protected override SecurityToken EndGetTokenCore(IAsyncResult result)
{
if (result is CompletedAsyncResult <SecurityToken> )
{
return(CompletedAsyncResult <SecurityToken> .End(result));
}
else
{
return(this.EndNegotiation(result));
}
}
internal void EndFactoryClose(IAsyncResult result)
{
if (typeof(CompletedAsyncResult).IsAssignableFrom(result.GetType()))
{
CompletedAsyncResult.End(result);
}
else
{
_channelFactory.EndClose(result);
}
}
protected virtual Message EndSecureOutgoingMessageAtInitiatorCore(IAsyncResult result)
{
if (result is CompletedAsyncResult <Message> )
{
return(CompletedAsyncResult <Message> .End(result));
}
else
{
return(SecureOutgoingMessageAsyncResult.End(result));
}
}
protected override bool EndTryGetChannel(IAsyncResult result)
{
TChannel channel = CompletedAsyncResult <TChannel> .End(result);
if (channel != null && !this.Synchronizer.SetChannel(channel))
{
channel.Abort();
}
return(true);
}
public IAsyncResult BeginAsyncMethod(AsyncCallback callback, object asyncState)
{
IAsyncResult result = new CompletedAsyncResult <int> (3, asyncState);
new Thread(new ThreadStart(
delegate
{
callback(result);
})).Start();
return(result);
}
protected override void EndInitializeChannelFactories(IAsyncResult result)
{
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
}
else
{
this.channelFactory.EndOpen(result);
}
}
protected void EndFlushTrackingRecords(IAsyncResult result)
{
if (this.HasTrackingParticipant)
{
this.TrackingProvider.EndFlushPendingRecords(result);
}
else
{
CompletedAsyncResult.End(result);
}
}
internal void EndChannelClose(IAsyncResult result)
{
if (typeof(CompletedAsyncResult).IsAssignableFrom(result.GetType()))
{
CompletedAsyncResult.End(result);
}
else
{
InnerChannel.EndClose(result);
}
}
public void FromAsync_CompletedWithException()
{
var completed = new CompletedAsyncResult();
Action <IAsyncResult> end = l => {
throw new ApplicationException();
};
Task task = factory.FromAsync(completed, end);
Assert.AreEqual(TaskStatus.Faulted, task.Status, "#1");
}
public void FromAsync_CompletedCanceled()
{
var completed = new CompletedAsyncResult();
Action <IAsyncResult> end = l => {
throw new OperationCanceledException();
};
Task task = factory.FromAsync(completed, end);
Assert.AreEqual(TaskStatus.Canceled, task.Status, "#1");
Assert.IsNull(task.Exception, "#2");
}
bool InternalEndAdd(IAsyncResult result, out MessageAttemptInfo attemptInfo)
{
if (result is CompletedAsyncResult <bool, MessageAttemptInfo> )
{
return(CompletedAsyncResult <bool, MessageAttemptInfo> .End(result, out attemptInfo));
}
else
{
attemptInfo = AsyncQueueAdder.End((AsyncQueueAdder)result);
return(true);
}
}
public void FromAsync_Completed()
{
var completed = new CompletedAsyncResult();
bool?valid = null;
Action <IAsyncResult> end = l => {
valid = l == completed;
};
Task task = factory.FromAsync(completed, end);
Assert.IsTrue(valid == true, "#1");
}
public static void EndClose(IAsyncResult result)
{
// result can be either an CloseOperation or a CompletedAsyncResult
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
}
else
{
CloseOperation.End(result);
}
}
protected override void OnEndClose(IAsyncResult result)
{
if (!(result is CompletedAsyncResult))
{
this.messagingFactory.EndCloseEntity(result);
}
else
{
CompletedAsyncResult.End(result);
}
this.clientLinkManager.Close();
}
protected override void OnEndOpen(IAsyncResult result)
{
if (!base.BatchingEnabled)
{
CompletedAsyncResult.End(result);
}
else
{
this.BatchManager.EndOpen(result);
}
this.SbmpMessagingFactory.ScheduleGetRuntimeEntityDescription(TrackingContext.GetInstance(Guid.NewGuid()), this, this.Path, this.MessageCreator);
}
public override void EndSecureOutgoingMessage(IAsyncResult result,
out Message message, out SecurityProtocolCorrelationState newCorrelationState)
{
if (this.outgoingProtocol != null)
{
this.outgoingProtocol.EndSecureOutgoingMessage(result, out message, out newCorrelationState);
}
else
{
message = CompletedAsyncResult <Message, SecurityProtocolCorrelationState> .End(result, out newCorrelationState);
}
}
protected override void OnEndClose(IAsyncResult result)
{
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
return;
}
if (!result.CompletedSynchronously)
{
this.EndFlush(result);
}
}
protected override void OnEndOpen(IAsyncResult result)
{
if (this.listener != null)
{
this.listener.EndOpen(result);
this.StartAccepting();
}
else
{
CompletedAsyncResult.End(result);
}
}
public override void EndClose(IAsyncResult result)
{
if (result is AlreadyClosedAsyncResult <TState> )
{
CompletedAsyncResult.End(result);
}
else
{
this.closeHandle.EndWait(result);
}
this.AfterClose();
}
public virtual void EndFloodMessage(IAsyncResult result)
{
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
return;
}
FloodAsyncResult fresult = result as FloodAsyncResult;
Fx.Assert(fresult != null, "Invalid AsyncResult type in EndFloodResult");
fresult.End();
}
public void FromAsync_Completed()
{
var completed = new CompletedAsyncResult();
bool?valid = null;
Action <IAsyncResult> end = l => {
Assert.IsFalse(Thread.CurrentThread.IsThreadPoolThread, "#2");
valid = l == completed;
};
Task task = factory.FromAsync(completed, end);
Assert.IsTrue(valid == true, "#1");
}
public void EndClose(IAsyncResult result)
{
if (result is RefcountedCommunicationObject.AlreadyClosedAsyncResult)
{
CompletedAsyncResult.End(result);
return;
}
if (result is RefcountedCommunicationObject.SkippingOperationAsyncResult)
{
CompletedAsyncResult.End(result);
return;
}
RefcountedCommunicationObject.CloseAsyncResult.End(result);
}
public bool EndWaitForRequest(IAsyncResult result)
{
WaitForRequestAsyncResult waitForRequestResult = result as WaitForRequestAsyncResult;
if (waitForRequestResult != null)
{
return(waitForRequestResult.End());
}
else
{
CompletedAsyncResult.End(result);
return(true);
}
}
internal bool EndTryAccept(IAsyncResult result, out IChannelBinder channelBinder)
{
ErrorHandlingCompletedAsyncResult result2 = result as ErrorHandlingCompletedAsyncResult;
if (result2 != null)
{
channelBinder = null;
return(CompletedAsyncResult <bool> .End(result2));
}
try
{
channelBinder = this.binder.EndAccept(result);
if (channelBinder != null)
{
this.dispatcher.PendingChannels.Add(channelBinder.Channel);
}
return(true);
}
catch (CommunicationObjectAbortedException)
{
channelBinder = null;
return(true);
}
catch (CommunicationObjectFaultedException)
{
channelBinder = null;
return(true);
}
catch (TimeoutException)
{
channelBinder = null;
return(false);
}
catch (CommunicationException exception)
{
this.HandleError(exception);
channelBinder = null;
return(false);
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
this.HandleErrorOrAbort(exception2);
channelBinder = null;
return(false);
}
}
public void EndOpen(IAsyncResult result)
{
if (result is RefcountedCommunicationObject.AlreadyOpeningAsyncResult)
{
RefcountedCommunicationObject.AlreadyOpeningAsyncResult.End(result);
return;
}
if (result is RefcountedCommunicationObject.SkippingOperationAsyncResult)
{
CompletedAsyncResult.End(result);
return;
}
RefcountedCommunicationObject.OpenAsyncResult.End(result);
}
public void EndProcessRequest(IAsyncResult result)
{
using (_tracer.Step("LogStreamHandler.EndProcessRequest"))
{
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
}
else
{
_manager.EndProcessRequest(result);
}
}
}
private static bool EndTryReceiveRequestContext(
IAsyncResult result,
out System.ServiceModel.Channels.RequestContext requestContext
)
{
Contract.Assert(result != null);
CompletedAsyncResult <bool> handlerResult = result as CompletedAsyncResult <bool>;
if (handlerResult != null)
{
requestContext = null;
return(CompletedAsyncResult <bool> .End(handlerResult));
}
else
{
try
{
ChannelContext channelContext = (ChannelContext)result.AsyncState;
Contract.Assert(channelContext != null, "context cannot be null");
return(channelContext.Channel.EndTryReceiveRequest(result, out requestContext));
}
catch (CommunicationObjectAbortedException)
{
requestContext = null;
return(true);
}
catch (CommunicationObjectFaultedException)
{
requestContext = null;
return(true);
}
catch (CommunicationException)
{
requestContext = null;
return(false);
}
catch (TimeoutException)
{
requestContext = null;
return(false);
}
catch
{
requestContext = null;
return(false);
}
}
}
public override bool EndTryReceive(IAsyncResult result, out Message message)
{
if (result is CompletedAsyncResult <bool, Message> )
{
return(CompletedAsyncResult <bool, Message> .End(result, out message));
}
bool flag = base.EndTryReceive(result, out message);
if ((flag && (message != null)) && this.receiveContextEnabled)
{
message.Properties[ReceiveContext.Name] = new MsmqSessionReceiveContext(this);
Interlocked.Increment(ref this.incompleteMessageCount);
}
return(flag);
}
public bool EndReceiveMessage(IAsyncResult result, out AmqpMessage message)
{
IEnumerable <AmqpMessage> amqpMessages;
if (!(result is ReceivingAmqpLink.ReceiveAsyncResult))
{
message = CompletedAsyncResult <IEnumerable <AmqpMessage> > .End(result).FirstOrDefault <AmqpMessage>();
return(true);
}
bool flag = ReceivingAmqpLink.ReceiveAsyncResult.End(result, out amqpMessages);
message = amqpMessages.FirstOrDefault <AmqpMessage>();
return(flag);
}
protected override SecurityToken EndGetTokenCore(IAsyncResult result)
{
CompletedAsyncResult caResult = result as CompletedAsyncResult;
if (caResult != null)
{
return(caResult.Token);
}
else
{
GenericXmlSecurityToken token = (GenericXmlSecurityToken)this.innerTokenProvider.EndGetToken(result);
this.cache.AddToken(token, target, issuer);
return(token);
}
}
public IAsyncResult BeginGetToken(AsyncCallback callback, object asyncState)
{
if (HttpContext.Current.Session[cacheKey] == null) {
// The maximum allowable token duration is 480 minutes (8 hours).
// The minimum allowable duration is 15 minutes.
var tokenSpec = new TokenSpecification {
ClientIPAddress = HttpContext.Current.Request.UserHostAddress,
TokenValidityDurationMinutes = 60
};
//IPv6 fix for local dev
if (tokenSpec.ClientIPAddress == "::1")
{
tokenSpec.ClientIPAddress = "127.0.0.1";
}
return commonservice.BeginGetClientToken(tokenSpec, callback, asyncState);
}
//complete the Async call immediately with the cached value
var asyncResult = new CompletedAsyncResult((string)HttpContext.Current.Session[cacheKey], callback, asyncState);
ThreadPool.QueueUserWorkItem(Callback, asyncResult);
return asyncResult;
}
private IAsyncResult StartGetUrl(string url, int cacheDuration, int count, AsyncCallback wcfCallback, object wcfState)
{
/// If the url already exists in cache then there's no need to fetch it from the source.
/// We can just return the response immediately from cache
if (!ConstantHelper.DisableCache && Services.Get<ICache>().Contains(url))
{
WebRequestState myState = new WebRequestState(wcfCallback, wcfState)
{
Url = url,
CacheDuration = cacheDuration,
ContentType = WebOperationContext.Current.IncomingRequest.ContentType,
Count = count
};
// Trigger the completion of the request immediately
var completedState = new CompletedAsyncResult<WebRequestState>(myState, wcfState);
wcfCallback(completedState);
return completedState;
}
else
{
/// The content does not exist in cache and we need to get it from the
/// original source
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.Method = "GET";
WebRequestState myState = new WebRequestState(wcfCallback, wcfState)
{
Request = request,
ContentType = WebOperationContext.Current.IncomingRequest.ContentType,
Url = url,
CacheDuration = cacheDuration,
Count = count
};
IAsyncResult asyncResult = request.BeginGetResponse(new AsyncCallback(HttpGetCallback), myState);
return new CustomAsyncResult<WebRequestState>(asyncResult, myState);
}
}
public void FromAsync_CompletedCanceled ()
{
var completed = new CompletedAsyncResult ();
Action<IAsyncResult> end = l => {
throw new OperationCanceledException ();
};
Task task = factory.FromAsync (completed, end);
Assert.AreEqual (TaskStatus.Canceled, task.Status, "#1");
Assert.IsNull (task.Exception, "#2");
}
public void FromAsync_CompletedWithException ()
{
var completed = new CompletedAsyncResult ();
Action<IAsyncResult> end = l => {
throw new ApplicationException ();
};
Task task = factory.FromAsync (completed, end);
Assert.AreEqual (TaskStatus.Faulted, task.Status, "#1");
}
public void FromAsync_Completed ()
{
var completed = new CompletedAsyncResult ();
bool? valid = null;
Action<IAsyncResult> end = l => {
Assert.IsFalse (Thread.CurrentThread.IsThreadPoolThread, "#2");
valid = l == completed;
};
Task task = factory.FromAsync (completed, end);
Assert.IsTrue (valid == true, "#1");
}
public void FromAsync_ArgumentsCheck ()
{
var result = new CompletedAsyncResult ();
try {
factory.FromAsync (null, l => { });
Assert.Fail ("#1");
} catch (ArgumentNullException) {
}
try {
factory.FromAsync (result, null);
Assert.Fail ("#2");
} catch (ArgumentNullException) {
}
try {
factory.FromAsync (result, l => { }, TaskCreationOptions.LongRunning);
Assert.Fail ("#3");
} catch (ArgumentOutOfRangeException) {
}
try {
factory.FromAsync (result, l => { }, TaskCreationOptions.PreferFairness);
Assert.Fail ("#4");
} catch (ArgumentOutOfRangeException) {
}
try {
factory.FromAsync (result, l => { }, TaskCreationOptions.None, null);
Assert.Fail ("#5");
} catch (ArgumentNullException) {
}
try {
factory.FromAsync (null, l => { }, null, TaskCreationOptions.None);
Assert.Fail ("#6");
} catch (ArgumentNullException) {
}
try {
factory.FromAsync ((a, b) => null, l => { }, null, TaskCreationOptions.LongRunning);
Assert.Fail ("#7");
} catch (ArgumentOutOfRangeException) {
}
}
public void BeginWrite_WhenCompletedSynchronously_CallsCallbackAndReturnsCompletedResult()
{
// Arrange
object expectedState = new object();
ExpectedAsyncResult expectedResult = new ExpectedAsyncResult
{
AsyncState = expectedState,
CompletedSynchronously = true,
IsCompleted = true
};
bool callbackCalled = false;
IAsyncResult callbackResult = null;
Stream product = null;
AsyncCallback callback = (ar) =>
{
callbackResult = ar;
AssertEqual(expectedResult, ar);
callbackCalled = true;
};
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
innerStreamMock
.Setup(s => s.BeginWrite(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(),
It.IsAny<AsyncCallback>(), It.IsAny<object>()))
.Returns<byte[], int, int, AsyncCallback, object>((i1, i2, i3, c, s) =>
{
IAsyncResult r = new CompletedAsyncResult(s);
if (c != null) c.Invoke(r);
return r;
});
innerStreamMock.SetupEndWrite();
CloudBlobStream innerStream = innerStreamMock.Object;
product = CreateProductUnderTest(innerStream);
byte[] buffer = new byte[0];
int offset = 123;
int count = 456;
// Act
IAsyncResult result = product.BeginWrite(buffer, offset, count, callback, expectedState);
// Assert
Assert.True(callbackCalled);
// An AsyncCallback must be called with the same IAsyncResult instance as the Begin method returned.
Assert.Same(result, callbackResult);
AssertEqual(expectedResult, result, disposeActual: true);
}
