Programujeme v jazyku C# II. Diel 9. -- Generics V.

Michal Čižmár  /  22. 02. 2006, 00:00

Dnes si dáme ešte jeden príklad na triedu Dictionary, ktorú sme nestihli dokončiť minule. Zároveň sa pozrieme stručne na dve nové triedy Queue a Stack, ktoré sa používajú ako zásobníky typu LIFO a FIFO.

Minule som hovoril, že trieda Dictionary<T,T> sa chová zaujímavo, keď sa pokúsime vložiť do zoznamu prvok s rovnakým kľúčom.
 

Platí pravidlo: Každý kľuč v zozname musí byť originálny a môže mať len jednu priradenú hodnotu.

 

Ak toto pravidlo nedodržíme, vyvolá sa výnimka a tú ak nezachytíme, spadne celý program.

Preto je potrebné zisťovať, či už daný kľúč zoznam obsahuje a ak hej, môžeme ho len modifikovať. Ak ste zatiaľ nepochopili, pozrite sa na príklad 9.1.

 

Príklad 9.1

using System;
using System.Collections.Generic;

//-----------------------------------------------------------
class MainClass
{
   public static void Main(string[] args)
      {

      Dictionary<string,string> slovnik =

            new Dictionary<string, string>(5);
     
      slovnik.Add("house","dom");
     

      //slovnik.Add("house","dom, domacnost"); ZLE!!!!

      if (slovnik.ContainsKey("house") == true)
      {
            string value = slovnik["house"];
            // Modifikacia !!!!

            value = value + ", domacnost";
            // Puzitie indexera !!

            slovnik["house"] = value;
      }
     

      Console.WriteLine("Houseznamena:{0}",slovnik["house"]);

      Console.ReadKey();
      }
}
//----------------------------------------------------------


Príklad na stiahnutie.

 

Ak sa pokúsime pridať rovnaký kľúč pomocou Add(..), nastane táto chyba :

Add(..) je možne použiť iba na pridávanie nových prvkov

[...] – Indexer aj na modifikáciu prvku.

>>Trieda Queue<T>
Tieto posledné dve triedy Queue a Stack fungujú ako zásobníky. Nadajú sa použiť na náhodný výber prvkov. Ale sú veľmi dobré praktické, pre určitý typ algoritmov, kde by zlyhali ostatné generické triedy.

 Queue funguje ako buffer, kde prvý vložený prvok aj prvý vychádza. Takáto rada sa nazýva FIFO – First In First Out, Prvý dnu prvý von.

Na pridávanie a vyberanie prvkov používame hlavne tieto dve metódy :

Enqueue(T)  a Dequeue () ........... Pridanie a Vybranie


 

Príklad 9.2

using System;
using System.Collections.Generic;
//--------------------------------------------------------------
class MainClass
{
      public static void Main(string[] args)
      {

            // Vytvorenie rady, fronty

            Queue<string> rada = new Queue<string>(5);

           

            // Vkladanie prvkov

rada.Enqueue("Max Planc");

            rada.Enqueue("Niels Bohr");

            Console.WriteLine(" Fronta/rada (Queue) obsahuje");
           
            int pocet = rada.Count;

// Vyberanie prvkov
       for(int i = 0; i < pocet; i++)

                  Console.WriteLine(rada.Dequeue());
     
            Console.ReadLine();
      }
}
//--------------------------------------------------------------

Príklad na stiahnutie.


Hlavne si všimnite, že prvky sa vyberajú v tom istom poradí ako boli vkladané.

Ďalej je dôležité si uvedomiť, že každým zavolaním metódy Dequeue () sa zníži počet prvkov o 1.

 

Preto, ako vidíte v príklade 9.2, som so musel najprv uložiť aktuálny počet prvkov do pomocnej premennej pocet, ktorú som potom použil ako hornú hranicu v cykle for.

Možno, že sa Vám zdá táto poznámka zbytočná, ale snažím sa Vás vystríhať pred častou chybou. Ak by ste použili ako hornú hranicu cyklufor hodnotu rada.Count, vypísali by ste len polovicu prvkov, pretože táto hodnota by sa počas cyklu stále znižovala.

 

Metóda Peek() – (v príklade nie je použitá) Vám dá len jeden prvý prvok, ale nevyberie ho zo zoznamu.

 

>>Trieda Stack<T>

 Je podobná ako Queue, ale prvky sa vyberajú v opačnom poradí ako boli vkladané. Je to teda rada typu LIFO – Last In First Out – Posledný dnu prvý von.

 

Na pridávanie a vyberanie prvkov používame hlavne tieto dve metódy :

Push (T)  a Pop () ........... Pridanie a Vybranie

 



Príklad 9.3
using System;
using System.Collections.Generic;
//-----------------------------------------------------
class MainClass
{
      public static void Main(string[] args)
      {

            Stack<string> zasobnik = new Stack<string>(5);

            zasobnik.Push("Max Planc");

            zasobnik.Push("Niels Bohr");

           
            int pocet = zasobnik.Count;
            Console.WriteLine("Zasobnik (Stack) obsahuje:");

            for(int i = 0; i < pocet; i++)

                  Console.WriteLine(zasobnik.Pop());
 
            Console.ReadLine();
      }
}
//--------------------------------------------------------
Príklad na stiahnutie.


Všimnite si, že sa prvky naozaj vyberajú v opačnom poradí ako boli vkladané.

>>Zoznam všetkých generických tried

Collection<T>
ReadOnlyCollection<T>
Comparer<T>
EqualityComparer<T>

Dictionary<TKey, TValue>

KeyedCollection<TKey, TItem>

SortedDictionary<TKey, TValue>
SortedList<TKey, TValue>
List<T> 
LinkedList<T>
LinkedListNode<T>
BindingList<T>
Queue<T> 
Stack<T>

Ako vidíte, prebrali sme naozaj len základné generické triedy. Môj výber bol takýto, pretože ich považujem aj za najvyužiteľnejšie/najpraktickejšie triedy.

Z názvov ostatných tried je zrejmé, že sa ide už len o ich ďalšie špecializácie. Myslím si, že ak ste si dobre pozreli príklady z celej kapitoly Generics, máte dobrý prehľad a ste pripravení prakticky používať tento špeciálny typ tried alebo si v prípade núdze vytrvávať aj vlastné.

 

>>Čo bude nabudúce?

Na základe diskusného príspevku v niektorom z predchádzajúcich článkov som sa rozhodol pridať ešte jeden diel na tému Generics a to o ich používaní v .NET Framework 1.1 kde sa volajú Collections.

Uvidíte, že môžete použiť celú túto kapitolu aj keď robíte v C# 1.1, použitím malej modifikácie.

 

Píšte aj VY diskusné príspevky (hlavne konštruktívne) a môžete sa spoluúčastniť tvorby tohto seriálu!!!

 
Michal Čižmár
micitn@orangemail.sk


Neprehliadnite: