sdk/samples/WCFSamples/TechnologySamples/Extensibility/Transport/UdpActivation/CS/UDPActivation/AsyncResult.cs

   1 // ----------------------------------------------------------------------------
   2 // Copyright (C) 2003-2005 Microsoft Corporation, All rights reserved.
   3 // ----------------------------------------------------------------------------
   4
   5 using System;
   6 using System.Diagnostics;
   7 using System.Threading;
   8
   9 namespace Microsoft.ServiceModel.Samples
  10 {
  11     /// <summary>
  12     /// A generic base class for IAsyncResult implementations
  13     /// that wraps a ManualResetEvent.
  14     /// </summary>
  15     abstract class AsyncResult : IAsyncResult
  16     {
  17         AsyncCallback callback;
  18         object state;
  19         bool completedSynchronously;
  20         bool endCalled;
  21         Exception exception;
  22         bool isCompleted;
  23         ManualResetEvent manualResetEvent;
  24         object thisLock;
  25
  26         protected AsyncResult(AsyncCallback callback, object state)
  27         {
  28             this.callback = callback;
  29             this.state = state;
  30             this.thisLock = new object();
  31         }
  32
  33         public object AsyncState
  34         {
  35             get
  36             {
  37                 return state;
  38             }
  39         }
  40
  41         public WaitHandle AsyncWaitHandle
  42         {
  43             get
  44             {
  45                 if (manualResetEvent != null)
  46                 {
  47                     return manualResetEvent;
  48                 }
  49
  50                 lock (ThisLock)
  51                 {
  52                     if (manualResetEvent == null)
  53                     {
  54                         manualResetEvent = new ManualResetEvent(isCompleted);
  55                     }
  56                 }
  57
  58                 return manualResetEvent;
  59             }
  60         }
  61
  62         public bool CompletedSynchronously
  63         {
  64             get
  65             {
  66                 return completedSynchronously;
  67             }
  68         }
  69
  70         public bool IsCompleted
  71         {
  72             get
  73             {
  74                 return isCompleted;
  75             }
  76         }
  77
  78         object ThisLock
  79         {
  80             get
  81             {
  82                 return this.thisLock;
  83             }
  84         }
  85
  86         // Call this version of complete when your asynchronous operation is complete.  This will update the state
  87         // of the operation and notify the callback.
  88         protected void Complete(bool completedSynchronously)
  89         {
  90             if (isCompleted)
  91             {
  92                 // It is a bug to call Complete twice.
  93                 throw new InvalidOperationException("Cannot call Complete twice");
  94             }
  95
  96             this.completedSynchronously = completedSynchronously;
  97
  98             if (completedSynchronously)
  99             {
 100                 // If we completedSynchronously, then there is no chance that the manualResetEvent was created so
 101                 // we do not need to worry about a race condition.
 102                 Debug.Assert(this.manualResetEvent == null, "No ManualResetEvent should be created for a synchronous AsyncResult.");
 103                 this.isCompleted = true;
 104             }
 105             else
 106             {
 107                 lock (ThisLock)
 108                 {
 109                     this.isCompleted = true;
 110                     if (this.manualResetEvent != null)
 111                     {
 112                         this.manualResetEvent.Set();
 113                     }
 114                 }
 115             }
 116
 117             // If the callback throws, there is a bug in the callback implementation
 118             if (callback != null)
 119             {
 120                 callback(this);
 121             }
 122         }
 123
 124         // Call this version of complete if you raise an exception during processing.  In addition to notifying
 125         // the callback, it will capture the exception and store it to be thrown during AsyncResult.End.
 126         protected void Complete(bool completedSynchronously, Exception exception)
 127         {
 128             this.exception = exception;
 129             Complete(completedSynchronously);
 130         }
 131
 132         // End should be called when the End function for the asynchronous operation is complete.  It
 133         // ensures the asynchronous operation is complete, and does some common validation.
 134         protected static TAsyncResult End<TAsyncResult>(IAsyncResult result)
 135             where TAsyncResult : AsyncResult
 136         {
 137             if (result == null)
 138             {
 139                 throw new ArgumentNullException("result");
 140             }
 141
 142             TAsyncResult asyncResult = result as TAsyncResult;
 143
 144             if (asyncResult == null)
 145             {
 146                 throw new ArgumentException("Invalid async result.", "result");
 147             }
 148
 149             if (asyncResult.endCalled)
 150             {
 151                 throw new InvalidOperationException("Async object already ended.");
 152             }
 153
 154             asyncResult.endCalled = true;
 155
 156             if (!asyncResult.isCompleted)
 157             {
 158                 asyncResult.AsyncWaitHandle.WaitOne();
 159             }
 160
 161             if (asyncResult.manualResetEvent != null)
 162             {
 163                 asyncResult.manualResetEvent.Close();
 164             }
 165
 166             if (asyncResult.exception != null)
 167             {
 168                 throw asyncResult.exception;
 169             }
 170
 171             return asyncResult;
 172         }
 173     }
 174
 175     //An AsyncResult that completes as soon as it is instantiated.
 176     class CompletedAsyncResult : AsyncResult
 177     {
 178         public CompletedAsyncResult(AsyncCallback callback, object state)
 179             : base(callback, state)
 180         {
 181             Complete(true);
 182         }
 183
 184         public static void End(IAsyncResult result)
 185         {
 186             AsyncResult.End<CompletedAsyncResult>(result);
 187         }
 188     }
 189
 190     //A strongly typed AsyncResult
 191     abstract class TypedAsyncResult<T> : AsyncResult
 192     {
 193         T data;
 194
 195         protected TypedAsyncResult(AsyncCallback callback, object state)
 196             : base(callback, state)
 197         {
 198         }
 199
 200         public T Data
 201         {
 202             get { return data; }
 203         }
 204
 205         protected void Complete(T data, bool completedSynchronously)
 206         {
 207             this.data = data;
 208             Complete(completedSynchronously);
 209         }
 210
 211         public static T End(IAsyncResult result)
 212         {
 213             TypedAsyncResult<T> typedResult = AsyncResult.End<TypedAsyncResult<T>>(result);
 214             return typedResult.Data;
 215         }
 216     }
 217
 218     //A strongly typed AsyncResult that completes as soon as it is instantiated.
 219     class TypedCompletedAsyncResult<T> : TypedAsyncResult<T>
 220     {
 221         public TypedCompletedAsyncResult(T data, AsyncCallback callback, object state)
 222             : base(callback, state)
 223         {
 224             Complete(data, true);
 225         }
 226
 227         public new static T End(IAsyncResult result)
 228         {
 229             TypedCompletedAsyncResult<T> completedResult = result as TypedCompletedAsyncResult<T>;
 230             if (completedResult == null)
 231             {
 232                 throw new ArgumentException("Invalid async result.", "result");
 233             }
 234
 235             return TypedAsyncResult<T>.End(completedResult);
 236         }
 237     }
 238 }