mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
688 lines
25 KiB
C#
688 lines
25 KiB
C#
//----------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Discovery
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Channels;
|
|
using System.Threading;
|
|
|
|
abstract partial class DiscoveryClientChannelBase<TChannel> : ChannelBase
|
|
where TChannel : class, IChannel
|
|
{
|
|
TChannel innerChannel;
|
|
|
|
IChannelFactory<TChannel> innerChannelFactory;
|
|
FindCriteria findCriteria;
|
|
DiscoveryEndpointProvider discoveryEndpointProvider;
|
|
|
|
DiscoveryClient discoveryClient;
|
|
|
|
InputQueue<EndpointDiscoveryMetadata> discoveredEndpoints;
|
|
Exception exception;
|
|
int totalExpectedEndpoints;
|
|
int totalDiscoveredEndpoints;
|
|
bool discoveryCompleted;
|
|
|
|
[Fx.Tag.SynchronizationObject]
|
|
object thisLock;
|
|
|
|
public DiscoveryClientChannelBase(
|
|
ChannelManagerBase channelManagerBase,
|
|
IChannelFactory<TChannel> innerChannelFactory,
|
|
FindCriteria findCriteria,
|
|
DiscoveryEndpointProvider discoveryEndpointProvider)
|
|
: base(channelManagerBase)
|
|
{
|
|
Fx.Assert(findCriteria != null, "The findCriteria must be non null.");
|
|
Fx.Assert(discoveryEndpointProvider != null, "The discoveryEndpointProvider must be non null.");
|
|
Fx.Assert(innerChannelFactory != null, "The innerChannelFactory must be non null.");
|
|
|
|
this.innerChannelFactory = innerChannelFactory;
|
|
this.findCriteria = findCriteria;
|
|
this.discoveryEndpointProvider = discoveryEndpointProvider;
|
|
|
|
this.discoveredEndpoints = new InputQueue<EndpointDiscoveryMetadata>();
|
|
this.totalExpectedEndpoints = int.MaxValue;
|
|
this.totalDiscoveredEndpoints = 0;
|
|
this.discoveryCompleted = false;
|
|
this.thisLock = new object();
|
|
}
|
|
|
|
protected TChannel InnerChannel
|
|
{
|
|
get
|
|
{
|
|
return this.innerChannel;
|
|
}
|
|
}
|
|
|
|
public override T GetProperty<T>()
|
|
{
|
|
T baseProperty = base.GetProperty<T>();
|
|
if (baseProperty != null)
|
|
{
|
|
return baseProperty;
|
|
}
|
|
|
|
if (this.innerChannel != null)
|
|
{
|
|
return this.InnerChannel.GetProperty<T>();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void OnOpen(TimeSpan timeout)
|
|
{
|
|
this.innerChannel = this.BuildChannel(timeout);
|
|
this.innerChannel.Faulted += new EventHandler(OnInnerChannelFaulted);
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new DiscoveryChannelBuilderAsyncResult(
|
|
this,
|
|
timeout,
|
|
callback,
|
|
state);
|
|
}
|
|
|
|
protected override void OnEndOpen(IAsyncResult result)
|
|
{
|
|
this.innerChannel = DiscoveryChannelBuilderAsyncResult.End(result);
|
|
this.innerChannel.Faulted += new EventHandler(OnInnerChannelFaulted);
|
|
}
|
|
|
|
protected override void OnClosing()
|
|
{
|
|
if (this.innerChannel != null)
|
|
{
|
|
this.innerChannel.Faulted -= new EventHandler(OnInnerChannelFaulted);
|
|
}
|
|
base.OnClosing();
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
if (this.innerChannel != null)
|
|
{
|
|
this.innerChannel.Close(timeout);
|
|
}
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new CloseAsyncResult(
|
|
this.innerChannel,
|
|
timeout,
|
|
callback,
|
|
state);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
CloseAsyncResult.End(result);
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
if (this.innerChannel != null)
|
|
{
|
|
this.innerChannel.Abort();
|
|
}
|
|
}
|
|
|
|
void OnInnerChannelFaulted(object sender, EventArgs e)
|
|
{
|
|
this.Fault();
|
|
}
|
|
|
|
public TChannel BuildChannel(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
this.InitializeAndFindAsync();
|
|
|
|
TChannel innerChannel = null;
|
|
bool completed = false;
|
|
|
|
EndpointDiscoveryMetadata currentEndpointDiscoveryMetadata = null;
|
|
|
|
try
|
|
{
|
|
do
|
|
{
|
|
try
|
|
{
|
|
currentEndpointDiscoveryMetadata = this.discoveredEndpoints.Dequeue(timeoutHelper.RemainingTime());
|
|
}
|
|
catch (TimeoutException te)
|
|
{
|
|
throw FxTrace.Exception.AsError(new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(timeoutHelper.OriginalTimeout), te));
|
|
}
|
|
|
|
if (currentEndpointDiscoveryMetadata == null)
|
|
{
|
|
if (this.totalDiscoveredEndpoints < 1)
|
|
{
|
|
throw FxTrace.Exception.AsError(new EndpointNotFoundException(SR.DiscoveryClientChannelEndpointNotFound, this.exception));
|
|
}
|
|
else
|
|
{
|
|
throw FxTrace.Exception.AsError(new EndpointNotFoundException(SR.DiscoveryClientChannelCreationFailed(this.totalDiscoveredEndpoints), this.exception));
|
|
}
|
|
}
|
|
|
|
if (timeoutHelper.RemainingTime() == TimeSpan.Zero)
|
|
{
|
|
throw FxTrace.Exception.AsError(new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(timeoutHelper.OriginalTimeout)));
|
|
}
|
|
|
|
if (currentEndpointDiscoveryMetadata.ListenUris.Count == 0)
|
|
{
|
|
completed = this.CreateChannel(
|
|
ref innerChannel,
|
|
currentEndpointDiscoveryMetadata.Address,
|
|
currentEndpointDiscoveryMetadata.Address.Uri,
|
|
timeoutHelper);
|
|
}
|
|
else
|
|
{
|
|
foreach (Uri listenUri in currentEndpointDiscoveryMetadata.ListenUris)
|
|
{
|
|
completed = this.CreateChannel(
|
|
ref innerChannel,
|
|
currentEndpointDiscoveryMetadata.Address,
|
|
listenUri,
|
|
timeoutHelper);
|
|
|
|
if (completed)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (!completed);
|
|
}
|
|
finally
|
|
{
|
|
if (completed && TD.InnerChannelOpenSucceededIsEnabled())
|
|
{
|
|
TD.InnerChannelOpenSucceeded(
|
|
currentEndpointDiscoveryMetadata.Address.ToString(),
|
|
GetVia(innerChannel).ToString());
|
|
}
|
|
|
|
this.Cleanup(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
return innerChannel;
|
|
}
|
|
|
|
bool CreateChannel(ref TChannel innerChannel, EndpointAddress to, Uri via, TimeoutHelper timeoutHelper)
|
|
{
|
|
bool completed = false;
|
|
Exception exception = null;
|
|
|
|
try
|
|
{
|
|
innerChannel = this.innerChannelFactory.CreateChannel(to, via);
|
|
innerChannel.Open(timeoutHelper.RemainingTime());
|
|
completed = true;
|
|
}
|
|
catch (TimeoutException timeoutException)
|
|
{
|
|
throw FxTrace.Exception.AsError(new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(timeoutHelper.OriginalTimeout), timeoutException));
|
|
}
|
|
catch (CommunicationException communicationException)
|
|
{
|
|
exception = communicationException;
|
|
}
|
|
catch (ArgumentException argumentException)
|
|
{
|
|
exception = argumentException;
|
|
}
|
|
catch (InvalidOperationException invalidOperationException)
|
|
{
|
|
exception = invalidOperationException;
|
|
}
|
|
finally
|
|
{
|
|
if (exception != null)
|
|
{
|
|
TraceInnerChannelFailure(innerChannel, to, via, exception);
|
|
}
|
|
|
|
if (!completed && innerChannel != null)
|
|
{
|
|
innerChannel.Abort();
|
|
innerChannel = null;
|
|
}
|
|
}
|
|
|
|
return completed;
|
|
}
|
|
|
|
void OnFindProgressChanged(object sender, FindProgressChangedEventArgs e)
|
|
{
|
|
lock (this.thisLock)
|
|
{
|
|
if (!this.discoveryCompleted)
|
|
{
|
|
this.discoveredEndpoints.EnqueueAndDispatch(e.EndpointDiscoveryMetadata, null, false);
|
|
if (++this.totalDiscoveredEndpoints == this.totalExpectedEndpoints)
|
|
{
|
|
this.discoveryCompleted = true;
|
|
this.discoveredEndpoints.Shutdown();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnFindCompleted(object sender, FindCompletedEventArgs e)
|
|
{
|
|
lock (this.thisLock)
|
|
{
|
|
if (!this.discoveryCompleted)
|
|
{
|
|
if (e.Error != null ||
|
|
e.Cancelled ||
|
|
this.totalDiscoveredEndpoints == e.Result.Endpoints.Count)
|
|
{
|
|
this.exception = e.Error;
|
|
this.discoveryCompleted = true;
|
|
this.discoveredEndpoints.Shutdown();
|
|
}
|
|
else
|
|
{
|
|
this.totalExpectedEndpoints = e.Result.Endpoints.Count;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void InitializeAndFindAsync()
|
|
{
|
|
DiscoveryEndpoint discoveryEndpoint = this.discoveryEndpointProvider.GetDiscoveryEndpoint();
|
|
|
|
if (discoveryEndpoint == null)
|
|
{
|
|
throw FxTrace.Exception.AsError(
|
|
new InvalidOperationException(
|
|
SR.DiscoveryMethodImplementationReturnsNull("GetDiscoveryEndpoint", this.discoveryEndpointProvider.GetType())));
|
|
}
|
|
|
|
this.discoveryClient = new DiscoveryClient(discoveryEndpoint);
|
|
this.discoveryClient.FindProgressChanged += new EventHandler<FindProgressChangedEventArgs>(OnFindProgressChanged);
|
|
this.discoveryClient.FindCompleted += new EventHandler<FindCompletedEventArgs>(OnFindCompleted);
|
|
|
|
SynchronizationContext originalSynchronizationContext = SynchronizationContext.Current;
|
|
if (originalSynchronizationContext != null)
|
|
{
|
|
SynchronizationContext.SetSynchronizationContext(null);
|
|
|
|
if (TD.SynchronizationContextSetToNullIsEnabled())
|
|
{
|
|
TD.SynchronizationContextSetToNull();
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
// AsyncOperation uses the SynchronizationContext set during its
|
|
// initialization to Post the FindProgressed and FindProgressCompleted
|
|
// events. Hence even if the async operation does not complete
|
|
// synchronously, the right SynchronizationContext will be used by
|
|
// AsyncOperation.
|
|
this.discoveryClient.FindAsync(this.findCriteria, this);
|
|
}
|
|
finally
|
|
{
|
|
if (originalSynchronizationContext != null)
|
|
{
|
|
SynchronizationContext.SetSynchronizationContext(originalSynchronizationContext);
|
|
|
|
if (TD.SynchronizationContextResetIsEnabled())
|
|
{
|
|
TD.SynchronizationContextReset(originalSynchronizationContext.GetType().ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (TD.FindInitiatedInDiscoveryClientChannelIsEnabled())
|
|
{
|
|
TD.FindInitiatedInDiscoveryClientChannel();
|
|
}
|
|
}
|
|
|
|
void Cleanup(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
Exception exception = null;
|
|
|
|
lock (this.thisLock)
|
|
{
|
|
this.discoveryCompleted = true;
|
|
}
|
|
|
|
try
|
|
{
|
|
this.discoveryClient.CancelAsync(this);
|
|
((ICommunicationObject)this.discoveryClient).Close(timeoutHelper.RemainingTime());
|
|
}
|
|
catch (TimeoutException timeoutException)
|
|
{
|
|
exception = timeoutException;
|
|
}
|
|
catch (CommunicationException communicationException)
|
|
{
|
|
exception = communicationException;
|
|
}
|
|
finally
|
|
{
|
|
if (exception != null && TD.DiscoveryClientInClientChannelFailedToCloseIsEnabled())
|
|
{
|
|
TD.DiscoveryClientInClientChannelFailedToClose(exception);
|
|
}
|
|
}
|
|
|
|
this.discoveredEndpoints.Dispose();
|
|
|
|
this.discoveryClient = null;
|
|
this.discoveredEndpoints = null;
|
|
this.findCriteria = null;
|
|
this.discoveryEndpointProvider = null;
|
|
this.innerChannelFactory = null;
|
|
}
|
|
|
|
static void TraceInnerChannelFailure(TChannel innerChannel, EndpointAddress to, Uri via, Exception exception)
|
|
{
|
|
if (innerChannel == null && TD.InnerChannelCreationFailedIsEnabled())
|
|
{
|
|
TD.InnerChannelCreationFailed(to.ToString(), via.ToString(), exception);
|
|
}
|
|
else if (innerChannel != null && TD.InnerChannelOpenFailedIsEnabled())
|
|
{
|
|
TD.InnerChannelOpenFailed(to.ToString(), via.ToString(), exception);
|
|
}
|
|
}
|
|
|
|
static Uri GetVia(TChannel innerChannel)
|
|
{
|
|
Fx.Assert(innerChannel != null, "TChannel must be non null");
|
|
|
|
IOutputChannel outputChannel = innerChannel as IOutputChannel;
|
|
if (outputChannel != null)
|
|
{
|
|
return outputChannel.Via;
|
|
}
|
|
|
|
IRequestChannel requestChannel = innerChannel as IRequestChannel;
|
|
if (requestChannel != null)
|
|
{
|
|
return requestChannel.Via;
|
|
}
|
|
|
|
Fx.Assert("TChannel must be a type derived from IOutputChannel or IRequestChannel");
|
|
return null;
|
|
}
|
|
|
|
sealed class DiscoveryChannelBuilderAsyncResult : IteratorAsyncResult<DiscoveryChannelBuilderAsyncResult>
|
|
{
|
|
static AsyncStep openStep;
|
|
static AsyncStep dequeueStep;
|
|
TChannel innerChannel;
|
|
|
|
EndpointDiscoveryMetadata currentEndpointDiscoveryMetadata;
|
|
DiscoveryClientChannelBase<TChannel> discoveryClientChannelBase;
|
|
|
|
public DiscoveryChannelBuilderAsyncResult(
|
|
DiscoveryClientChannelBase<TChannel> discoveryClientChannelBase,
|
|
TimeSpan timeout,
|
|
AsyncCallback callback,
|
|
object state)
|
|
: base(callback, state)
|
|
{
|
|
this.discoveryClientChannelBase = discoveryClientChannelBase;
|
|
|
|
this.Start(this, timeout);
|
|
}
|
|
|
|
public static TChannel End(IAsyncResult result)
|
|
{
|
|
DiscoveryChannelBuilderAsyncResult thisPtr = AsyncResult.End<DiscoveryChannelBuilderAsyncResult>(result);
|
|
thisPtr.discoveryClientChannelBase.Cleanup(thisPtr.RemainingTime());
|
|
return thisPtr.innerChannel;
|
|
}
|
|
|
|
protected override IEnumerator<AsyncStep> GetAsyncSteps()
|
|
{
|
|
this.discoveryClientChannelBase.InitializeAndFindAsync();
|
|
|
|
while (true)
|
|
{
|
|
this.currentEndpointDiscoveryMetadata = null;
|
|
yield return DiscoveryChannelBuilderAsyncResult.GetDequeueStep();
|
|
|
|
Exception ex = this.CheckEndpointDiscoveryMetadataAndGetException();
|
|
if (ex != null)
|
|
{
|
|
this.CompleteOnce(ex);
|
|
yield break;
|
|
}
|
|
|
|
bool checkListenUris = (currentEndpointDiscoveryMetadata.ListenUris.Count > 0);
|
|
int index = 0;
|
|
|
|
do
|
|
{
|
|
if (checkListenUris)
|
|
{
|
|
this.CreateChannel(
|
|
this.currentEndpointDiscoveryMetadata.Address,
|
|
this.currentEndpointDiscoveryMetadata.ListenUris[index++]);
|
|
}
|
|
else
|
|
{
|
|
this.CreateChannel(
|
|
this.currentEndpointDiscoveryMetadata.Address,
|
|
this.currentEndpointDiscoveryMetadata.Address.Uri);
|
|
}
|
|
|
|
if (this.innerChannel != null)
|
|
{
|
|
yield return DiscoveryChannelBuilderAsyncResult.GetOpenStep();
|
|
|
|
if (this.innerChannel != null)
|
|
{
|
|
// The channel was successfully opened
|
|
if (TD.InnerChannelOpenSucceededIsEnabled())
|
|
{
|
|
TD.InnerChannelOpenSucceeded(
|
|
this.currentEndpointDiscoveryMetadata.Address.ToString(),
|
|
GetVia(this.innerChannel).ToString());
|
|
}
|
|
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
while (index < this.currentEndpointDiscoveryMetadata.ListenUris.Count);
|
|
}
|
|
}
|
|
|
|
static AsyncStep GetDequeueStep()
|
|
{
|
|
if (dequeueStep == null)
|
|
{
|
|
dequeueStep = DiscoveryChannelBuilderAsyncResult.CallAsync(
|
|
(thisPtr, t, c, s) => thisPtr.discoveryClientChannelBase.discoveredEndpoints.BeginDequeue(thisPtr.RemainingTime(), c, s),
|
|
(thisPtr, r) => thisPtr.currentEndpointDiscoveryMetadata = thisPtr.discoveryClientChannelBase.discoveredEndpoints.EndDequeue(r),
|
|
new IAsyncCatch[]
|
|
{
|
|
new DiscoveryChannelBuilderAsyncResult.AsyncCatch<TimeoutException>(HandleTimeoutException)
|
|
});
|
|
}
|
|
|
|
return dequeueStep;
|
|
}
|
|
|
|
static AsyncStep GetOpenStep()
|
|
{
|
|
if (openStep == null)
|
|
{
|
|
openStep = DiscoveryChannelBuilderAsyncResult.CallAsync(
|
|
(thisPtr, t, c, s) => thisPtr.innerChannel.BeginOpen(thisPtr.RemainingTime(), c, s),
|
|
(thisPtr, r) => thisPtr.innerChannel.EndOpen(r),
|
|
new IAsyncCatch[]
|
|
{
|
|
new DiscoveryChannelBuilderAsyncResult.AsyncCatch<TimeoutException>(HandleTimeoutException),
|
|
new DiscoveryChannelBuilderAsyncResult.AsyncCatch<CommunicationException>(HandleCommunicationException),
|
|
new DiscoveryChannelBuilderAsyncResult.AsyncCatch<Exception>(HandleException)
|
|
});
|
|
}
|
|
|
|
return openStep;
|
|
}
|
|
|
|
static Exception HandleTimeoutException(DiscoveryChannelBuilderAsyncResult thisPtr, TimeoutException e)
|
|
{
|
|
if (thisPtr.innerChannel != null)
|
|
{
|
|
thisPtr.innerChannel.Abort();
|
|
thisPtr.innerChannel = null;
|
|
}
|
|
|
|
return new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(thisPtr.OriginalTimeout), e);
|
|
}
|
|
|
|
static Exception HandleException(DiscoveryChannelBuilderAsyncResult thisPtr, Exception e)
|
|
{
|
|
if (thisPtr.innerChannel != null)
|
|
{
|
|
thisPtr.innerChannel.Abort();
|
|
thisPtr.innerChannel = null;
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
static Exception HandleCommunicationException(DiscoveryChannelBuilderAsyncResult thisPtr, CommunicationException e)
|
|
{
|
|
if (thisPtr.innerChannel != null)
|
|
{
|
|
thisPtr.innerChannel.Abort();
|
|
|
|
if (TD.InnerChannelOpenFailedIsEnabled())
|
|
{
|
|
TD.InnerChannelOpenFailed(
|
|
thisPtr.currentEndpointDiscoveryMetadata.Address.ToString(),
|
|
GetVia(thisPtr.innerChannel).ToString(),
|
|
e);
|
|
}
|
|
|
|
thisPtr.innerChannel = null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
void CreateChannel(EndpointAddress address, Uri listenUri)
|
|
{
|
|
Exception exception = null;
|
|
|
|
try
|
|
{
|
|
this.innerChannel = this.discoveryClientChannelBase.innerChannelFactory.CreateChannel(
|
|
address,
|
|
listenUri);
|
|
}
|
|
catch (ArgumentException argumentException)
|
|
{
|
|
exception = argumentException;
|
|
}
|
|
catch (InvalidOperationException invalidOperationException)
|
|
{
|
|
exception = invalidOperationException;
|
|
}
|
|
catch (CommunicationException communicationException)
|
|
{
|
|
exception = communicationException;
|
|
this.CompleteOnce(communicationException);
|
|
}
|
|
finally
|
|
{
|
|
if (exception != null && TD.InnerChannelCreationFailedIsEnabled())
|
|
{
|
|
TD.InnerChannelCreationFailed(address.ToString(), listenUri.ToString(), exception);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Exception CheckEndpointDiscoveryMetadataAndGetException()
|
|
{
|
|
if (this.RemainingTime() == TimeSpan.Zero)
|
|
{
|
|
return new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(this.OriginalTimeout));
|
|
}
|
|
|
|
if (this.currentEndpointDiscoveryMetadata == null)
|
|
{
|
|
string exceptionMessage = (this.discoveryClientChannelBase.totalDiscoveredEndpoints < 1) ?
|
|
SR.DiscoveryClientChannelEndpointNotFound :
|
|
SR.DiscoveryClientChannelCreationFailed(this.discoveryClientChannelBase.totalDiscoveredEndpoints);
|
|
return new EndpointNotFoundException(exceptionMessage, this.discoveryClientChannelBase.exception);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class CloseAsyncResult : AsyncResult
|
|
{
|
|
TChannel innerChannel;
|
|
|
|
public CloseAsyncResult(TChannel innerChannel, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.innerChannel = innerChannel;
|
|
|
|
if (this.innerChannel != null)
|
|
{
|
|
IAsyncResult closeResult = this.innerChannel.BeginClose(
|
|
timeout,
|
|
PrepareAsyncCompletion(new AsyncCompletion(OnCloseCompleted)),
|
|
this);
|
|
|
|
if (closeResult.CompletedSynchronously && OnCloseCompleted(closeResult))
|
|
{
|
|
this.Complete(true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.Complete(true);
|
|
}
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseAsyncResult>(result);
|
|
}
|
|
|
|
bool OnCloseCompleted(IAsyncResult result)
|
|
{
|
|
this.innerChannel.EndClose(result);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|