Lekce 1 - Úvod do kolekcí a genericita
V dnešní lekci si řekneme úvodní teorii ke kolekcím v C# .NET, které si v tomto kurzu podrobněji rozebereme.
Kolekce
Pojem kolekce označuje soubor dat, které jsou většinou stejného typu a
slouží ke specifickému účelu. Během seriálu jsme se již setkali se
dvěma typy kolekcí, bylo to pole a List
. Kolekcí existuje velké
množství a ačkoli se zvenku mnohdy tváří podobně, uvnitř fungují velmi
odlišně a vybíráme si je podle konkrétního účelu. .NET disponuje velkým
množstvím předpřipravených kolekcí, se kterými se v této sekci postupně
seznámíme a zkusíme si s nimi pracovat.
Generické a obecné kolekce
Když se zamyslíme nad tím, jak bychom si udělali vlastní kolekci, jistě
bychom po nějaké době dospěli k problému. Byl by jím datový typ kolekce.
Chtěli bychom si např. naprogramovat vlastní List
, vytvořili
bychom třídu MujList.cs
, do ní přidali příslušné metody a
vše potřebné. Protože však chceme, aby byla naše kolekce univerzální a
uměla tedy ukládat např. jak int
y, tak uživatele, bude problém
s datovým typem prvků uvnitř kolekce. Existují 2 varianty, jak tento
problém vyřešit a i samotný .NET obsahuje kolekce těchto 2 typů.
Obecné kolekce
Jelikož víme, že všechny datové typy mají jako předka třídu
Object
, můžeme prvky v naší kolekci ukládat právě do tohoto
datového typu. Do kolekce nyní můžeme uložit v podstatě cokoli. Nevýhodou
je, že sama kolekce skutečný datový typ prvků nezná a proto umí prvky
navracet jen jako obecné objekty. Po získání prvku z kolekce si jej tedy
musíme přetypovat.
Uveďme si příklad negenerické kolekce, je jí ArrayList
:
using System.Collections;
{CSHARP_CONSOLE}
ArrayList list = new ArrayList();
list.Add("položka");
string polozka = (string)list[0];
Console.WriteLine(polozka);
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikace
položka
Po vytvoření listu si do něj přidáme položku typu string
.
Abychom tuto položky mohli z listu získat zpět, je třeba ji na
string
zpětně přetypovat.
Pro funkčnost kódu musíme přidat using System.Collections;
.
Jelikož tento jmenný prostor není ve výchozím projektu přítomen,
napovídá nám to, že negenerické kolekce nebudou ta obvyklá volba.
Generické kolekce
Generické kolekce řeší problém s datovým typem na úrovni jazyka C#.
Zavádí tzv. genericitu. Zjednodušeně řečeno se jedná o možnost
specifikovat datový typ až ve chvíli vytvoření instance. Ve třídě
samotné kolekce se poté pracuje s generickým typem, který slouží jako
zástupce pro budoucí datový typ. Můžeme si to představit tak, že se
generický typ ve třídě změní např. na string
ve chvíli,
když vytvoříme její instanci. Jedná se tedy o možnost třídy nějakým
způsobem parametrizovat.
Generický List
již známe a onen datový typ (parametr) se
generickým třídám specifikuje ve špičatých závorkách. Máme možnost
specifikovat datový typ pouze jednou, při vytvoření kolekce. Jakékoli
další přetypování odpadá:
{CSHARP_CONSOLE}
List<string> list = new List<string>();
list.Add("položka");
string polozka = list[0];
Console.WriteLine(polozka);
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikace
položka
Program funguje úplně stejně, jako ten s negenerickou kolekcí
ArrayList
, nicméně číst můžeme bez nepohodlného
přetypování.
Generické kolekce nahradily kolekce obecné a ty se již příliš nepoužívají. V kurzu se budeme věnovat generickým kolekcím a jejich negenerické verze pouze zmíníme.
Genericita
Genericita je samozřejmě vlastnost jazyka C# a my ji máme možnost ve svých třídách používat.
Zatím se nebudeme zatěžovat tvorbou vlastní kolekce. Vytvořme si
třídu, která bude jednoduše spravovat jednu proměnnou. Proměnná bude
generická, tedy libovolného datového typu. Založte si nový projekt,
konzolovou aplikaci s názvem Genericita
. Přidejte si novou
třídu, pojmenujme ji nyní pro studijní účely pouze Trida
. V
její deklaraci přidáme generický parametr, který pojmenujeme
T
:
public class Trida<T> { }
Generických parametrů můžeme zadat ve špičatých závorkách více, oddělíme je čárkou. Někdy se to může hodit, my se s tím setkáme dále u generických slovníků.
Přesuneme se do metody Main()
, kde si vytvoříme instanci
naší třídy:
Trida<int> instance = new Trida<int>();
Nezapomeneme na špičaté závorky jak u datového typu, tak u konstruktoru.
Nyní jsme parametru T
v této instanci třídy určili datový typ
int
. Stejně tak si můžeme udělat další instanci té samé
třídy a parametru T
dát úplně jiný datový typ, např.
string
. Stačí nám tedy 1 třída pro více datových typů.
Pokračujme a vytvořme si ve třídě atribut. T
můžeme
použít jako běžný datový typ:
private T promenna;
Třídě ještě dodáme konstruktor, který proměnnou inicializuje:
public Trida(T promenna) { this.promenna = promenna; }
V Main()
aktualizujeme vytvoření instance:
Trida<int> instance = new Trida<int>(10);
Nyní instance obsahuje atribut promenna
, který je typu
int
a nabývá hodnoty 10
.
Můžeme dokonce přidat metodu, která bude mít navíc další generický parametr (jiný, než má třída). Mohla by vypadat např. takto:
public bool Porovnej<T2>(T2 a) { return promenna.Equals(a); }
Zkusíme si tedy porovnat náš int
s nějakým jiným
typem:
{CSHARP_CONSOLE} Trida<int> instance = new Trida<int>(10); bool stejne = instance.Porovnej<string>("15"); Console.WriteLine(stejne); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Trida<T> { private T promenna; public Trida(T promenna) { this.promenna = promenna; } public bool Porovnej<T2>(T2 a) { return promenna.Equals(a); } } {/CSHARP_OOP}
Výstup programu:
False
Další konstrukce
Pro úplnost si ještě uveďme několik konstrukcí.
Generický parametr třídy je možné blíže specifikovat, přesněji
omezit. Slouží k tomu klíčové slovo where
. Můžeme tak
nastavit, že udaný datový typ musí např. obsahovat rozhraní
IComparable
:
public class Trida<T> where T: IComparable { ... }
Díky tomu můžeme na proměnných typu T
nyní uvnitř třídy
volat metody z daného rozhraní. Samotné rozhraní může opět obsahovat
generický parametr, abychom generické typy mohli používat i v hlavičkách
jeho metod.
Když uvedeme za where
ještě new()
, můžeme
uvnitř typ T
instanciovat. Taková malá továrna na instance
libovolného typu by mohla vypadat takto:
public class Tovarna<T> where T : new() { public T VytvorInstanci() { return new T(); } }
Pokud máme ve where
již nějaká rozhraní, new()
dáme jednoduše mezi ně a oddělíme čárkou.
Nakonec si ukažme, jak můžeme typ parametru omezit z hlediska dědičnosti:
public class Trida<A, B, C> where A : B where B : C { }
Výše jsme deklarovali třídu se třemi generickými parametry, kde
A
je potomkem B
a B
je potomkem
C
.
V příští lekci, Seznam (List) pomocí pole v C#, se podíváme na listy, představíme si různé implementace této kolekce a jejich výhody a nevýhody.
Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.
Stáhnout
Stažením následujícího souboru souhlasíš s licenčními podmínkami
Staženo 735x (21.23 kB)
Aplikace je včetně zdrojových kódů v jazyce C#