143 lines
5.3 KiB
C#
143 lines
5.3 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HttpAsyncResult.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* ASP.NET simple internal implementation of IAsyncResult
|
|
*
|
|
* Copyright (c) 2000 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web {
|
|
using System;
|
|
using System.Threading;
|
|
using System.Web.Util;
|
|
|
|
internal class HttpAsyncResult : IAsyncResult {
|
|
private AsyncCallback _callback;
|
|
private Object _asyncState;
|
|
|
|
private bool _completed;
|
|
private bool _completedSynchronously;
|
|
|
|
private Object _result;
|
|
private Exception _error;
|
|
private Thread _threadWhichStartedOperation;
|
|
|
|
// pipeline support
|
|
private RequestNotificationStatus
|
|
_status;
|
|
|
|
/*
|
|
* Constructor with pending result
|
|
*/
|
|
internal HttpAsyncResult(AsyncCallback cb, Object state) {
|
|
_callback = cb;
|
|
_asyncState = state;
|
|
_status = RequestNotificationStatus.Continue;
|
|
}
|
|
|
|
/*
|
|
* Constructor with known result
|
|
*/
|
|
internal HttpAsyncResult(AsyncCallback cb, Object state,
|
|
bool completed, Object result, Exception error) {
|
|
_callback = cb;
|
|
_asyncState = state;
|
|
|
|
_completed = completed;
|
|
_completedSynchronously = completed;
|
|
|
|
_result = result;
|
|
_error = error;
|
|
_status = RequestNotificationStatus.Continue;
|
|
|
|
if (_completed && _callback != null)
|
|
_callback(this);
|
|
}
|
|
|
|
internal void SetComplete() {
|
|
_completed = true;
|
|
}
|
|
|
|
/*
|
|
* Helper method to process completions
|
|
*/
|
|
internal void Complete(bool synchronous, Object result, Exception error, RequestNotificationStatus status) {
|
|
if (Volatile.Read(ref _threadWhichStartedOperation) == Thread.CurrentThread) {
|
|
// If we're calling Complete on the same thread which kicked off the operation, then
|
|
// we ignore the 'synchronous' value that the caller provided to us since we know
|
|
// for a fact that this is really a synchronous completion. This is only checked if
|
|
// the caller calls the MarkCallToBeginMethod* routines below.
|
|
synchronous = true;
|
|
}
|
|
|
|
_completed = true;
|
|
_completedSynchronously = synchronous;
|
|
_result = result;
|
|
_error = error;
|
|
_status = status;
|
|
|
|
if (_callback != null)
|
|
_callback(this);
|
|
}
|
|
|
|
internal void Complete(bool synchronous, Object result, Exception error) {
|
|
Complete(synchronous, result, error, RequestNotificationStatus.Continue);
|
|
}
|
|
|
|
|
|
/*
|
|
* Helper method to implement End call to async method
|
|
*/
|
|
internal Object End() {
|
|
if (_error != null)
|
|
throw new HttpException(null, _error);
|
|
|
|
return _result;
|
|
}
|
|
|
|
// If the caller needs to invoke an asynchronous method where the only way of knowing whether the
|
|
// method actually completed synchronously is to inspect which thread the callback was invoked on,
|
|
// then the caller should surround the asynchronous call with calls to the below Started / Completed
|
|
// methods. The callback can compare the captured thread against the current thread to see if the
|
|
// completion was synchronous. The caller calls the Completed method when unwinding so that the
|
|
// captured thread can be cleared out, preventing an asynchronous invocation on the same thread
|
|
// from being mistaken for a synchronous invocation.
|
|
|
|
internal void MarkCallToBeginMethodStarted() {
|
|
Thread originalThread = Interlocked.CompareExchange(ref _threadWhichStartedOperation, Thread.CurrentThread, null);
|
|
Debug.Assert(originalThread == null, "Another thread already called MarkCallToBeginMethodStarted.");
|
|
}
|
|
|
|
internal void MarkCallToBeginMethodCompleted() {
|
|
Thread originalThread = Interlocked.Exchange(ref _threadWhichStartedOperation, null);
|
|
Debug.Assert(originalThread == Thread.CurrentThread, "This thread did not call MarkCallToBeginMethodStarted.");
|
|
}
|
|
|
|
//
|
|
// Properties that are not part of IAsyncResult
|
|
//
|
|
|
|
internal Exception Error { get { return _error;}}
|
|
|
|
internal RequestNotificationStatus Status {
|
|
get {
|
|
return _status;
|
|
}
|
|
}
|
|
|
|
//
|
|
// IAsyncResult implementation
|
|
//
|
|
|
|
public bool IsCompleted { get { return _completed;}}
|
|
public bool CompletedSynchronously { get { return _completedSynchronously;}}
|
|
public Object AsyncState { get { return _asyncState;}}
|
|
public WaitHandle AsyncWaitHandle { get { return null;}} // wait not supported
|
|
}
|
|
|
|
}
|