Task ReplyAddressFilterDidNotMatchAsync(RequestContext request, RequestInfo requestInfo)
{
FaultCode code = FaultCode.CreateSenderFaultCode(AddressingStrings.DestinationUnreachable,
_messageVersion.Addressing.Namespace);
string reason = SR.Format(SR.SFxNoEndpointMatchingAddress, request.RequestMessage.Headers.To);
return(ReplyFailureAsync(request, requestInfo, code, reason));
}
private void ReplyAddressFilterDidNotMatch(RequestContext request)
{
FaultCode code = FaultCode.CreateSenderFaultCode(AddressingStrings.DestinationUnreachable,
_messageVersion.Addressing.Namespace);
string reason = SR.Format(SR.SFxNoEndpointMatchingAddress, request.RequestMessage.Headers.To);
ReplyFailure(request, code, reason);
}
internal static FaultException CreateAccessDeniedFaultException()
{
SecurityVersion wss = SecurityVersion.WSSecurity11;
FaultCode faultCode = FaultCode.CreateSenderFaultCode("FailedAuthentication", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
FaultReason faultReason = new FaultReason(new FaultReasonText("Access is denied", CultureInfo.CurrentCulture));
return(new FaultException(faultReason, faultCode));
}
internal static Exception CreateAccessDeniedFaultException()
{
SecurityVersion wss = SecurityVersion.Default;
FaultCode faultCode = FaultCode.CreateSenderFaultCode(wss.FailedAuthenticationFaultCode.Value, wss.HeaderNamespace.Value);
FaultReason faultReason = new FaultReason(SR.AccessDenied, CultureInfo.CurrentCulture);
return(new FaultException(faultReason, faultCode));
}
internal static Exception CreateFailedAuthenticationFaultException()
{
SecurityVersion wss = SecurityVersion.Default;
FaultCode faultCode = FaultCode.CreateSenderFaultCode(wss.InvalidSecurityFaultCode.Value, wss.HeaderNamespace.Value);
FaultReason faultReason = new FaultReason(SR.AuthenticationOfClientFailed);
return(new FaultException(faultReason, faultCode));
}
internal static NetDispatcherFaultException CreateDeserializationFailedFault(string reason, Exception innerException)
{
reason = SR.Format(SR.SFxDeserializationFailed1, reason);
FaultCode code = new FaultCode(FaultCodeConstants.Codes.DeserializationFailed, FaultCodeConstants.Namespaces.NetDispatch);
code = FaultCode.CreateSenderFaultCode(code);
return(new NetDispatcherFaultException(reason, code, innerException));
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
fault = Message.CreateMessage(version,
FaultCode.CreateSenderFaultCode("BadEvalSubmission", "http://learningwcf.com/evals"),
"Bad Eval Submitted (IErrorHandler)",
new BadEvalSubmission(),
"http://learningwcf.com/IEvalService/SubmitEvalBadEvalSubmissionFault");
}
/// <summary>
/// Builds a fault message for to return to the caller
/// </summary>
/// <remarks>
/// Builds an undeclared SOAP fault (using FaultException, rather than generic FaultException),
/// for interop with non-WCF clients which won't recognise declared SOAP faults
/// </remarks>
/// <param name="error">Unhandled exception</param>
/// <param name="version">Message version</param>
/// <param name="fault">Fault message</param>
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
//build undeclared SOAP fault:
FaultException ex = new FaultException(error.Message, FaultCode.CreateSenderFaultCode(SoapException.ServerFaultCode.Name, SoapException.ServerFaultCode.Namespace));
MessageFault messageFault = ex.CreateMessageFault();
fault = Message.CreateMessage(version, messageFault, this.ServiceName);
}
public void ProvideFault(Exception error, MessageVersion version,
ref Message fault)
{
FaultCode faultCode =
FaultCode.CreateSenderFaultCode(error.GetType().Name,
ServiceConstants.Error);
fault = Message.CreateMessage(version, faultCode, error.Message, null);
}
internal static Exception CreateFailedAuthenticationFaultException()
{
// always use default version?
SecurityVersion wss = SecurityVersion.Default;
FaultCode faultCode = FaultCode.CreateSenderFaultCode(wss.InvalidSecurityFaultCode.Value, wss.HeaderNamespace.Value);
FaultReason faultReason = new FaultReason(SR.GetString(SR.AuthenticationOfClientFailed), CultureInfo.CurrentCulture);
return(new FaultException(faultReason, faultCode));
}
public Task <object> InvokeAsync(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;
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
{
serviceChannel.Close(ChannelHandler.CloseAfterFaultTimeout);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
channelDispatcher.HandleError(ex);
}
}
};
if (_dispatchRuntime._shared.EnableFaults)
{
MessageFault fault = MessageFault.CreateFault(code, reason, action);
return(Task.FromResult((object)Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction)));
}
else
{
OperationContext.Current.RequestContext.Close();
OperationContext.Current.RequestContext = null;
return(Task.FromResult((object)null));
}
}
private static MessageFault GetSecureConversationCloseNotSupportedFault()
{
if (s_secureConversationCloseNotSupportedFault == null)
{
FaultCode faultCode = FaultCode.CreateSenderFaultCode(DotNetSecurityStrings.SecureConversationCancelNotAllowedFault, DotNetSecurityStrings.Namespace);
FaultReason faultReason = new FaultReason(SR.Format(SR.SecureConversationCancelNotAllowedFaultReason), System.Globalization.CultureInfo.InvariantCulture);
s_secureConversationCloseNotSupportedFault = MessageFault.CreateFault(faultCode, faultReason);
}
return(s_secureConversationCloseNotSupportedFault);
}
private Task ReplyChannelTerminatedAsync(RequestContext request, RequestInfo requestInfo)
{
FaultCode code = FaultCode.CreateSenderFaultCode(FaultCodeConstants.Codes.SessionTerminated,
FaultCodeConstants.Namespaces.NetDispatch);
string reason = SR.SFxChannelTerminated0;
string action = FaultCodeConstants.Actions.NetDispatcher;
Message fault = Message.CreateMessage(_messageVersion, code, reason, action);
return(ReplyFailureAsync(request, requestInfo, fault, action, reason, code));
}
private void ReplyChannelTerminated(RequestContext request)
{
FaultCode code = FaultCode.CreateSenderFaultCode(FaultCodeConstants.Codes.SessionTerminated,
FaultCodeConstants.Namespaces.NetDispatch);
string reason = SR.Format(SR.SFxChannelTerminated0);
string action = FaultCodeConstants.Actions.NetDispatcher;
Message fault = Message.CreateMessage(_messageVersion, code, reason, action);
ReplyFailure(request, fault, action, reason, code);
}
internal static FaultCode GetFaultCode(HttpStatusCode statusCode)
{
if ((int)statusCode >= (int)HttpStatusCode.InternalServerError)
{
return(FaultCode.CreateReceiverFaultCode(statusCode.ToString(), WebFaultCodeNamespace));
}
else
{
return(FaultCode.CreateSenderFaultCode(statusCode.ToString(), WebFaultCodeNamespace));
}
}
/// <summary>
/// Called when request executed.
/// </summary>
/// <param name="onAction">The on request action.</param>
/// <exception cref="FaultException"></exception>
/// <exception cref="FaultReason"></exception>
private void OnAction(Action onAction)
{
try
{
onAction();
}
catch (Exception e)
{
throw new FaultException(new FaultReason(e.Message), FaultCode.CreateSenderFaultCode("err", "test"));
}
}
public static Message CreateFaultMessage(UniqueId messageID, MessageVersion messageVersion, Fault fault)
{
MessageFault fault2 = MessageFault.CreateFault(FaultCode.CreateSenderFaultCode(fault.Code), fault.Reason);
Message message = Message.CreateMessage(messageVersion, fault2, messageVersion.Addressing.FaultAction);
message.Headers.Action = fault.Action;
if (messageID != null)
{
message.Headers.RelatesTo = messageID;
}
return(message);
}
public WorkflowOperationFault(MessageQueueErrorCode errorCode)
{
if (errorCode == MessageQueueErrorCode.QueueNotAvailable)
{
faultCode = FaultCode.CreateSenderFaultCode(operationNotAvailable, ContextMessageHeader.ContextHeaderNamespace);
faultReason = new FaultReason(new FaultReasonText(SR2.GetString(SR2.OperationNotAvailable), CultureInfo.CurrentCulture));
}
else
{
faultCode = FaultCode.CreateSenderFaultCode(operationNotImplemented, ContextMessageHeader.ContextHeaderNamespace);
faultReason = new FaultReason(new FaultReasonText(SR2.GetString(SR2.OperationNotImplemented), CultureInfo.CurrentCulture));
}
}
static void Main(string[] args)
{
FaultCode code = FaultCode.CreateSenderFaultCode("calcuError", "http://www.artech.com");
FaultReasonText reasonText1 = new FaultReasonText("Divided by zero!", "en-US");
FaultReasonText reasonText2 = new FaultReasonText("试图除以零!", "zh-CN");
FaultReason reason = new FaultReason(new FaultReasonText[] { reasonText1, reasonText2 });
MessageFault fault = MessageFault.CreateFault(code, reason);
string action = "http://www.artech.com/divideFault";
using (Message message = Message.CreateMessage(MessageVersion.Default, fault, action))
{
WriteMessage(message, "message.xml");
}
}
public virtual IEnumerable <string> Find(string costCenterCriteria)
{
if (costCenterCriteria == "WebFaultException")
{
throw new WebFaultException <string>("Custom exception", HttpStatusCode.GatewayTimeout);
}
if (costCenterCriteria == "FaultException")
{
throw new FaultException("Default exception", FaultCode.CreateSenderFaultCode("hej", "hej"));
}
return(this._test.GetList(costCenterCriteria));
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
FaultException exception;
ServiceChannel serviceChannel;
outputs = EmptyArray <object> .Allocate(0);
Message message = inputs[0] as Message;
if (message != null)
{
string action = message.Headers.Action;
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, 0x80037, System.ServiceModel.SR.GetString("TraceCodeUnhandledAction"), new StringTraceRecord("Action", action), this, null, message);
}
FaultCode code = FaultCode.CreateSenderFaultCode("ActionNotSupported", message.Version.Addressing.Namespace);
FaultReason reason = new FaultReason(System.ServiceModel.SR.GetString("SFxNoEndpointMatchingContract", new object[] { action }));
exception = new FaultException(reason, code);
System.ServiceModel.Dispatcher.ErrorBehavior.ThrowAndCatch(exception);
serviceChannel = OperationContext.Current.InternalServiceChannel;
OperationContext.Current.OperationCompleted += delegate(object sender, EventArgs e) {
ChannelDispatcher channelDispatcher = this.dispatchRuntime.ChannelDispatcher;
if (!channelDispatcher.HandleError(exception) && serviceChannel.HasSession)
{
try
{
serviceChannel.Close(ChannelHandler.CloseAfterFaultTimeout);
}
catch (Exception exception1)
{
if (Fx.IsFatal(exception1))
{
throw;
}
channelDispatcher.HandleError(exception1);
}
}
};
if (this.dispatchRuntime.shared.EnableFaults)
{
MessageFault fault = MessageFault.CreateFault(code, reason, action);
return(Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction));
}
OperationContext.Current.RequestContext.Close();
OperationContext.Current.RequestContext = null;
}
return(null);
}
/// <summary>
/// Build the unshielded MessageFault.
/// </summary>
/// <param name="faultContractWrapper"></param>
/// <returns></returns>
private MessageFault BuildMessageFault(FaultContractWrapperException faultContractWrapper)
{
Type faultExceptionType = typeof(FaultException <>);
Type constructedFaultExceptionType = faultExceptionType.MakeGenericType(faultContractWrapper.FaultContract.GetType());
//Encapsulate the FaultContract in the FaultException
FaultException faultException =
(FaultException)Activator.CreateInstance(
constructedFaultExceptionType,
faultContractWrapper.FaultContract,
new FaultReason(new FaultReasonText(faultContractWrapper.Message, CultureInfo.CurrentCulture)),
FaultCode.CreateSenderFaultCode(SoapException.ClientFaultCode.Name, SoapException.ClientFaultCode.Namespace));
return(faultException.CreateMessageFault());
}
public void TestSenderFaultCode()
{
code = FaultCode.CreateSenderFaultCode("foo", "bar");
Assert.IsTrue(code.IsSenderFault);
Assert.AreEqual("Sender", code.Name);
Assert.AreEqual(String.Empty, code.Namespace);
Assert.AreEqual("foo", code.SubCode.Name);
Assert.AreEqual("bar", code.SubCode.Namespace);
code = new FaultCode("Sender");
Assert.IsTrue(code.IsSenderFault);
code = new FaultCode("something else");
Assert.IsFalse(code.IsReceiverFault);
}
private FaultCode CreateFaultCode(OiosiFaultCode faultCode, OiosiInnerFaultCode innerFaultCode)
{
switch (faultCode)
{
case OiosiFaultCode.Sender:
FaultCode senderInnerFaultCode = CreateSenderFaultCode(innerFaultCode);
return(FaultCode.CreateSenderFaultCode(senderInnerFaultCode));
case OiosiFaultCode.Receiver:
FaultCode recieverInnerFaultCode = CreateRecieverFaultCode(innerFaultCode);
return(FaultCode.CreateReceiverFaultCode(recieverInnerFaultCode));
default:
throw new OiosiMessageFaultUnexpectedFaultCode(faultCode);
}
}
public void BeforeSendReply(ref Message reply, object correlationState)
{
try
{
reply.ToString();
}
catch (Exception e)
{
var faultCode = FaultCode.CreateSenderFaultCode(null);
var faultReason = new FaultReason(e.GetBaseException().Message);
reply = Message.CreateMessage(
reply.Version,
MessageFault.CreateFault(faultCode, faultReason),
null);
}
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
try
{
FaultReason faultReason = new FaultReason(error.Message);
ExceptionDetail exceptionDetail = new ExceptionDetail(error);
FaultCode faultCode = FaultCode.CreateSenderFaultCode(new FaultCode("0"));
FaultException <ExceptionDetail> faultException = new FaultException <ExceptionDetail>(exceptionDetail, faultReason, faultCode);
MessageFault messageFault = faultException.CreateMessageFault();
fault = Message.CreateMessage(version, messageFault, faultException.Action);
}
catch
{
// Todo log error
}
}
private FaultException ConstructSoapFaultException(Exception e)
{
var moviesException = e as MoviesBaseException;
string faultReason;
if (moviesException != null)
{
faultReason = moviesException.Reason + "\r\n" + e.Message;
}
else
{
faultReason = e.Message;
}
return(new FaultException(faultReason, FaultCode.CreateSenderFaultCode(e.GetType().Name, "http://www.matlus.com/gateway/Movies")));
}
public void AttemptSimplePasswordReset(object sender, XmlDocumentValidationEventArgs e)
{
if (e.XmlDocument is SimplePWResetDocument)
{
this.xmlInteractiveActivity1.ReferenceProperties = new ReferencePropertiesType(new Microsoft.ResourceManagement.WebServices.UniqueIdentifier("SimplePWResetDocument"));
this.xmlInteractiveActivity1.ResourceAddress = new Uri("http://NotUsableAddress/");
}
else
{
this.xmlInteractiveActivity1.CreateFaultMessage = new FaultException(
MessageFault.CreateFault(
FaultCode.CreateSenderFaultCode("DataRequiredFault", "http://schemas.xmlsoap.org/ws/2004/09/transfer/fault"),
new FaultReason(new FaultReasonText("DataRequiredFaultReason")),
new DataRequiredFault(SimplePasswordReset.ObjectTypeRequested, "Your password was not long enough"),
new ClientSerializer(typeof(DataRequiredFault))));
}
}
public void SubmitEvals(Eval eval)
{
if (eval.Submitter.Equals("throw1"))
{
throw new Exception("Something Bad Happened");
}
else if (eval.Submitter.Equals("throw2"))
{
throw new FaultException("Something Bad Happened",
FaultCode.CreateSenderFaultCode("Bad Submitter Name", "http://learningwcf.com/faultexception"));
}
else if (eval.Submitter.Equals("throw3"))
{
throw new FaultException <BadEvalSubmission>(new BadEvalSubmission());
}
evalList.Add(eval);
Console.WriteLine($" Service received from : {eval.Submitter} at {eval.Timespent}");
}
internal static Exception CreateFault(string reasonText, string codeString, bool isNetDispatcherFault)
{
string str;
string str2;
if (isNetDispatcherFault)
{
str = "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher";
str2 = "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher/fault";
}
else
{
str = "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/transactions";
str2 = "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/transactions/fault";
}
FaultReason reason = new FaultReason(reasonText, CultureInfo.CurrentCulture);
return(new FaultException(reason, FaultCode.CreateSenderFaultCode(codeString, str), str2));
}