Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

390 lines
14 KiB
C#

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System.Runtime;
using System.ServiceModel.Channels;
using System.Transactions;
class ReceiveContextRPCFacet
{
static AsyncCallback handleEndComplete = Fx.ThunkCallback(new AsyncCallback(HandleEndComplete));
ReceiveContext receiveContext;
ReceiveContextRPCFacet(ReceiveContext receiveContext)
{
this.receiveContext = receiveContext;
}
//Called from ProcessMessage1
//ManualAcknowledgementMode : No-Op.
//Non-transacted V1 Operation : Remove RC; RC.Complete;(Will pause RPC if truly async)
//Else : Create and Attach RCFacet to MessageRPC.
public static void CreateIfRequired(ImmutableDispatchRuntime dispatchRuntime, ref MessageRpc messageRpc)
{
if (messageRpc.Operation.ReceiveContextAcknowledgementMode == ReceiveContextAcknowledgementMode.ManualAcknowledgement)
{
//Manual mode, user owns the acknowledgement.
return;
}
//Retrieve RC from request and ensure it is removed from Message.
ReceiveContext receiveContext = null;
if (!ReceiveContext.TryGet(messageRpc.Request, out receiveContext))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.SFxReceiveContextPropertyMissing,
typeof(ReceiveContext).Name)));
}
messageRpc.Request.Properties.Remove(ReceiveContext.Name);
if (messageRpc.Operation.ReceiveContextAcknowledgementMode == ReceiveContextAcknowledgementMode.AutoAcknowledgeOnReceive)
{
if (!messageRpc.Operation.TransactionRequired)
{
//Attempt to complete the ReceiveContext.
//Async Result Ensures RPC is paused if it goes ASYNC.
IAsyncResult result = new AcknowledgementCompleteAsyncResult(
receiveContext,
TimeSpan.MaxValue,
ref messageRpc,
null,
handleEndComplete,
new AcknowledgementCompleteCallbackState
{
DispatchRuntime = dispatchRuntime,
Rpc = messageRpc
});
if (result.CompletedSynchronously)
{
AcknowledgementCompleteAsyncResult.End(result);
}
return;
}
}
//We have to create a Facet for acknowledgement at later stage.
messageRpc.ReceiveContext = new ReceiveContextRPCFacet(receiveContext);
}
//Called from ProcessMessage31.
//Mode is TransactedOperation && !ManualAcknowledgement
//Will pause RPC if Complete is truly Async.
public void Complete(ImmutableDispatchRuntime dispatchRuntime, ref MessageRpc rpc, TimeSpan timeout, Transaction transaction)
{
Fx.Assert(transaction != null, "Cannot reach here with null transaction");
//Async Result Ensures the RPC is paused if the request goes Async.
IAsyncResult result = new AcknowledgementCompleteAsyncResult(
this.receiveContext,
timeout,
ref rpc,
transaction,
handleEndComplete,
new AcknowledgementCompleteCallbackState
{
DispatchRuntime = dispatchRuntime,
Rpc = rpc
});
if (result.CompletedSynchronously)
{
AcknowledgementCompleteAsyncResult.End(result);
}
}
//Called from RPC.DisposeRequestContext for sucessful invoke.
//Mode is RCBA.ManualAcknowledgement = false.
public IAsyncResult BeginComplete(TimeSpan timeout, Transaction transaction, ChannelHandler channelHandler, AsyncCallback callback, object state)
{
IAsyncResult result = null;
if (transaction != null)
{
using (TransactionScope scope = new TransactionScope(transaction))
{
TransactionOutcomeListener.EnsureReceiveContextAbandonOnTransactionRollback(this.receiveContext, transaction, channelHandler);
result = this.receiveContext.BeginComplete(
timeout,
callback,
state);
scope.Complete();
}
}
else
{
result = this.receiveContext.BeginComplete(
timeout,
callback,
state);
}
return result;
}
public void EndComplete(IAsyncResult result)
{
this.receiveContext.EndComplete(result);
}
//Called from RPC.AbortRequestContext for failed invoke.
//Mode is RCBA.ManualAcknowledgement = false.
public IAsyncResult BeginAbandon(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.receiveContext.BeginAbandon(
timeout,
callback,
state);
}
public void EndAbandon(IAsyncResult result)
{
this.receiveContext.EndAbandon(result);
}
//Callback handler for ReceiveContext.BeginComplete made from ProcessMessage*
static void HandleEndComplete(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
try
{
AcknowledgementCompleteAsyncResult.End(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
AcknowledgementCompleteCallbackState callbackState = (AcknowledgementCompleteCallbackState)result.AsyncState;
MessageRpc rpc = callbackState.Rpc;
rpc.Error = e;
callbackState.DispatchRuntime.ErrorBehavior.HandleError(ref rpc);
return;
}
}
class AcknowledgementCompleteCallbackState
{
public ImmutableDispatchRuntime DispatchRuntime
{
get;
set;
}
public MessageRpc Rpc
{
get;
set;
}
}
class AcknowledgementCompleteAsyncResult : AsyncResult
{
static AsyncCallback completeCallback = Fx.ThunkCallback(new AsyncCallback(CompleteCallback));
IResumeMessageRpc resumableRPC;
ReceiveContext receiveContext;
Transaction currentTransaction;
ChannelHandler channelHandler;
public AcknowledgementCompleteAsyncResult(
ReceiveContext receiveContext,
TimeSpan timeout,
ref MessageRpc rpc,
Transaction transaction,
AsyncCallback callback,
object state) : base(callback, state)
{
this.receiveContext = receiveContext;
this.currentTransaction = transaction;
this.channelHandler = rpc.channelHandler;
this.resumableRPC = rpc.Pause();
bool completeThrew = true;
try
{
bool completed = this.Complete(timeout);
completeThrew = false;
if (completed)
{
this.resumableRPC = null;
rpc.UnPause();
this.Complete(true);
}
}
finally
{
if (completeThrew)
{
rpc.UnPause();
}
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End<AcknowledgementCompleteAsyncResult>(result);
}
bool Complete(TimeSpan timeout)
{
IAsyncResult result = null;
if (this.currentTransaction != null)
{
using (TransactionScope scope = new TransactionScope(this.currentTransaction))
{
TransactionOutcomeListener.EnsureReceiveContextAbandonOnTransactionRollback(this.receiveContext, this.currentTransaction, this.channelHandler);
result = this.receiveContext.BeginComplete(
timeout,
completeCallback,
this);
scope.Complete();
}
}
else
{
result = this.receiveContext.BeginComplete(
timeout,
completeCallback,
this);
}
if (result.CompletedSynchronously)
{
return HandleComplete(result);
}
return false;
}
static bool HandleComplete(IAsyncResult result)
{
AcknowledgementCompleteAsyncResult thisPtr = (AcknowledgementCompleteAsyncResult)result.AsyncState;
thisPtr.receiveContext.EndComplete(result);
return true;
}
static void CompleteCallback(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
//Async Completion Path.
Exception completionException = null;
bool completeSelf = true;
try
{
completeSelf = HandleComplete(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
completionException = e;
}
if (completeSelf)
{
AcknowledgementCompleteAsyncResult thisPtr = (AcknowledgementCompleteAsyncResult)result.AsyncState;
thisPtr.resumableRPC.Resume();
thisPtr.Complete(false, completionException);
}
}
}
class TransactionOutcomeListener
{
static AsyncCallback abandonCallback = Fx.ThunkCallback(new AsyncCallback(AbandonCallback));
ReceiveContext receiveContext;
ChannelHandler channelHandler;
public TransactionOutcomeListener(ReceiveContext receiveContext, Transaction transaction, ChannelHandler handler)
{
this.receiveContext = receiveContext;
transaction.TransactionCompleted += new TransactionCompletedEventHandler(this.OnTransactionComplete);
this.channelHandler = handler;
}
public static void EnsureReceiveContextAbandonOnTransactionRollback(ReceiveContext receiveContext, Transaction transaction, ChannelHandler channelHandler)
{
new TransactionOutcomeListener(receiveContext, transaction, channelHandler);
}
void OnTransactionComplete(object sender, TransactionEventArgs e)
{
if (e.Transaction.TransactionInformation.Status == TransactionStatus.Aborted)
{
try
{
IAsyncResult result = this.receiveContext.BeginAbandon(
TimeSpan.MaxValue,
abandonCallback,
new CallbackState
{
ChannelHandler = this.channelHandler,
ReceiveContext = this.receiveContext
});
if (result.CompletedSynchronously)
{
this.receiveContext.EndAbandon(result);
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.channelHandler.HandleError(exception);
}
}
}
static void AbandonCallback(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
CallbackState callbackState = (CallbackState)result.AsyncState;
try
{
callbackState.ReceiveContext.EndAbandon(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
callbackState.ChannelHandler.HandleError(e);
}
}
class CallbackState
{
public ChannelHandler ChannelHandler
{
get;
set;
}
public ReceiveContext ReceiveContext
{
get;
set;
}
}
}
}
}