Ako som už povedal, Generics je výborná vec, ale použiteľná až od verzie
.NET Framework v2.0. Uvedomil som si, že ešte veľa programátorov používa .NET 1.1, či už z dôvodov jeho väčšieho rozšírenia (WinXp SP1 ho už obsahuje) alebo tým, že vo Visual Studio 2003 sa nedá ľahko zmeniť kompilátor na inú verziu.
>>Ako na genericitu bez Generics v .NET 1.1?
Možno, že sa Vám to bude zdať zvláštne, ale riešením je dedičnosť (samozrejme ako programátorský nástroj). O tej sme sa bavili v kapitole OOP (objektovo orientovane programovanie) v minulej sérii.
1) Všetky objekty v C# (triedy aj dátové typy) majú jedného spoločného predka a to triedu object.
2) Polymorfizmus funguje tak, že predok môže zastúpiť všetkých svojich potomkov.
To znamená, že všade tam, kde ako parameter metódy alebo triedy budete chcieť použiť ľubovoľný dátový typ (podstata Generics), môžete ako parameter zadefinovať triedu object.
Problém je v tom, že pri implicitnom pretypovaní (t.j. zariadi to C# a nie programátor) na object (pozrite do príkladu) sa stráca informácia o pôvodnom type objektu.
Teda ak metóda aj vracia nejaký výstup, je potrebné explicitné (napr. (int) object) pretypovanie na pôvodný dátový typ.
Týmto spôsobom si musí programátor strážiť o dva úkony na viac a pri častom opakovaní to aj značne spomaľuje program, oproti tomu, keby sme použili .NET 2 a Generics, kde sa žiadne pretypovanie (ani len vnútorné) nedeje.
Všetko toto oveľa lepšie strávite ak sa dobre pozrite na príklad dole. Použil som ten istý typ príkladu ako na začiatku kapitoly o Generics, až na to, že som použil object a spätné pretypovanie. Príklad demonštruje metóda Zamen, ktorá zamieňa obsah svojich dvoch parametrov, ktoré sú zadefinované ako typ object, čo umožňuje dosadiť ľubovoľný iný typ odvodený od object (teda čokoľvek :-) )
Príklad 10.1
using System;
using System.Collections.Generic;
//--------------------------------------
class MainClass
{
public static void Main(string[] args)
{
int i = 5; object i_object = (object) i ;
int j = 10; object j_object = (object) j;
Console.WriteLine(" Pred zamenou i ={0}, j ={1}",i,j);
object temp_i = i; // Pretypovanie na spolocneho
object temp_j = j; // predka object
Zamen( ref temp_i , ref temp_j);
i = (int) temp_i; // Pretypovaním obnovíme
j = (int) temp_j; // inf. o povodnom type
Console.WriteLine(" Po zamene i ={0}, j ={1}",i,j);
Console.ReadKey();
}
public static void Zamen(ref object o1,ref object o2)
{
object temp; // Tato metoda
temp = o1; // zamiena obsah lubovolnych
o1 = o2; // datovych typov
o2 = temp;
}
}
//------------------------------------
>>A čo z generickými triedami?
Väčšinu generických tried, o ktorých som písal v minulých dieloch môžete použiť aj v .NET v 1.1. Je to možné, pretože majú svoje (nie úplne generické) predchodkyne v knižniciach (priestore mien) System.Collections.
Na príklade si ukážeme ako môžeme pracovať s triedou Stack tentoraz z Collections, ktorej generickú verziu sme podrobne rozobrali minule.
Príklad 10.2
using System;
using System.Collections;
//---------------------------------------
class MainClass
{
public static void Main(string[] args)
{
Stack zasobnik = new Stack();
zasobnik.Push("slovo 1");
// Pretypovanie
string vystup = (string) zasobnik.Pop();
Console.WriteLine("V zasobniku bolo {0}",vystup);
Console.ReadKey();
}
}
//--------------------------------------
Všimnite si v príklade, že po vybratí prvku zo zásobníka pomocou metódy Pop(), som explicitne pretypoval výstup pomocou (string) na pôvodný dátový typ.
Poznámka : Trochu skúsenejší programátori v C# si určite všimli, že v skutočnosti pre náš konkrétny prípad, kde sa prvok po vybratí iba vypisuje, nie je potrebné pretypovanie.
Prečo? Pretože, pre vypisovanie sa volá metóda ToString() a tú má v sebe aj samotná trieda object, aj trieda string. Ak by sme ďalej chceli využívať funkcie charakteristické pre triedu string, tak pretypovanie je už potrebné.
>>Náhrada za triedu List
Môžete použiť triedu ArrayList, ktorá funguje takmer rovnako. T.j. táto trieda funguje ako obyčajne pole až na to, že dokáže dynamicky zväčšovať svoju veľkosť. Na príklade si všimnite, že poznámka hore naozaj platí, teda ak sa budem snažiť pripočítať 1 k vybranému objektu, tak spätné pretypovanie na int je nevyhnutné. Pretože nie je definovaná operácia sčítania s typom object.
Príklad 10.3
using System;
using System.Collections;
//---------------------------------------
class MainClass
{
public static void Main(string[] args)
{
ArrayList pole = new ArrayList();
pole.Add(2006);
pole.Add(6002);
pole.Add(1000);
Console.WriteLine("Vypis pola po prve:");
for(int i = 0; i < pole.Count; i++)
Console.WriteLine("pole[{0}] ={1} ",i,
pole[i] );
pole[i] );
Console.WriteLine("Vypis pola po druhe:");
for(int i = 0; i < pole.Count; i++)
Console.WriteLine("pole[{0}] ={1} ",i,1 +
(int)pole[i] );
(int)pole[i] );
// jedine pomocou pretypovania
Console.ReadLine();
}
}
//---------------------------------------
>>Nenašiel som triedu Dictionary v .NET 1.1, čo teraz ?
Áno triedu s menou Dictionary v “dot net jednotke“ nenájdete. Možno akurát tak rozhranie IDictionary. Ako som hovoril, generická trieda Dictionary<T> je založená na hešovacej tabuľke a tá v .NET 1.1 existuje. Takže stačí namiesto Dictionary<T> použiť HashTable, s ktorou sa pracuje takmer rovnako. Takže tu príklad ani netreba dávať.
NEZABUDNITE!
Namiesto tried z System.Collections.Generics musíte v .NET 1.1 používať len triedy z System.Collections, čo nezabudnite na začiatku programu deklarovať pomocou using.
>>Čo bude nabudúce?
Dúfam, že autor diskusného príspevku, vďaka ktorému tento diel vznikol je spokojný (môžete zas napísať do diskusie). Nabudúce začneme úplne novú tému (kapitolu). Akú?
Sám neviem :-). Ak máte nejaký nápad napíšte mi, čo by Vás zaujímalo, alebo vymyslím niečo sám.
Sám neviem :-). Ak máte nejaký nápad napíšte mi, čo by Vás zaujímalo, alebo vymyslím niečo sám.
Michal Čižmár
micitn@orangemail.sk
