internal void AfterReceiveReply(ref ProxyRpc rpc)
{
int offset = MessageInspectorCorrelationOffset;
try
{
for (int i = 0; i < messageInspectors.Length; i++)
{
messageInspectors[i].AfterReceiveReply(ref rpc.Reply, rpc.Correlation[offset + i]);
//if (TD.ClientMessageInspectorAfterReceiveInvokedIsEnabled())
//{
// TD.ClientMessageInspectorAfterReceiveInvoked(rpc.EventTraceActivity, this.messageInspectors[i].GetType().FullName);
//}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
internal void Init()
{
errorBehavior = new ErrorBehavior(this);
filterTable = new EndpointDispatcherTable(ThisLock);
for (int i = 0; i < endpointDispatchers.Count; i++)
{
EndpointDispatcher endpoint = endpointDispatchers[i];
// Force a build of the runtime to catch any unexpected errors before we are done opening.
endpoint.DispatchRuntime.GetRuntime();
// Lock down the DispatchRuntime.
endpoint.DispatchRuntime.LockDownProperties();
filterTable.AddEndpoint(endpoint);
if ((addressTable != null) && (endpoint.OriginalAddress != null))
{
addressTable.Add(endpoint.AddressFilter, endpoint.OriginalAddress, endpoint.FilterPriority);
}
//if (DiagnosticUtility.ShouldTraceInformation)
//{
// this.TraceEndpointLifetime(endpoint, TraceCode.EndpointListenerOpen, SR.Format(SR.TraceCodeEndpointListenerOpen));
//}
}
}
internal void BeforeSendRequest(ref ProxyRpc rpc)
{
int offset = MessageInspectorCorrelationOffset;
try
{
for (int i = 0; i < messageInspectors.Length; i++)
{
rpc.Correlation[offset + i] = messageInspectors[i].BeforeSendRequest(ref rpc.Request, (IClientChannel)rpc.Channel.Proxy);
//if (TD.ClientMessageInspectorBeforeSendInvokedIsEnabled())
//{
// TD.ClientMessageInspectorBeforeSendInvoked(rpc.EventTraceActivity, this.messageInspectors[i].GetType().FullName);
//}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
//if (this.addTransactionFlowProperties)
//{
// SendTransaction(ref rpc);
//}
}
internal bool HandleError(Exception error, ref ErrorHandlerFaultInfo faultInfo)
{
ErrorBehavior behavior;
lock (ThisLock)
{
if (_errorBehavior != null)
{
behavior = _errorBehavior;
}
else
{
behavior = new ErrorBehavior(this);
}
}
if (behavior != null)
{
return(behavior.HandleError(error, ref faultInfo));
}
else
{
return(false);
}
}
void InitializeCallContextCore(MessageRpc rpc)
{
IClientChannel channel = rpc.Channel.Proxy as IClientChannel;
int offset = Parent.CallContextCorrelationOffset;
try
{
for (int i = 0; i < rpc.Operation.CallContextInitializers.Length; i++)
{
ICallContextInitializer initializer = CallContextInitializers[i];
rpc.Correlation[offset + i] = initializer.BeforeInvoke(rpc.InstanceContext, channel, rpc.Request);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
internal void BeforeRequest(ref ProxyRpc rpc)
{
int offset = _parent.ParameterInspectorCorrelationOffset;
try
{
for (int i = 0; i < _parameterInspectors.Length; i++)
{
rpc.Correlation[offset + i] = _parameterInspectors[i].BeforeCall(_name, rpc.InputParameters);
//if (TD.ClientParameterInspectorBeforeCallInvokedIsEnabled())
//{
// TD.ClientParameterInspectorBeforeCallInvoked(rpc.EventTraceActivity, this._parameterInspectors[i].GetType().FullName);
//}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (_serializeRequest)
{
//if (TD.ClientFormatterSerializeRequestStartIsEnabled())
//{
// TD.ClientFormatterSerializeRequestStart(rpc.EventTraceActivity);
//}
rpc.Request = _formatter.SerializeRequest(rpc.MessageVersion, rpc.InputParameters);
//if (TD.ClientFormatterSerializeRequestStopIsEnabled())
//{
// TD.ClientFormatterSerializeRequestStop(rpc.EventTraceActivity);
//}
}
else
{
if (rpc.InputParameters[0] == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxProxyRuntimeMessageCannotBeNull, _name)));
}
rpc.Request = (Message)rpc.InputParameters[0];
if (!IsValidAction(rpc.Request, Action))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInvalidRequestAction, Name, rpc.Request.Headers.Action ?? "{NULL}", Action)));
}
}
}
internal ImmutableDispatchRuntime(DispatchRuntime dispatch)
{
_authenticationBehavior = AuthenticationBehavior.TryCreate(dispatch);
_authorizationBehavior = AuthorizationBehavior.TryCreate(dispatch);
_concurrency = new ConcurrencyBehavior(dispatch);
_error = new ErrorBehavior(dispatch.ChannelDispatcher);
_enableFaults = dispatch.EnableFaults;
_inputSessionShutdownHandlers = EmptyArray <IInputSessionShutdown> .ToArray(dispatch.InputSessionShutdownHandlers);
InstanceBehavior = new InstanceBehavior(dispatch, this);
_isOnServer = dispatch.IsOnServer;
_manualAddressing = dispatch.ManualAddressing;
_messageInspectors = EmptyArray <IDispatchMessageInspector> .ToArray(dispatch.MessageInspectors);
_securityImpersonation = SecurityImpersonationBehavior.CreateIfNecessary(dispatch);
RequireClaimsPrincipalOnOperationContext = dispatch.RequireClaimsPrincipalOnOperationContext;
_impersonateOnSerializingReply = dispatch.ImpersonateOnSerializingReply;
_terminate = TerminatingOperationBehavior.CreateIfNecessary(dispatch);
_thread = new ThreadBehavior(dispatch);
ValidateMustUnderstand = dispatch.ValidateMustUnderstand;
ParameterInspectorCorrelationOffset = (dispatch.MessageInspectors.Count +
dispatch.MaxCallContextInitializers);
_correlationCount = ParameterInspectorCorrelationOffset + dispatch.MaxParameterInspectors;
DispatchOperationRuntime unhandled = new DispatchOperationRuntime(dispatch.UnhandledDispatchOperation, this);
if (dispatch.OperationSelector == null)
{
ActionDemuxer demuxer = new ActionDemuxer();
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Action, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
_demuxer = demuxer;
}
else
{
CustomDemuxer demuxer = new CustomDemuxer(dispatch.OperationSelector);
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Name, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
_demuxer = demuxer;
}
_processMessageNonCleanupError = new MessageRpcErrorHandler(ProcessMessageNonCleanupError);
_processMessageCleanupError = new MessageRpcErrorHandler(ProcessMessageCleanupError);
}
private async Task ReplyFailureAsync(RequestContext request, RequestInfo requestInfo, Message fault, string action, string reason, FaultCode code)
{
FaultException exception = new FaultException(reason, code);
ErrorBehavior.ThrowAndCatch(exception);
ErrorHandlerFaultInfo faultInfo = new ErrorHandlerFaultInfo(action);
faultInfo.Fault = fault;
faultInfo = await ProvideFaultAndReplyFailureAsync(request, requestInfo, exception, faultInfo);
HandleError(exception, ref faultInfo);
}
internal ProxyOperationRuntime GetOperation(MethodBase methodBase, object[] args, out bool canCacheResult)
{
if (operationSelector == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException
(SR.Format(SR.SFxNeedProxyBehaviorOperationSelector2, methodBase.Name,
methodBase.DeclaringType.Name)));
}
try
{
if (operationSelector.AreParametersRequiredForSelection)
{
canCacheResult = false;
}
else
{
args = null;
canCacheResult = true;
}
string operationName = operationSelector.SelectOperation(methodBase, args);
ProxyOperationRuntime operation;
if ((operationName != null) && operations.TryGetValue(operationName, out operation))
{
return(operation);
}
else
{
// did not find the right operation, will not know how
// to invoke the method.
return(null);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
// TODO: Move this functionality somewhere else as this class is now OM only
internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo)
{
ErrorBehavior behavior;
lock (ThisLock)
{
if (_errorBehavior != null)
{
behavior = _errorBehavior;
}
else
{
behavior = new ErrorBehavior(this);
}
}
behavior.ProvideFault(e, faultConverter, ref faultInfo);
}
// this should not be inlined, since we want to JIT the reference to System.Transactions
// only if transactions are being flowed.
//[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
//static void SendTransaction(ref ProxyRpc rpc)
//{
// System.ServiceModel.Channels.TransactionFlowProperty.Set(Transaction.Current, rpc.Request);
//}
internal void InitializeChannel(IClientChannel channel)
{
try
{
for (int i = 0; i < channelInitializers.Length; ++i)
{
channelInitializers[i].Initialize(channel);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
internal void AfterReply(ref MessageRpc rpc, ErrorBehavior error)
{
InstanceContext context = rpc.InstanceContext;
if (context != null)
{
try
{
if (rpc.Operation.ReleaseInstanceAfterCall)
{
if (context.State == CommunicationState.Opened)
{
context.ReleaseServiceInstance();
}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
error.HandleError(e);
}
try
{
context.UnbindRpc(rpc);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
error.HandleError(e);
}
}
}
void SerializeOutputs(ref MessageRpc rpc)
{
if (!IsOneWay && parent.EnableFaults)
{
Message reply;
if (serializeReply)
{
try
{
//if (TD.DispatchFormatterSerializeReplyStartIsEnabled())
//{
// TD.DispatchFormatterSerializeReplyStart(rpc.EventTraceActivity);
//}
reply = Formatter.SerializeReply(rpc.RequestVersion, rpc.OutputParameters, rpc.ReturnParameter);
//if (TD.DispatchFormatterSerializeReplyStopIsEnabled())
//{
// TD.DispatchFormatterSerializeReplyStop(rpc.EventTraceActivity);
//}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (reply == null)
{
string message = SR.Format(SR.SFxNullReplyFromFormatter2, Formatter.GetType().ToString(), (name ?? ""));
ErrorBehavior.ThrowAndCatch(new InvalidOperationException(message));
}
}
else
{
if ((rpc.ReturnParameter == null) && (rpc.OperationContext.RequestContext != null))
{
string message = SR.Format(SR.SFxDispatchRuntimeMessageCannotBeNull, name);
ErrorBehavior.ThrowAndCatch(new InvalidOperationException(message));
}
reply = (Message)rpc.ReturnParameter;
if ((reply != null) && (!ProxyOperationRuntime.IsValidAction(reply, ReplyAction)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInvalidReplyAction, Name, reply.Headers.Action ?? "{NULL}", ReplyAction)));
}
}
//if (DiagnosticUtility.ShouldUseActivity && rpc.Activity != null && reply != null)
//{
// TraceUtility.SetActivity(reply, rpc.Activity);
// if (TraceUtility.ShouldPropagateActivity)
// {
// TraceUtility.AddActivityHeader(reply);
// }
//}
//else if (TraceUtility.ShouldPropagateActivity && reply != null && rpc.ResponseActivityId != Guid.Empty)
//{
// ActivityIdHeader header = new ActivityIdHeader(rpc.ResponseActivityId);
// header.AddTo(reply);
//}
//rely on the property set during the message receive to correlate the trace
//if (TraceUtility.MessageFlowTracingOnly)
//{
// //Guard against MEX scenarios where the message is closed by now
// if (null != rpc.OperationContext.IncomingMessage && MessageState.Closed != rpc.OperationContext.IncomingMessage.State)
// {
// FxTrace.Trace.SetAndTraceTransfer(TraceUtility.GetReceivedActivityId(rpc.OperationContext), true);
// }
// else
// {
// if (rpc.ResponseActivityId != Guid.Empty)
// {
// FxTrace.Trace.SetAndTraceTransfer(rpc.ResponseActivityId, true);
// }
// }
//}
// Add the ImpersonateOnSerializingReplyMessageProperty on the reply message iff
// a. reply message is not null.
// b. Impersonation is enabled on serializing Reply
//if (reply != null && this.parent.IsImpersonationEnabledOnSerializingReply)
//{
// bool shouldImpersonate = this.parent.SecurityImpersonation != null && this.parent.SecurityImpersonation.IsImpersonationEnabledOnCurrentOperation(ref rpc);
// if (shouldImpersonate)
// {
// reply.Properties.Add(ImpersonateOnSerializingReplyMessageProperty.Name, new ImpersonateOnSerializingReplyMessageProperty(ref rpc));
// reply = new ImpersonatingMessage(reply);
// }
//}
//if (MessageLogger.LoggingEnabled && null != reply)
//{
// MessageLogger.LogMessage(ref reply, MessageLoggingSource.ServiceLevelSendReply | MessageLoggingSource.LastChance);
//}
rpc.Reply = reply;
}
}
//bool didTraceProcessMessage1 = false;
//bool didTraceProcessMessage2 = false;
//bool didTraceProcessMessage3 = false;
//bool didTraceProcessMessage31 = false;
//bool didTraceProcessMessage4 = false;
//bool didTraceProcessMessage41 = false;
internal ImmutableDispatchRuntime(DispatchRuntime dispatch)
{
//this.authenticationBehavior = AuthenticationBehavior.TryCreate(dispatch);
//this.authorizationBehavior = AuthorizationBehavior.TryCreate(dispatch);
concurrency = new ConcurrencyBehavior(dispatch);
error = new ErrorBehavior(dispatch.ChannelDispatcher);
enableFaults = dispatch.EnableFaults;
inputSessionShutdownHandlers = EmptyArray <IInputSessionShutdown> .ToArray(dispatch.InputSessionShutdownHandlers);
instance = new InstanceBehavior(dispatch, this);
isOnServer = dispatch.IsOnServer;
manualAddressing = dispatch.ManualAddressing;
messageInspectors = EmptyArray <IDispatchMessageInspector> .ToArray(dispatch.MessageInspectors);
//this.requestReplyCorrelator = new RequestReplyCorrelator();
//this.securityImpersonation = SecurityImpersonationBehavior.CreateIfNecessary(dispatch);
//this.RequireClaimsPrincipalOnOperationContext = dispatch.RequireClaimsPrincipalOnOperationContext;
//this.impersonateOnSerializingReply = dispatch.ImpersonateOnSerializingReply;
terminate = TerminatingOperationBehavior.CreateIfNecessary(dispatch);
thread = new ThreadBehavior(dispatch);
ValidateMustUnderstand = dispatch.ValidateMustUnderstand;
//this.ignoreTransactionFlow = dispatch.IgnoreTransactionMessageProperty;
//this.transaction = TransactionBehavior.CreateIfNeeded(dispatch);
//sendAsynchronously = dispatch.ChannelDispatcher.SendAsynchronously;
ParameterInspectorCorrelationOffset = (dispatch.MessageInspectors.Count +
dispatch.MaxCallContextInitializers);
correlationCount = ParameterInspectorCorrelationOffset + dispatch.MaxParameterInspectors;
DispatchOperationRuntime unhandled = new DispatchOperationRuntime(dispatch.UnhandledDispatchOperation, this);
if (dispatch.OperationSelector == null)
{
ActionDemuxer demuxer = new ActionDemuxer();
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Action, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
this.demuxer = demuxer;
}
else
{
throw new PlatformNotSupportedException();
// CustomDemuxer demuxer = new CustomDemuxer(dispatch.OperationSelector);
// for (int i = 0; i < dispatch.Operations.Count; i++)
// {
// DispatchOperation operation = dispatch.Operations[i];
// DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
// demuxer.Add(operation.Name, operationRuntime);
// }
// demuxer.SetUnhandled(unhandled);
// this.demuxer = demuxer;
}
//processMessage1 = new MessageRpcProcessor(ProcessMessage1);
//processMessage11 = new MessageRpcProcessor(ProcessMessage11);
//processMessage2 = new MessageRpcProcessor(ProcessMessage2);
//processMessage3 = new MessageRpcProcessor(ProcessMessage3);
//processMessage31 = new MessageRpcProcessor(ProcessMessage31);
//processMessage4 = new MessageRpcProcessor(ProcessMessage4);
//processMessage41 = new MessageRpcProcessor(ProcessMessage41);
//processMessage5 = new MessageRpcProcessor(ProcessMessage5);
//processMessage6 = new MessageRpcProcessor(ProcessMessage6);
//processMessage7 = new MessageRpcProcessor(ProcessMessage7);
//processMessage8 = new MessageRpcProcessor(ProcessMessage8);
//processMessage9 = new MessageRpcProcessor(ProcessMessage9);
//processMessageCleanup = new MessageRpcProcessor(ProcessMessageCleanup);
processMessageNonCleanupError = new MessageRpcErrorHandler(ProcessMessageNonCleanupError);
processMessageCleanupError = new MessageRpcErrorHandler(ProcessMessageCleanupError);
}
internal void AfterReply(ref ProxyRpc rpc)
{
if (!_isOneWay)
{
Message reply = rpc.Reply;
if (_deserializeReply)
{
//if (TD.ClientFormatterDeserializeReplyStartIsEnabled())
//{
// TD.ClientFormatterDeserializeReplyStart(rpc.EventTraceActivity);
//}
rpc.ReturnValue = _formatter.DeserializeReply(reply, rpc.OutputParameters);
//if (TD.ClientFormatterDeserializeReplyStopIsEnabled())
//{
// TD.ClientFormatterDeserializeReplyStop(rpc.EventTraceActivity);
//}
}
else
{
rpc.ReturnValue = reply;
}
int offset = _parent.ParameterInspectorCorrelationOffset;
try
{
for (int i = _parameterInspectors.Length - 1; i >= 0; i--)
{
_parameterInspectors[i].AfterCall(_name,
rpc.OutputParameters,
rpc.ReturnValue,
rpc.Correlation[offset + i]);
//if (TD.ClientParameterInspectorAfterCallInvokedIsEnabled())
//{
// TD.ClientParameterInspectorAfterCallInvoked(rpc.EventTraceActivity, this._parameterInspectors[i].GetType().FullName);
//}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (_parent.ValidateMustUnderstand)
{
Collection <MessageHeaderInfo> headersNotUnderstood = reply.Headers.GetHeadersNotUnderstood();
if (headersNotUnderstood != null && headersNotUnderstood.Count > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.Format(SR.SFxHeaderNotUnderstood, headersNotUnderstood[0].Name, headersNotUnderstood[0].Namespace)));
}
}
}
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
outputs = EmptyArray <object> .Allocate(0);
Message message = inputs[0] as Message;
if (message == null)
{
return(null);
}
string action = message.Headers.Action;
//if (DiagnosticUtility.ShouldTraceInformation)
//{
// TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.UnhandledAction,
// SR.TraceCodeUnhandledAction,
// new StringTraceRecord("Action", action),
// this, null, message);
//}
FaultCode code = FaultCode.CreateSenderFaultCode(AddressingStrings.ActionNotSupported,
message.Version.Addressing.Namespace);
string reasonText = SR.Format(SR.SFxNoEndpointMatchingContract, action);
FaultReason reason = new FaultReason(reasonText);
FaultException exception = new FaultException(reason, code);
ErrorBehavior.ThrowAndCatch(exception);
ServiceChannel serviceChannel = OperationContext.Current.InternalServiceChannel;
OperationContext.Current.OperationCompleted +=
delegate(object sender, EventArgs e)
{
ChannelDispatcher channelDispatcher = dispatchRuntime.ChannelDispatcher;
if (!channelDispatcher.HandleError(exception) && serviceChannel.HasSession)
{
try
{
var helper = new TimeoutHelper(ChannelHandler.CloseAfterFaultTimeout);
serviceChannel.CloseAsync(helper.GetCancellationToken()).GetAwaiter().GetResult();
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
channelDispatcher.HandleError(ex);
}
}
};
if (dispatchRuntime.shared.EnableFaults)
{
MessageFault fault = MessageFault.CreateFault(code, reason, action);
return(Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction));
}
else
{
OperationContext.Current.RequestContext.CloseAsync().GetAwaiter().GetResult();
OperationContext.Current.RequestContext = null;
return(null);
}
}
//internal bool TransactionAutoComplete
//{
// get { return this.transactionAutoComplete; }
//}
//internal bool TransactionRequired
//{
// get { return this.transactionRequired; }
//}
//internal bool IsInsideTransactedReceiveScope
//{
// get { return this.isInsideTransactedReceiveScope; }
//}
void DeserializeInputs(MessageRpc rpc)
{
//bool success = false;
try
{
try
{
rpc.InputParameters = Invoker.AllocateInputs();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
try
{
// If the field is true, then this operation is to be invoked at the time the service
// channel is opened. The incoming message is created at ChannelHandler level with no
// content, so we don't need to deserialize the message.
if (!isSessionOpenNotificationEnabled)
{
if (deserializeRequest)
{
//if (TD.DispatchFormatterDeserializeRequestStartIsEnabled())
//{
// TD.DispatchFormatterDeserializeRequestStart(rpc.EventTraceActivity);
//}
Formatter.DeserializeRequest(rpc.Request, rpc.InputParameters);
//if (TD.DispatchFormatterDeserializeRequestStopIsEnabled())
//{
// TD.DispatchFormatterDeserializeRequestStop(rpc.EventTraceActivity);
//}
}
else
{
rpc.InputParameters[0] = rpc.Request;
}
}
//success = true;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
finally
{
rpc.DidDeserializeRequestBody = (rpc.Request.State != MessageState.Created);
//if (!success && MessageLogger.LoggingEnabled)
//{
// MessageLogger.LogMessage(rpc.Request, MessageLoggingSource.Malformed);
//}
}
}