AnonymousMethods

סגור באמצעות טופס זה תוכלו לספר ולהמליץ לחבריכם..
שם השולח:
כתובת דוא"ל של השולח:
שם המקבל:
שלח לכתובת דוא"ל:
הוסף הערה:
QR
מאמר קצר המסביר את השימוש במתודות אנונימיות (Anonymous Methods) ב- Delegate וב- Events.
 
מאמר בנושא Anonymous Methods Anonymous Methods

מאת: ארז קלר

הורדת דוגמאות קודהורדת דוגמאות קוד 

delegates מכילים ייחוס למתודות בעלות אותה החתימה של ה-delegate.
בשימוש רגיל ב-delegate ישנן שתי ישויות: המתודה עצמה וה-delegate שעוטף אותה.
ניתן להפעיל את המתודה ישירות באמצעות שמה או בעקיפין באמצעות הפעלת ה-delegate.
באמצעות Anonymous Methods ניתן לאחד את שתי הישויות לישות אחת תחת ה-delegate.
אם בשימוש ב- delegate רגיל ניתן היה להפעיל את המתודה ישירות, באמצעות שימוש ב-Anonymous Methods ניתן להפעיל אותה רק באמצעות ה-delegate.

 1  : using System; 
 2  : using System.Collections.Generic; 
 3  : using System.Net.NetworkInformation; 
 4  : using System.Text; 
 5  :  
 6  : namespace AnonymousMethod01 
 7  : { 
 8  :     delegate void MyDelgate(); 
 9  :     class Program 
 10 :     { 
 11 :         static void Main(string[] args) 
 12 :         { 
 13 :             // Old Fashion delegate 
 14 :             MyDelgate my_delegate1 = DoSomething; 
 15 :             my_delegate1(); 
 16 :  
 17 :             // Anonymous Method delegate 
 18 :             MyDelgate my_delegate2 = delegate()  
 19 :             {  
 20 :                 Console.WriteLine(invoke delegate using anonymous method);  
 21 :             }; 
 22 :             my_delegate2(); 
 23 :         } 
 24 :         public static void DoSomething() 
 25 :         { 
 26 :             Console.WriteLine(Invoke delegate in the old fashion way);  
 27 :         } 
 28 :     } 
 29 : } 
דוגמת הקוד הפשוטה מציגה הגדרה, רישום והפעלה של delegate בשתי דרכים:
תחילה, בשיטה הקלאסית שהוצגה בגרסה הראשונה של השפה, שיטה שדורשת הגדרת delegate, הגדרת מתודה וחיבור ביניהם.
בשיטה זו לא ניתן למנוע קריאה ישירה למתודה ללא שימוש ב-delegate.
באמצעות שימוש ב-Anonymous Methods לא נדרש להגדיר מתודה בצורה מפורשת,  
אלא כותבים מקטע קוד אשר ירוץ בכל פעם שה-Delegate יופעל,
הקומפיילר כבר יודע לייצר את המתודה בזמן קומפילציה.
מכיוון שהמתודה לא עצמאית, אין לה שם מפורש, לא ניתן להפעיל אותה שלא באמצעות ה-delegate.
קוד ה-MSIL של Anonymous Methods

מפיענוח קוד ה-MSIL שנוצר באמצעות הקומפיילר ניתן להבחין בבירור במתודה הרגילה שנוצרת מהמתודה האנונימית.
ניתן להבין מכך ש-Anonymous Methods זו תכונה של שפת C# ולא יכולת חדשה של .NET Framework


מתודה אנונימית עם פרמטרים

כמו בגרסה המסורתית של הגדרה ושימוש ב-delegate גם ב- Anonymous Methods נדרש לעיתים להעביר פרמטרים בהפעלת ה-delegate ולקבל ערך מוחזר.
 1  : using System; 
 2  : using System.Collections.Generic; 
 3  : using System.Text; 
 4  :  
 5  : namespace AnonymousMethod02 
 6  : { 
 7  :     delegate double MyDelegate(double num1,double num2); 
 8  :     class Program 
 9  :     { 
 10 :         static void Main(string[] args) 
 11 :         { 
 12 :             MyDelegate mul_delegate = delegate(double num1, double num2) 
 13 :             { 
 14 :                 return num1 * num2; 
 15 :             }; 
 16 :             double result = mul_delegate(10,20); 
 17 :             Console.WriteLine(result); 
 18 :         } 
 19 :     } 
 20 : } 


מתודה אנונימית עם Multicast
delegates ב-.Net Framework  הינם למעשה Multicast Delegates,
המשמעות היא שמופע של delegate יכול להתייחס ולהפעיל מספר מתודות ולא מוגבל רק מתודה יחידה.
delegate מכיל רשימה של ייחוסים למתודות.
הדוגמה הבאה מציגה מימוש של Multicast Delegate באמצעות Anonymous Methods:
 1  : using System; 
 2  : using System.Collections.Generic; 
 3  : using System.Text; 
 4  :  
 5  : namespace Anonymous_Method03 
 6  : { 
 7  :     delegate void MyDelegate(double num1, double num2); 
 8  :     class Program 
 9  :     { 
 10 :         static void Main(string[] args) 
 11 :         { 
 12 :             MyDelegate calculation_delegate = delegate(double num1, double num2) 
 13 :             { 
 14 :                 Console.WriteLine(Mul = {0}, num1 * num2); 
 15 :             }; 
 16 :             calculation_delegate += delegate(double num1, double num2) 
 17 :             { 
 18 :                 Console.WriteLine(Sum = {0}, num1 + num2); 
 19 :             }; 
 20 :             calculation_delegate += delegate(double num1, double num2) 
 21 :             { 
 22 :                 Console.WriteLine(Sub = {0}, num1 - num2); 
 23 :             }; 
 24 :             calculation_delegate += delegate(double num1, double num2) 
 25 :             { 
 26 :                 Console.WriteLine(Div = {0}, num1 / num2); 
 27 :             }; 
 28 :              
 29 :             calculation_delegate(10, 20); 
 30 :         } 
 31 :     } 
 32 : } 
שורה 12  - ייחוס המתודה האנונימית הראשונה ל-delegate.
שורות 24,20,16 – ייחוס המתודות הנוספות ל-delegate.
שורה 29 – הפעלת ה-delegate גורמת לכל המתודות המיוחסות ל-delegate לפעול סינכרונית.
פלט:
פלט דוגמת הקוד



מתודה אנונימית עם אירוע
השימוש הנפוץ ב-delegate הוא בהגדרת והפעלת אירועים, דוגמת הקוד הבא מציגה זאת:
 1  : using System; 
 2  : using System.Collections.Generic; 
 3  : using System.Linq; 
 4  : using System.Text; 
 5  : using System.Threading.Tasks; 
 6  :  
 7  : namespace AnonymousMethods04 
 8  : { 
 9  :     delegate void MyDelegate(string msg); 
 10 :     class Program 
 11 :     { 
 12 :         public static event MyDelegate MyEvent; 
 13 :         static void Main(string[] args) 
 14 :         { 
 15 :             MyEvent += delegate(string msg) 
 16 :             { 
 17 :                 Console.WriteLine(msg1 : {0}, msg); 
 18 :             }; 
 19 :             MyEvent(Event Invoked); 
 20 :         } 
 21 :     } 
 22 : } 



כל הזכויות שמורות למחבר ©