CarotDav_decompile/Rei.Net.HttpServer/MyAsyncResult.cs

190 lines
4.3 KiB
C#
Raw Normal View History

// Decompiled with JetBrains decompiler
// Type: Rei.Net.HttpServer.MyAsyncResult
// Assembly: Rei.Net.HttpServer, Version=1.13.2.9297, Culture=neutral, PublicKeyToken=null
// MVID: 6174F8E9-E7BA-46AD-8F2E-196645884F28
// Assembly location: F:\Eigene Dateien\Dropbox\portable Collection\Progs\CarotDAV\Rei.Net.HttpServer.dll
using Microsoft.VisualBasic.CompilerServices;
using System;
using System.Runtime.CompilerServices;
using System.Threading;
namespace Rei.Net.HttpServer
{
public class MyAsyncResult : IAsyncResult
{
private AsyncCallback _callback;
private object _asyncstate;
private bool _iscompleted;
private bool _isended;
private bool _async;
private ManualResetEvent _waithandle;
private object _returnvalue;
private object _syncobject;
private IAsyncResult _baseasyncresult;
private object _tag;
private Exception _ex;
public MyAsyncResult(AsyncCallback callback, object asyncstate)
{
this._callback = callback;
this._asyncstate = RuntimeHelpers.GetObjectValue(asyncstate);
this._isended = false;
this._iscompleted = false;
this._async = false;
this._waithandle = (ManualResetEvent) null;
this._returnvalue = (object) null;
this._syncobject = RuntimeHelpers.GetObjectValue(new object());
}
public bool IsCompleted
{
get
{
return this._iscompleted;
}
}
public object AsyncState
{
get
{
return this._asyncstate;
}
}
public bool CompletedSynchronously
{
get
{
return this.IsCompleted && !this._async;
}
}
public WaitHandle AsyncWaitHandle
{
get
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._waithandle == null)
this._waithandle = new ManualResetEvent(this._iscompleted);
}
finally
{
Monitor.Exit(syncobject);
}
return (WaitHandle) this._waithandle;
}
}
internal object ReturnValue
{
get
{
return this._returnvalue;
}
set
{
this._returnvalue = RuntimeHelpers.GetObjectValue(value);
}
}
internal IAsyncResult BaseAsyncResult
{
get
{
return this._baseasyncresult;
}
set
{
this._baseasyncresult = value;
}
}
internal object Tag
{
get
{
return this._tag;
}
set
{
this._tag = RuntimeHelpers.GetObjectValue(value);
}
}
internal void SetAsync()
{
this._async = true;
}
internal void Complete(Exception ex)
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._iscompleted)
throw new InvalidOperationException();
this._iscompleted = true;
this._ex = ex;
if (this._waithandle != null)
this._waithandle.Set();
}
finally
{
Monitor.Exit(syncobject);
}
Exception ex1 = this._ex;
if (this._callback == null)
return;
this._callback((IAsyncResult) this);
}
internal void Complete()
{
this.Complete((Exception) null);
}
internal void AsyncEnd()
{
object syncobject1 = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject1);
Monitor.Enter(syncobject1);
bool iscompleted;
try
{
if (this._isended)
throw new InvalidOperationException();
this._isended = true;
iscompleted = this._iscompleted;
}
finally
{
Monitor.Exit(syncobject1);
}
if (!iscompleted)
this.AsyncWaitHandle.WaitOne();
object syncobject2 = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject2);
Monitor.Enter(syncobject2);
try
{
if (this._waithandle != null)
this._waithandle.Close();
}
finally
{
Monitor.Exit(syncobject2);
}
if (this._ex != null)
throw new Exception("error", this._ex);
}
}
}