1 namespace Examples
 2 {
 3     public class Progrom
 4     {
 5         public static void Main()
 6         {
 7             AsyncWorkTest work = new AsyncWorkTest();
 8             IAsyncResult result = work.BeginWork(CallBack, null);
 9             Console.WriteLine("Work is begining...");
10             string ret = work.EndWork(result);
11             Console.WriteLine(ret);
12             Console.WriteLine("Work is end...");
13             Console.ReadKey();
14         }
15 
16         static void CallBack(object obj)
17         {
18             //do someing
19         }
20     }
21 
22     public class AsyncResult : IAsyncResult
23     {
24         public AsyncResult()
25         {
26             //Accept parameters
27         }
28         private object asyncState;
29         private volatile bool isCompleted;
30         private volatile bool completedSynchronously;
31         private ManualResetEvent asynWaitHandle;
32 
33         public string Result = "Mandel";
34 
35         public object AsyncState
36         {
37             get { return asyncState; }
38         }
39         public WaitHandle AsyncWaitHandle
40         {
41             get
42             {
43                 if (this.asynWaitHandle == null)
44                 {
45                     Interlocked.CompareExchange<ManualResetEvent>(ref this.asynWaitHandle, new ManualResetEvent(false), null);
46                 }
47                 return asynWaitHandle;
48             }
49         }
50         public bool CompletedSynchronously
51         {
52             get { return completedSynchronously; }
53         }
54         public bool IsCompleted
55         {
56             get { return isCompleted; }
57         }
58 
59         public void Work()
60         {
61             //do someing
62             Thread.Sleep(3000); ;
63             Result = "The Silent Southern Girl";
64             asyncState = this;
65             completedSynchronously = false;
66             isCompleted = true;
67             asynWaitHandle.Set();
68         }
69 
70     }
71 
72     public class AsyncWorkTest
73     {
74         public IAsyncResult BeginWork(AsyncCallback callback, object state)
75         {
76             AsyncResult result = new AsyncResult();
77             ThreadPool.QueueUserWorkItem((action) =>
78             {
79                 result.Work();
80                 if (callback != null)
81                 {
82                     callback((AsyncResult)state);
83                 }
84             }, state);
85             return result;
86         }
87 
88         public string EndWork(IAsyncResult re)
89         {
90             AsyncResult result = (AsyncResult)re;
91             result.AsyncWaitHandle.WaitOne();
92             return result.Result;
93         }
94     }
95 
96 }

  1  class EAPTest
  2     {
  3         public static void Main()
  4         {
  5             Work myWork = new Work();
  6             myWork.onProgressChanged += new ProgressChangedEventHandler(myWork_onProgressChanged);
  7             myWork.onWorkCompleted += new WorkCompletedEventHandler(myWork_onWorkCompleted);
  8             myWork.WoekAsync("Mandel");
  9             myWork.WoekAsync("Alan");
 10             Thread.Sleep(4000);
 11             myWork.CancelAsync("Alan");
 12             Console.ReadKey();
 13         }
 14 
 15         static void myWork_onProgressChanged(WorkProgressChangedEventArgs e)
 16         {
 17             Console.WriteLine("Worked" + e.TaskID + " " + e.ProgressPercentage.ToString() + "% --------------");
 18         }
 19 
 20         static void myWork_onWorkCompleted(object sender, WorkCompletedEventArgs e)
 21         {
 22             Console.WriteLine("Work " + e.TaskID + "Completed---------");
 23         }
 24     }
 25 
 26     //delegate
 27     public delegate void ProgressChangedEventHandler(WorkProgressChangedEventArgs e);
 28     public delegate void WorkCompletedEventHandler(object sender, WorkCompletedEventArgs e);
 29     class Work
 30     {
 31         private delegate void WorkerEventHandler(AsyncOperation asyncOp, object taskID);
 32         private delegate void www();
 33         private SendOrPostCallback onProgressReportDelegate;
 34         private SendOrPostCallback onCompletedDelegate;
 35 
 36         public event ProgressChangedEventHandler onProgressChanged;
 37         public event WorkCompletedEventHandler onWorkCompleted;
 38 
 39         private HybridDictionary userStateToLifetime = new HybridDictionary();
 40 
 41         public Work()
 42         {
 43             onProgressReportDelegate = new SendOrPostCallback(ReportProgress);
 44             onCompletedDelegate = new SendOrPostCallback(WorkCompleted);
 45         }
 46         private void WorkCompleted(object operationState)
 47         {
 48             WorkCompletedEventArgs e = operationState as WorkCompletedEventArgs;
 49             if (onWorkCompleted != null)
 50             {
 51                 onWorkCompleted(this, e);
 52             }
 53         }
 54         private void ReportProgress(object state)
 55         {
 56             WorkProgressChangedEventArgs e = state as WorkProgressChangedEventArgs;
 57             if (onProgressChanged != null)
 58             {
 59                 onProgressChanged(e);
 60             }
 61         }
 62 
 63         public virtual void WoekAsync(string taskId)
 64         {
 65             // Create an AsyncOperation for taskId.
 66             AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId);
 67             lock (userStateToLifetime.SyncRoot)
 68             {
 69                 if (userStateToLifetime.Contains(taskId))
 70                 {
 71                     throw new ArgumentException("Task ID parameter must be unique", "taskId");
 72                 }
 73 
 74                 userStateToLifetime[taskId] = asyncOp;
 75             }
 76             // Start the asynchronous operation.
 77             WorkerEventHandler workerDelegate = new WorkerEventHandler(Worker);
 78             workerDelegate.BeginInvoke(asyncOp, taskId, null, null);
 79         }
 80         private void Worker(AsyncOperation asyncOp, object taskID)
 81         {
 82             Exception e = null;
 83             ProgressChangedEventArgs progressEventArg;
 84             for (int i = 0; i < 5; i++)
 85             {
 86                 Thread.Sleep(1000);
 87                 Console.WriteLine(i);
 88             }
 89             if (!TaskCanceled(asyncOp.UserSuppliedState))
 90             {
 91                 //Do the work
 92                 try
 93                 {
 94                     Console.WriteLine("Come On! " + taskID);
 95                     Console.WriteLine("Work " + taskID.ToString() + " is working");
 96                     progressEventArg = new WorkProgressChangedEventArgs(taskID, 50, new object());
 97                     asyncOp.Post(this.onProgressReportDelegate, progressEventArg);
 98                     Console.WriteLine("Work " + taskID.ToString() + " has been completed");
 99                     progressEventArg = new WorkProgressChangedEventArgs(taskID, 100, new object());
100                     asyncOp.Post(this.onProgressReportDelegate, progressEventArg);
101                 }
102                 catch (Exception ex)
103                 {
104                     e = ex;
105                 }
106                 this.CompletionMethod(taskID, e, TaskCanceled(asyncOp.UserSuppliedState), asyncOp);
107             }
108             else
109             {
110                 Console.WriteLine("Work " + taskID.ToString() + " has been canceled");
111             }
112         }
113 
114         public void CancelAsync(object taskId)
115         {
116             AsyncOperation asyncOp = userStateToLifetime[taskId] as AsyncOperation;
117             if (asyncOp != null)
118             {
119                 lock (userStateToLifetime.SyncRoot)
120                 {
121                     userStateToLifetime.Remove(taskId);
122                 }
123             }
124         }
125 
126         private bool TaskCanceled(object taskId)
127         {
128             return (userStateToLifetime[taskId] == null);
129         }
130 
131         private void CompletionMethod(object taskID, Exception exception, bool canceled, AsyncOperation asyncOp)
132         {
133             if (!canceled)
134             {
135                 lock (userStateToLifetime.SyncRoot)
136                 {
137                     userStateToLifetime.Remove(asyncOp.UserSuppliedState);
138                 }
139             }
140             WorkCompletedEventArgs e = new WorkCompletedEventArgs(taskID.ToString(), exception, canceled, asyncOp.UserSuppliedState);
141             asyncOp.PostOperationCompleted(onCompletedDelegate, e);
142         }
143     }
144 
145     //Args
146     public class WorkProgressChangedEventArgs : ProgressChangedEventArgs
147     {
148         private object taskID = null;
149 
150         public WorkProgressChangedEventArgs(object value, int progressPercentage, object userToken)
151             : base(progressPercentage, userToken)
152         {
153             this.taskID = value;
154         }
155         /// <summary>
156         /// 任务标识
157         /// </summary>
158         public object TaskID
159         {
160             get
161             {
162                 return taskID;
163             }
164         }
165     }
166     public class WorkCompletedEventArgs : AsyncCompletedEventArgs
167     {
168         object taskID = "";
169         public WorkCompletedEventArgs(object value, Exception e, bool canceled, object state)
170             : base(e, canceled, state)
171         {
172             this.taskID = value;
173         }
174         /// <summary>
175         /// 任务标识
176         /// </summary>
177         public object TaskID
178         {
179             get
180             {
181                 RaiseExceptionIfNecessary();
182                 return taskID;
183             }
184         }
185     }