C#: Delegate דלגייט - "נציגים"

dovid

[u:1k4ychdj][size=150:1k4ychdj]1. רקע[/u:1k4ychdj][/size:1k4ychdj]
פירוש המילה היא נציג. כלומר במקום לבוא במגע עם המתודה, יש לנו אובייקט שמייצג אותה, אפשר "לומר לו", והוא כבר יפעיל את המתודה המקורית.
נגיד יש לנו מתודה שמדפיסה על המסך "123"
אז כשאנו מציבים אותה ב"נציג" היינו הDelegate, אז יש לנו פונקציונליות ביד. אנו יכולים להכניס אותה למשתנה, למאפיין, לשלוח את זה כפרמטר לפונקציה והכל תחת הסוג ששמו Delegate.

אז הנה הדגמה לdelegate בצורתו הבסיסית, בשלוש צעדים:
א. מצהירים על הdelegate (כי כל Delegate נבדל מאחר בפרמטרים שהוא מקבל והטיפוס המוחזר).
ב. מאכלסים אותו - יוצרים מופע ממנו ובבנאי שלו שמים את שם המתודה שלנו.
ג. קוראים אליו משתמשים בו במקום במתודה המקורית

class Example
{
    //הצהרה על שמו+מה הוא מחזיר+מה הוא מקבל (במקרה זה כלום).
    delegate void MethodContainer();

    public Example()
    {
        //יצירת מופע מהדלגייט. בבנאי מעבירים כפרמטר שם של מתודה, אותה הוא "ייצג".
        MethodContainer i = new MethodContainer(Write123);
        //שימוש בו השקול לקריאה ישירה למתודה שהוא מחזיק
        i();
    }

    public void Write123()
    {
        Console.WriteLine("123");
    }
}

בהודעה הבאה אדגים בע"ה שימושים בDelegate.

פורסם במקור בפורום CODE613 ב18/07/2013 14:41 (+03:00)

dovid

[u:2eqoffeb][size=150:2eqoffeb]2. דוגמה בסיסית לנציג[/u:2eqoffeb][/size:2eqoffeb]
נניח אנו מפתחים מחלקה (למשל מחלקה שמשדרת לשב"א או כל פעולה ארוכה בסגנון).
המחלקה היא DLL דוטנטי טהור. ללא כל ייצוג גרפי.
אנו כותבי המחלקה, כותבים פרוצדורה ארוכה, שמורכבת מהרבה חלקים. מידי פעם אנו משחררים חיווי על המצב הנוכחי
(כמו: "מעבד נתונים...", "מבצע אימות...", "משדר...", "שודר בהצלחה!", "מחכה לתשובה...").
השאלה איפה להציג את החיווי הזה?

אז מאוד מתאים להשתמש בDelegate:

public delegate void StatusMessage(string message);

/// <param name="messageHandel">נציג של מתודה לטיפול בהודעות הסטטוס</param>
public void GoSendData(DataTable data, StatusMessage messageHandel)
{
    //....פעולות
    messageHandel("כעת אוכל דגים...");
    //....פעולות
    messageHandel("כל הדגים נאכלו. מתכונן למנה הבאה...");
    //....
}

כעת הנה קוד בו אנחנו או מתכנת שקנה/קיבל מאיתנו את המחלקה דלעיל כDLL, משמשים בה, ומציגים את ההודעות במקום שנראה לנכון, במקרה זה אפילקציית וינדוס ואנו רוצים שההודעות יופיעו בליסט בוקס:

public UseClass()
{
    var shidur = new ShidurShva();
    shidur.GoSendData(dt, new ShidurShva.StatusMessage(ShowMessage));
}

public void ShowMessage(string message)
{
    //שם במקרה זה את הודעת המצב בליסט בוקס
    ListBoxLog.Items.Add(message);
}

[size=85:2eqoffeb][u:2eqoffeb]במאמר המוסגר:[/u:2eqoffeb]

**הדוגמה הציגה מצוקה שצריכה פיתרון. המצוקה לא לגמרי נכונה כי האמת שהכי פשוט זה לכתוב לקונסול (Console.WriteLine) והמתכנת שיעשה שימוש במחלקה יכול להפנות את הפלט לאיפה שירצה, אבל למען יופי הדוגמה נניח לא הייתה כזאת מחלקה כלל.
מתכנתים רבים יחשבו "זה ממש אירוע קלאסי" ויתהו למה לא ליצור אירוע של התקדמות עם ארוגמנט למצב (או מאפיין סטרינג עם המצב האחרון ואירוע שמתריע על שינויו). אז נא לזכור שאירוע זה דלגייט בשינוי אדרת... נדבר על כך בהמשך.**
[/size:2eqoffeb]

פורסם במקור בפורום CODE613 ב19/01/2014 13:46 (+02:00)

dovid

[u:2qcedb8a][size=150:2qcedb8a]3. דוגמה נוספת[/u:2qcedb8a][/size:2qcedb8a]
הדוגמה האחרונה הייתה על Delegate עבוד מתודה ללא פרמטרים וללא ערך מוחזר. כעת נראה דוגמה זה יש ערך מתקבל וערך מוחזר:
נניח אנחנו מפתחים פקד טקסטבוקס משוכלל עם אפשרויות מתקדמות.
אחת השכלולים שעשינו בו זה ולידציה, הפקד נניח מסמן באדום נתונים לא תקפים.
אבל מהו נתון לא תקף? אם זה ת.ז. יש נוסחה אחת, אם זה משהו אחר יש נוסחאות אחרות.
ואנחנו כמובן "משאירים את זה פתוח" למתכנת (זה ע"פ רוב אנחנו בעצמנו...) שישתמש בפקד הזה, שהוא יקבע לפי השימוש והעניין מה הנוסחה.
איך הוא יקבע?
עם דלגייט זה מאוד פשוט. במחלקה יהיה קוד דומה לזה:

//הצהרה סוג
public delegate bool ValidUserInput(string message);

//הצהרת מופע - בינתיים הוא ריק
public ValidUserInput FunctionToValidate { get; set; }

//פוקנציה שמופעלת מתי שצריל לבדוק את קלט המשתמש, אם הקלט לא תקני היא צובעת את הפקד באדום
void vaildateInput()
{
    if (FunctionToValidate != null)
        if (FunctionToValidate(faturedTextBox.Text) == false )
            faturedTextBox.Background = Red;
}

בצד המשתמש, כלומר מי שישתמש במחלקתנו, ושוב ושוב אדגיש שזה כולל אותנו (כעובדים נכון וממדרים פרוייקטים)
אז המשתמש הזה משתמש בפקד בכל מיני מקומות לכל מיני מטרות. פעם לחשבון בנק, פעם לת.ז. וכו'.
האחריות על הפוקנציה לבדיקת התקינות בהכרח מוטלת עליו, רק הוא יודע מתי לעשות איזה אימות (מילים נרדפות: אימות, תיקוף, ולידציה).
אז נניח מקרה שהוא משתמש בפקד שלנו בשביל להציג 4 ספרות אחרונות של מס' אשראי, והנה הפונקציה שהוא הכין:

//פונקציה לאימות 4 ספרות אחרונות של כרטיס אשראי
bool Check4DigitNum(string str)
{
    int ParserValue;
    return int.TryParse(str, out ParserValue) && ParserValue > 0 && ParserValue < 10000; 
}

הוא צריך רק להגדיר את הדלגייט של המחלקה, שיכיל את הפונקציה שלנו:

FaturedTextBox1.FunctionToValidate = new FaturedTextBox.ValidUserInput(Check4DigitNum);

פורסם במקור בפורום CODE613 ב22/01/2014 16:30 (+02:00)

dovid

[u:1nxlzsw8][size=150:1nxlzsw8]4. הצבה בדלגייט בצורה הצהרתית[/u:1nxlzsw8][/size:1nxlzsw8]
נחזור לדוגמה ראשונה היה שמה כזה קוד:

delegate void MethodContainer();

public Example()
{
    MethodContainer i = new MethodContainer(Write123);
    i(); 
}
 
public void Write123()
{
    Console.WriteLine("123");
}

ההצבה נעשתה ע"י בנאי שמקבל כפרמטר שם של מתודה.
כעת שימו לב, לא צריך בכלל בנאי. למה? כי שם מתודה הוא עצמו "ליטרל".

מה זה ליטרל?? סטרינג לדוגמה יכול להופיע כפי שהוא בקוד, בלי צורך בNEW בהצבתו. איך? מוקף במרכאות כפולות. קוראים לזה ליטרל (מאחורי הקלעים נוצר אובייקט עם NEW שמכיל אותו!).
אותו הדבר Char יכול להופיע כמו שהוא מוקף במרכאה בודדת (בVB גם במרכאות כפולות שאחריהם מייד שמים את האות c). לעמות זאת בDateTime ובאלפי מחלקות אחרות, אין ליטרל. אין שום אפשרות ליצור עצם בקוד (קוד הצהרתי) בלי לעשות זאת מפורשות (קוד פונקציונלי). אגב, בVB יש כן ליטרל לתאריך ע"י תאריך בפורמט MM\DD\YYYY מוקף בסולמיות, אנשי C# תקנאו אבל לעניין הנושא המדובר זה להיפך: בVB שם מתודה איננה ליטרל...

וזה אומר שכשמופיע בקוד שם מתודה, הקומפיילר מתרגם זאת לאובייקט מסוג delegate. אתם עלולים לשאול איזה delegate שהרי הצהרת delegate חייבת לכלול פרמטרים נדרשים וערך מוחזר. התשובה היא שהקומפיילר מסיק את סוג הdelegate לפי חתימת המתודה שנקבנו בשמה.
הנה המסקנות בקוד, בשלב הראשון נסיק שאפשר לכתוב ככה:

public delegate void MethodContainer();

public Example()
{
    MethodContainer i = MyMethod;
    i();
}

הנה, לא השתמשנו בכלל בNEW.

פורסם במקור בפורום CODE613 ב30/01/2014 14:41 (+02:00)

dovid

[u:2o9o2tow][size=150:2o9o2tow]5.MulticastDelegate, וסיום המדריך [/u:2o9o2tow][/size:2o9o2tow]
הDelegate בדוט נט הם Multicast כלומר נציג אחד יכול להכיל הפנייה להרבה מתודות.
הנה דוגמה, במקרה זה יודפס פעמיים 123.

public Example()
{
    MethodContainer i = MyMethod;
    i = i + MyMethod;
    i();
}

void MyMethod() { Console.WriteLine("123"); }

אפשר להשתמש גם באופרטור המוכר +=, וגם ב-= להסיר מתודה כל שהיא, ממכלול המתודות. האופרטורים האלו עובדים גם כשהאובייקט ריק.
שימו לב שהדוגמה עסקה במתודת void.
במקרה של מתודה שמחזירה ערך זה חסר טעם, וזה מחזיר את הערך של הפונקציה האחרונה שהוכנסה.

טוב, סיימנו מדריך על נציגים, בע"ה מדריך הבא יהיה על אירועים.

פורסם במקור בפורום CODE613 ב05/02/2014 15:25 (+02:00)

תחומים - פורום חרדי מקצועי

C#: Delegate דלגייט - "נציגים"