http://dl.dropbox.com/u/32154937/TCP-IP_Sockets_in_C%2523_Practical_Guide_for_Programmers.pdf

עמוד 117

public override IAsyncResult BeginRead(byte[ ] buffer, int offset, int size,
AsyncCallback callback, object state);
public override IAsyncResult BeginWrite(byte[ ] buffer, int offset, int count,
AsyncCallback callback, object state)

public override int EndRead(IAsyncResult asyncResult);
public override void EndWrite(IAsyncResult asyncResult)

למה שבמקום כל הבלבול מוח הזה אני פשוט לא יעשה thread חדש שיפעיל לי את הREAD וWRITE שם וזהו?

מה בעצם המטרה של הפיצול הזה של כל פעולה לשתי חלקים והחלק של הEND לא עושה כלום חוץ מלהודיע לי שכל הWRITE או READ הסתיים.

האם הבנתי נכון?

לפתוח ת'רד משלך זו פעולה כבדה, במקום זה הCLR מחזיק threadpool עם ת'רדים שרק מחכים שתנצל אותם. (ופעולה אסינכרונית עושה את זה)

המטרה היא שתוכל לקבל את המידע על התוצאה של הפעולה, כשהcallback יופעל אתה תקרא לendwrite ותתן לו את הasyncresult כדי שהוא יביא לך את התוצאה כמו שציפית לקבל אותה.

יש מקרים שזה פחות שימושי (כמו endread שהוא void) ויש מקרים שאתה צריך להוציא את החומר ולכן אתה תעביר את הdelegate כstateobject. (כדי לקרוא לendread או פונקציית סיום כזאת או אחרת)

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

כמו כן, בכלליות יש עכשיו מעבר לכיוון של tasks, תקרא על זה בגוגל.

יש מקרים שזה פחות שימושי (כמו endread שהוא void) ויש מקרים שאתה צריך להוציא את החומר ולכן אתה תעביר את הdelegate כstateobject. (כדי לקרוא לendread או פונקציית סיום כזאת או אחרת)

אפשר הסבר על זה?

קראתי כבר על TASKS ויקח זמן עד עד שאני יגיע לזה אבל תודה גבר.

 public delegate bool MyDelegate();
    static void Main(string[] args)
    {
      MyDelegate del = new MyDelegate(asyncWork);
      del.BeginInvoke(CallbackMethod, del);
      Console.ReadKey();
    }
    public static bool asyncWork()
    {
      //do some work
      return true;
    }
    public static void CallbackMethod(IAsyncResult Result)
    {
      var del=(MyDelegate)Result.AsyncState;
      bool MethodResult=del.EndInvoke(Result);
      Console.WriteLine(MethodResult.ToString());    }

כאן עטפתי איזשהיא מתודה בdelegate כדי לקרוא לה בצורה אסינכרונית (בעצם להפעיל thread מהthreadpool), וכדי להשיג את התוצאה שלה העברתי את הinstance של הdelegate כדי לקרוא לendinvoke ולהשיג את התוצאה.

במקרה והפונקציה היתה void לא היתה סיבה להשיג את התוצאה, אבל בכ"ז ב99% מהמקרים אתה תרצה לעשות משהו ברגע שהפעולה נגמרה (לעדכן את הממשק וכו') ולכן אתה תקרא לcallback.

שים לב שהcallback נקרא מה הthread השני ולא מהthread של הui, ולכן אם אתה משתמש בwinforms/WPF אתה תצטרך לקרוא לthread הUI שישנה דברים בUI.

הסתבכתי לגמרה מהדבר הזה לעזזל =\

אני לא מבין למה זה לא עובד:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication7
{
  class Program
  {
    public delegate bool MyDelegate();
    static void Main(string[] args)
    {
      bool b=del.EndInvoke(del.BeginInvoke(asyncWork, null));
    }
    public static bool asyncWork()
    {
      //do some work
      return true;
    }
  }
}

איפה יצרת instance של הdelegate שלך?

כל הסינטקס שלך לא נכון, תעבור שוב על מה שאני עשיתי.

נראלי שלא בדיוק הבנת מה זה delegate ולמה להשתמש בזה, תעביר חיפוש בגוגל לפני שאתה משתמש במשהו. (ככלל)

כעקרון delegate הוא class לכל דבר ובכל הגדרה של delegate אתה יוצר קלאס חדש שמצפה לקבל פונקציות עם החתימה שהגדרת (במקרה שלי הגדרתי שהוא מחזיר bool ולא מקבל שום פרמטר). הוא עוטף לך את הפונקציה ומאפשר לך להשתמש בה בצורה אסינכרונית. ובסיום הפעולה להגיב עם הcallback.

בקלאס שהבאת בהודעה הראשונה הdelegate הוא שקוף לך ויוצרים לך אותו ברגע שאתה יוצר אינסטנס של הקלאס, אתה צריך לקרוא לbeginwrite/read ולהעביר את האינסטנס של הקלאס שלך כstateobject ובcallback לקרוא לendwrite/read דרכו.

תעביר מבט בmsdn על הקלאס הזה ואיך להשתמש בו, תמיד יש שם קוד מדיוק של איך אתה אמור להשתמש בזה.

שים לב שזה לאו דווקא נכון לכל api יש classים שיש להם begin וend בלי קשר והשימוש בהם הוא שונה. (תבדוק בmsdn אם יש ספק)

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

אני יודע איך להשתמש בDELEGATE ומזה.אני פשוט לא ממש הבנתי מה התפקיד של כל אחד מהפרמטרים לStartEnvoke.

לפי מה שקראתי במדריך אז הפרמטר הראשון זה איזה פעולה להפעיל כאשר הStartEnvoke מסתיים והפרמטר השני הוא פרמטרת לפעולה שמופעלת אחרי שהStartEnvoke מסתיים (אגב למה תמיד זה אנטרפייס של IAsyncResult ?). אבל זה לא הגיוני שגם מוחזר ערך מהSTART וגם יש פנייה לפונקציה אחרת.

* מזה instance ? שתירגמתי את המילה זה יצא דוגמא וזה לא נראה לי הפירוש שאתה מתכוון אליו.

כאן הטעות שלי בהבנה.

instance זה מקרה יחיד של קלאס:

ברגע שעשית new Class() יצרת instance חדש של הקלאס.

תודה על כל התגובות וברוך השם הבנתי.

בבקשה