internal bool HandleError(Exception error)
{
ErrorHandlerFaultInfo dummy = new ErrorHandlerFaultInfo();
return(HandleError(error, ref dummy));
}
internal MessageRpc(RequestContext requestContext, Message request, DispatchOperationRuntime operation,
ServiceChannel channel, ServiceHostBase host, ChannelHandler channelHandler, bool cleanThread,
OperationContext operationContext, InstanceContext instanceContext /*, EventTraceActivity eventTraceActivity*/)
{
Fx.Assert((operationContext != null), "correwcf.Dispatcher.MessageRpc.MessageRpc(), operationContext == null");
// TODO: ChannelHandler supplied an ErrorHandler, need to supply this some other way.
//Fx.Assert(channelHandler != null, "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), channelHandler == null");
//this.Activity = null;
//this.EventTraceActivity = eventTraceActivity;
AsyncResult = null;
TaskResult = null;
CanSendReply = true;
Channel = channel;
this.channelHandler = channelHandler;
Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount);
DidDeserializeRequestBody = false;
Error = null;
ErrorProcessor = null;
FaultInfo = new ErrorHandlerFaultInfo(request.Version.Addressing.DefaultFaultAction);
HasSecurityContext = false;
Host = host;
Instance = null;
AsyncProcessor = null;
NotUnderstoodHeaders = null;
Operation = operation;
OperationContext = operationContext;
paused = false;
ParametersDisposed = false;
Request = request;
RequestContext = requestContext;
RequestContextThrewOnReply = false;
SuccessfullySendReply = false;
RequestVersion = request.Version;
Reply = null;
ReplyTimeoutHelper = new TimeoutHelper();
SecurityContext = null;
InstanceContext = instanceContext;
SuccessfullyBoundInstance = false;
SuccessfullyIncrementedActivity = false;
SuccessfullyLockedInstance = false;
switchedThreads = !cleanThread;
//this.transaction = null;
InputParameters = null;
OutputParameters = null;
ReturnParameter = null;
isInstanceContextSingleton = InstanceContextProviderBase.IsProviderSingleton(Channel.DispatchRuntime.InstanceContextProvider);
invokeContinueGate = null;
if (!operation.IsOneWay && !operation.Parent.ManualAddressing)
{
RequestID = request.Headers.MessageId;
ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo(request);
}
else
{
RequestID = null;
ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo();
}
//if (DiagnosticUtility.ShouldUseActivity)
//{
// this.Activity = TraceUtility.ExtractActivity(this.Request);
//}
//if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
//{
// this.ResponseActivityId = ActivityIdHeader.ExtractActivityId(this.Request);
//}
//else
//{
ResponseActivityId = Guid.Empty;
//}
//if (this.EventTraceActivity == null && FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
//{
// if (this.Request != null)
// {
// this.EventTraceActivity = EventTraceActivityHelper.TryExtractActivity(this.Request, true);
// }
//}
}
private async Task <ErrorHandlerFaultInfo> ProvideFaultAndReplyFailureAsync(RequestContext request, RequestInfo requestInfo, Exception exception, ErrorHandlerFaultInfo faultInfo)
{
bool requestMessageIsFault = false;
try
{
requestMessageIsFault = request.RequestMessage.IsFault;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
// swallow it
}
bool enableFaults = false;
if (_serviceDispatcher != null)
{
enableFaults = _serviceDispatcher.ChannelDispatcher.EnableFaults;
}
// No client yet.
//else if (this._channel != null && this._channel.IsClient)
//{
// enableFaults = this._channel.ClientRuntime.EnableFaults;
//}
if ((!requestMessageIsFault) && enableFaults)
{
ProvideFault(exception, requestInfo, ref faultInfo);
if (faultInfo.Fault != null)
{
Message reply = faultInfo.Fault;
try
{
try
{
if (PrepareReply(request, reply))
{
await request.ReplyAsync(reply);
}
}
finally
{
reply.Close();
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
HandleError(e);
}
}
}
return(faultInfo);
}
private Task HandleErrorAsync(Exception e, RequestContext request, RequestInfo requestInfo, ServiceChannel channel)
{
var faultInfo = new ErrorHandlerFaultInfo(_messageVersion.Addressing.DefaultFaultAction);
return(ProvideFaultAndReplyFailureAsync(request, requestInfo, e, faultInfo));
}
internal bool HandleError(Exception error, ref ErrorHandlerFaultInfo faultInfo)
{
return(HandleErrorCommon(error, ref faultInfo));
}
internal bool HandleError(Exception error)
{
ErrorHandlerFaultInfo faultInfo = new ErrorHandlerFaultInfo(messageVersion.Addressing.DefaultFaultAction);
return(HandleError(error, ref faultInfo));
}
private void ProvideWellKnownFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo)
{
if (faultConverter != null && faultConverter.TryCreateFaultMessage(e, out Message faultMessage))
{
faultInfo.Fault = faultMessage;
return;
}
else if (e is NetDispatcherFaultException)
{
NetDispatcherFaultException ndfe = e as NetDispatcherFaultException;
if (_debug)
{
ExceptionDetail detail = new ExceptionDetail(ndfe);
faultInfo.Fault = Message.CreateMessage(_messageVersion, MessageFault.CreateFault(ndfe.Code, ndfe.Reason, detail), ndfe.Action);
}
else
{
faultInfo.Fault = Message.CreateMessage(_messageVersion, ndfe.CreateMessageFault(), ndfe.Action);
}
}
}
