private static void ReadCallback(IAsyncResult ar)
{
NetworkPackagingLayer networkPackagingLayer = (NetworkPackagingLayer)ar.AsyncState;
NetworkPackagingLayer.Tracer.TraceDebug <bool, int>(0L, "ReadCallback completion was sync: {0} arhash={1}", ar.CompletedSynchronously, ar.GetHashCode());
Exception ex = null;
NetworkChannelCallback networkChannelCallback = null;
object asyncState = null;
bool flag = false;
int num = 0;
try
{
num = networkPackagingLayer.m_tcpChannel.Stream.EndRead(ar);
ExTraceGlobals.NetworkChannelTracer.TraceDebug <int, string, string>((long)networkPackagingLayer.GetHashCode(), "AsyncReadCallback read {0} bytes from {1} on {2}", num, networkPackagingLayer.m_netChannel.RemoteEndPointString, networkPackagingLayer.m_netChannel.LocalEndPointString);
flag = true;
}
catch (IOException ex2)
{
ex = ex2;
}
catch (Win32Exception ex3)
{
ex = ex3;
}
catch (ObjectDisposedException ex4)
{
NetworkPackagingLayer.Tracer.TraceError <bool, string>(0L, "ReadCallback has closed={0} ignoring exception {1}", networkPackagingLayer.m_closeCalled, ex4.Message);
}
catch (InvalidOperationException ex5)
{
NetworkPackagingLayer.Tracer.TraceError <string>(0L, "ReadCallback ignoring exception {0}", ex5.Message);
}
finally
{
lock (networkPackagingLayer)
{
networkChannelCallback = networkPackagingLayer.m_userCallback;
asyncState = networkPackagingLayer.m_userCallbackCtx;
networkPackagingLayer.m_asyncException = ex;
if (flag)
{
networkPackagingLayer.m_asyncReadByteCount = num;
if (num == 0)
{
networkPackagingLayer.m_asyncReadGotZeroBytes = true;
}
}
else
{
networkPackagingLayer.m_asyncReadByteCount = 0;
}
networkPackagingLayer.m_asyncReadActive = false;
networkPackagingLayer.m_asyncReadCompleteEvent.Set();
}
}
if (networkChannelCallback != null)
{
networkChannelCallback(asyncState, num, ar.CompletedSynchronously, ex);
}
}
internal void StartRead(NetworkChannelCallback asyncCallback, object asyncState)
{
bool flag = false;
lock (this)
{
if (this.m_asyncReadCompleteEvent == null)
{
this.m_asyncReadCompleteEvent = new ManualResetEvent(false);
}
else
{
this.m_asyncReadCompleteEvent.Reset();
}
this.m_asyncReadActive = true;
this.m_asyncReadGotZeroBytes = false;
this.m_asyncReadByteCount = 0;
this.m_asyncException = null;
this.m_userCallback = asyncCallback;
this.m_userCallbackCtx = asyncState;
try
{
IAsyncResult asyncResult = this.m_tcpChannel.Stream.BeginRead(this.m_readPacketHeaderBuf, 0, 1, new AsyncCallback(NetworkPackagingLayer.ReadCallback), this);
NetworkPackagingLayer.Tracer.TraceDebug <bool, int>((long)this.GetHashCode(), "BeginRead completion was sync: {0} arhash={1}", asyncResult.CompletedSynchronously, asyncResult.GetHashCode());
flag = true;
}
finally
{
if (!flag)
{
this.m_asyncReadActive = false;
if (this.m_asyncReadCompleteEvent != null)
{
this.m_asyncReadCompleteEvent.Set();
}
}
}
}
}
public void EndInvoke(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
if (asyncResult != this.pendingResult)
{
throw new ArgumentException(MExRuntimeStrings.InvalidEndInvoke, "asyncResult");
}
ExTraceGlobals.DispatchTracer.TraceDebug <int>((long)this.GetHashCode(), this.InstanceNameFormatted + "async dispatch ended, async result {0}", asyncResult.GetHashCode());
try
{
this.pendingResult.EndInvoke();
}
finally
{
this.pendingResult = null;
}
}
