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); }