>>Anonymné metódy
sú zaujímavou novinkou v .NET 2. Pamätáte si na niektorý z predchádzajúc článkov, kde som písal, že jedno z použití delegátov je, že umožňujú predávať ako parameter metódy inú metódu? Zdalo sa Vám to zo začiatku zložite? Teraz Vám poviem, že anonymné metódy umožňujú, aby parametrom metódy boli priamo príkazy v jazyku C# (či inom pre .NET).
Ja som za to, aby sme hneď prešli na príklad, aby ste si vedeli predstaviť o čom to tu hovorím.Takže :
Príklad 16.1
//--------------------------------------
using System;
class MainClass
{
delegate int RobNieco(int cislo);
public static void Main(string[] args)
{
// 1. sposob
RobNieco anonym =
delegate(int i){ return i * i; };
delegate(int i){ return i * i; };
Console.WriteLine(" i = {0}",anonym(5));
// 2. sposob
RobViacKrat(delegate(int i){ return i*i;},5);
Console.ReadLine();
}
//--------------------------------------------------------
private static void RobViacKrat(RobNieco func,int n)
{
for(int i =0; i < n; i++) {
Console.WriteLine(" i = {0}",func(i));
}
}
}
//--------------------------------------- V príklade sú použité dva spôsoby použitia anonymnej metódy.
1.Spôsob – vytvoríme inštanciu delegáta, pomocou anonymnej metódy. Stačí napísať priamo kód, či príkazy do bloku za definíciu delegáta. V našom prípade return i*i.
T.j. nemusíme najprv vytvárať metódu, ktorá obsahuje potrebný kód a potom na ňu predávať referenciu pre delegáta.
Namiesto RobNieco anonym = new RobNieco( … ); // Klasicky
použijeme RobNieco anonym = dekegate(int i) { return i*i};
Takže vidíte, že potrebujeme použiť kľúčové slovíčko delegate, uviesť do okrúhlych zátvoriek vstupné parametre a do zložených (brčkavých) zátvoriek priamo príkazy.
2. Spôsob – sme použili, keď sme potrebovali predať delegáta ako argument metódy RobViacKrat. Tu taktiež vložíme na miesto parametru priamo príkazy zo syntaxou
ako v 1. spôsobe. Samotnú metódu už nezaujíma, či používame anonymnú metódu alebo nie a pracuje so syntaxou ako u normálnych delegátoch.
V skutočnosti kompilátor automaticky vytvorí nejakú metódu, ktorá obsahuje kód našej anonymnej metódy a delegáta odkazuje na ňu. Takže nemôžeme asi čakať nárast rýchlosti spracovania príkazov, tým že sa vynechá volanie metódy a administrácia s tým spojená na úrovni CPU a OS. Hovorím ASI, pretože by to chcelo urobiť testy. Pozrite sa na obr. aspoň na disassamblovaný MSIL jazyk.
ako v 1. spôsobe. Samotnú metódu už nezaujíma, či používame anonymnú metódu alebo nie a pracuje so syntaxou ako u normálnych delegátoch.
>>Sú anonymné metódy inline?
Túto otázku si určite kladú programátori v C++. Mám dobú aj zlú správu. To že použijete anonymnú metódu neznamená, že sa jej kód (telo) rozbalí v miestach volania. V skutočnosti kompilátor automaticky vytvorí nejakú metódu, ktorá obsahuje kód našej anonymnej metódy a delegáta odkazuje na ňu. Takže nemôžeme asi čakať nárast rýchlosti spracovania príkazov, tým že sa vynechá volanie metódy a administrácia s tým spojená na úrovni CPU a OS. Hovorím ASI, pretože by to chcelo urobiť testy. Pozrite sa na obr. aspoň na disassamblovaný MSIL jazyk.
Na obrázku vidíte, že podľa toho, či sa anonymná metóda používa v statickej alebo obyčajnej metóde, kompilátor automaticky vytvorí pre seba zapovedajúcu skrytú metódu.
Keďže použitím anonymných metód sa zrýchlenia asi nedočkáme, dobrou správou aspoň je, že anonymné metódy nám umožňujú (okrem hore uvedených príkladov) robiť zaujímavé finty, ktoré sa s inline funkciami nedajú. Veď čítajte ďalej.
>>Oblasť platnosti premenných.
Zaujímalo ma, ako je to viditeľnosťou/platnosťou premenných v nadradenom bloku anonymnej metódy. Tak som spravil tento malý príklad:
Príklad 16.2
//---------------------------------------
using System;
class MainClass
{
delegate int MojDelegat();
private static MojDelegat anonym;
public static void Main(string[] args)
{
Console.WriteLine("Zavolame metodu PokusnaM..");
Console.WriteLine(" i = {0}",PokusnaMetoda());
Console.WriteLine("Po skonceni PokusnaM...");
int i = anonym();
Console.WriteLine(" i = {0}",i);
Console.ReadLine();
}
//-------------------------------------------------------
public static int PokusnaMetoda()
{
int i = 5;
anonym = delegate()
{
return i; // nadradena premanna
};
Console.Write("Zadajte cislo :");
string text = Console.ReadLine();
i = int.Parse(text);
return i;
}
}
//---------------------------------------
To je sila čo? Všimli ste si, čo sme dokázali pomocou anonymnej metódy? Ak nie, poďme sa na to pozrieť krok po kroku:
V prvom kroku sme klasicky zavolali metódu PokusnáMetóda(). V nej sa na začiatku vytvorí inštancia delegáta s menom anonym. Potom sa načíta číslo z klávesnice a uloží sa do lokálnej premennej i a zároveň sa i vráti na výstupe. A vrátime sa späť do Main().
Zavoláme anonymnú metódu, na ktorú odkazuje, v predchádzajúcom kroku naplnený delegát - anonym a teraz sa to stane :-)
Anonymná metóda má dosah aj na premenné v jej nadradenom bloku, t.j. v metóde, kde bola vytvorená inštancia daného delegáta.. V našom prípade nám vráti obsah premennej i, ktorú sme naplnili v predchádzajúcom volaní metódy PokusnaMetoda().
Funguje to tak, že všetky premenné z nadradeného bloku, ktoré sa používajú v anonymnej metóde, zostanú v platnosti aj po ukončení metódy. T.j. Garbage Collector s tým ráta a nechá ich existovať. Preto je potrebné s týmto faktom rátať a dávať si pozor s akými veľkými premennými budeme narábať v tele anonymnej metódy, aby sme zbytočne neplytvali zdrojmi OS.
>>Záver
V prvom kroku sme klasicky zavolali metódu PokusnáMetóda(). V nej sa na začiatku vytvorí inštancia delegáta s menom anonym. Potom sa načíta číslo z klávesnice a uloží sa do lokálnej premennej i a zároveň sa i vráti na výstupe. A vrátime sa späť do Main().
Zavoláme anonymnú metódu, na ktorú odkazuje, v predchádzajúcom kroku naplnený delegát - anonym a teraz sa to stane :-)
Anonymná metóda má dosah aj na premenné v jej nadradenom bloku, t.j. v metóde, kde bola vytvorená inštancia daného delegáta.. V našom prípade nám vráti obsah premennej i, ktorú sme naplnili v predchádzajúcom volaní metódy PokusnaMetoda().
Funguje to tak, že všetky premenné z nadradeného bloku, ktoré sa používajú v anonymnej metóde, zostanú v platnosti aj po ukončení metódy. T.j. Garbage Collector s tým ráta a nechá ich existovať. Preto je potrebné s týmto faktom rátať a dávať si pozor s akými veľkými premennými budeme narábať v tele anonymnej metódy, aby sme zbytočne neplytvali zdrojmi OS.
>>Záver
Anonymné metódy môžu sprehľadniť a zjednodušiť program len ak ich telo je veľmi malé. Umožňujú používať premenné s tiel iných metód aj po ich skončení, čo je silný nástroj. Ale ako sme si povedali, každá z týchto „vymožeností“ má aj svoju tienistú stránku. Takže používajte anonymné metódy opatrne a hlavne s rozvahou.
>>Čo bude nabudúce?
Hádam aj posledný diel o udalostiach, kde dáme dokopy všetky čiastkové nadobudnuté vedomosti.
>>Predchádzajúce diely:
Programujeme v jazyku C# II. Diel 15. – Udalosti IV.
Programujeme v jazyku C# II. Diel 14. – Udalosti III
Programujeme v jazyku C# II. Diel 13. – Udalosti II
Programujeme v jazyku C# II. Diel 12. – Udalosti I
Programujeme v jazyku C# II. Diel 11. – yield
Michal Čižmár
micitn@orangemail.sk
micitn@orangemail.sk
