Facilities/Synchronize/Castle.Facilities.Synchronize/AbstractAsyncResult.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Facilities.Synchronize
  16 {
  17         using System;
  18         using System.Threading;
  19
  20         /// <summary>
  21         /// Abstract result for asynchronous operations.
  22         /// </summary>
  23         public abstract class AbstractAsyncResult : IAsyncResult
  24         {
  25                 private int cleanUp;
  26                 private int completed;
  27                 private int invokedCallback;
  28                 private readonly object asyncState;
  29                 private readonly AsyncCallback _asyncCallback;
  30                 private bool completedSynchronously;
  31                 private bool endCalled;
  32                 private Exception exception;
  33                 private object result;
  34                 private object waitEvent;
  35
  36                 /// <summary>
  37                 /// Initializes a new <see cref="AbstractAsyncResult"/>
  38                 /// </summary>
  39                 /// <param name="callback">The async callback.</param>
  40                 /// <param name="state">The async state</param>
  41                 protected AbstractAsyncResult(AsyncCallback callback, object state)
  42                 {
  43                         asyncState = state;
  44                         _asyncCallback = callback;
  45                         invokedCallback = (callback != null) ? 0 : 1;
  46                 }
  47
  48                 #region IAsyncResult Members
  49
  50                 /// <summary>
  51                 /// Gets the asynchournous state.
  52                 /// </summary>
  53                 public object AsyncState
  54                 {
  55                         get { return asyncState; }
  56                 }
  57
  58                 /// <summary>
  59                 /// Determines if the result is available.
  60                 /// </summary>
  61                 public bool IsCompleted
  62                 {
  63                         get { return (completed != 0); }
  64                 }
  65
  66                 /// <summary>
  67                 /// Determines if the result completed synchronously.
  68                 /// </summary>
  69                 public bool CompletedSynchronously
  70                 {
  71                         get { return completedSynchronously; }
  72                         protected internal set
  73             {
  74                  completedSynchronously = value;
  75             }
  76                 }
  77
  78                 /// <summary>
  79                 /// Gets the asynchronous <see cref="WaitHandle"/>.
  80                 /// </summary>
  81                 public WaitHandle AsyncWaitHandle
  82                 {
  83                         get
  84                         {
  85                                 int isCompleted = completed;
  86
  87                                 if (waitEvent == null)
  88                                 {
  89                                         Interlocked.CompareExchange(ref waitEvent,
  90                                                 new ManualResetEvent(isCompleted != 0), (object)null);
  91                                 }
  92
  93                                 ManualResetEvent ev = (ManualResetEvent)waitEvent;
  94
  95                                 if ((isCompleted == 0) && (completed != 0))
  96                                 {
  97                                         ev.Set();
  98                                 }
  99
 100                                 return ev;
 101                         }
 102                 }
 103
 104                 /// <summary>
 105                 /// Ends the asynchronous request.
 106                 /// </summary>
 107                 /// <param name="asyncResult">The asynchronous result.</param>
 108                 /// <returns>The result.</returns>
 109                 public static object End(IAsyncResult asyncResult)
 110                 {
 111                         if (asyncResult == null)
 112                         {
 113                                 throw new ArgumentNullException("asyncResult");
 114                         }
 115
 116                         AbstractAsyncResult result = asyncResult as AbstractAsyncResult;
 117
 118                         if (result == null)
 119                         {
 120                                 throw new ArgumentException("Unrecognized IAsyncResult", "result");
 121                         }
 122
 123                         if (result.endCalled)
 124                         {
 125                                 throw new InvalidOperationException("IAsyncResult has already ended");
 126                         }
 127
 128                         result.endCalled = true;
 129
 130                         if (result.completed == 0)
 131                         {
 132                                 result.AsyncWaitHandle.WaitOne();
 133                         }
 134
 135                         if (result.exception != null)
 136                         {
 137                                 throw result.exception;
 138                         }
 139
 140                         return result.result;
 141                 }
 142
 143                 #endregion
 144
 145                 /// <summary>
 146                 /// Completes the asynchronous request.
 147                 /// </summary>
 148                 /// <param name="synchronously">true if synchronously.</param>
 149                 protected void Complete(bool synchronously)
 150                 {
 151                         completedSynchronously = synchronously;
 152
 153                         Interlocked.Increment(ref completed);
 154
 155                         if (waitEvent != null)
 156                         {
 157                                 ((ManualResetEvent)waitEvent).Set();
 158                         }
 159
 160                         if ((_asyncCallback != null) && (Interlocked.Increment(ref invokedCallback) == 1))
 161                         {
 162                                 _asyncCallback(this);
 163                         }
 164
 165                         InternalCleanup();
 166                 }
 167
 168                 /// <summary>
 169                 /// Completes the asynchronous request.
 170                 /// </summary>
 171                 /// <param name="synchronously">true if synchronously.</param>
 172                 /// <param name="result">The result.</param>
 173                 protected void Complete(bool synchronously, object result)
 174                 {
 175                         this.result = result;
 176                         Complete(synchronously);
 177                 }
 178
 179                 /// <summary>
 180                 /// Completes the asynchronous request with exception.
 181                 /// </summary>
 182                 /// <param name="synchronously">true if synchronously.</param>
 183                 /// <param name="exception">The exception.</param>
 184                 protected void Complete(bool synchronously, Exception exception)
 185                 {
 186                         this.exception = exception;
 187                         Complete(synchronously);
 188                 }
 189
 190                 /// <summary>
 191                 /// Performs any cleanup.
 192                 /// </summary>
 193                 protected virtual void Cleanup()
 194                 {
 195                 }
 196
 197                 private void InternalCleanup()
 198                 {
 199                         if (Interlocked.Increment(ref cleanUp) == 1)
 200                         {
 201                                 Cleanup();
 202                         }
 203                 }
 204
 205                 /// <summary>
 206                 /// Finalizer to ensure cleanup.
 207                 /// </summary>
 208                 ~AbstractAsyncResult()
 209                 {
 210                         InternalCleanup();
 211                 }
 212         }
 213 }