public Fault(string action, FaultCode code, string reasonText)
 {
     this.action = action;
     this.code = code;
     this.reasonText = reasonText;
     this.reason = new FaultReason(reasonText, CultureInfo.CurrentCulture);
 }

		private FaultException HandleClientFaultException(Exception exception, Guid errorId)
		{
			string clientMessage = "The operation could not be performed. Reason: internal server error.";
			FaultCode code = new FaultCode(exception.GetType().Name);
			string errorMessage = String.Format("{0} Error Id: [{1}].{2}{3}", clientMessage, errorId, Environment.NewLine, Logger.ErrorLogEntityToString(Logger.GetExceptionLogEntity(exception)));
			return new FaultException(new FaultReason(errorMessage), FaultCode.CreateReceiverFaultCode(code));
		}

 void ProvideFaultOfLastResort(Exception error, ref ErrorHandlerFaultInfo faultInfo)
 {
     if (faultInfo.Fault == null)
     {
         FaultCode code = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch);
         code = FaultCode.CreateReceiverFaultCode(code);
         string action = FaultCodeConstants.Actions.NetDispatcher;
         MessageFault fault;
         if (this.debug)
         {
             faultInfo.DefaultFaultAction = action;
             fault = MessageFault.CreateFault(code, new FaultReason(error.Message), new ExceptionDetail(error));
         }
         else
         {
             string reason = this.isOnServer ? SR.GetString(SR.SFxInternalServerError) : SR.GetString(SR.SFxInternalCallbackError);
             fault = MessageFault.CreateFault(code, new FaultReason(reason));
         }
         faultInfo.IsConsideredUnhandled = true;
         faultInfo.Fault = Message.CreateMessage(this.messageVersion, fault, action);
     }
     //if this is an InternalServiceFault coming from another service dispatcher we should treat it as unhandled so that the channels are cleaned up
     else if (error != null)
     {
         FaultException e = error as FaultException;
         if (e != null && e.Fault != null && e.Fault.Code != null && e.Fault.Code.SubCode != null &&
             string.Compare(e.Fault.Code.SubCode.Namespace, FaultCodeConstants.Namespaces.NetDispatch, StringComparison.Ordinal) == 0 &&
             string.Compare(e.Fault.Code.SubCode.Name, FaultCodeConstants.Codes.InternalServiceFault, StringComparison.Ordinal) == 0)
         {
             faultInfo.IsConsideredUnhandled = true;
         }
     }
 }

 public FaultCode(string name, string ns, FaultCode subCode)
 {
     if (name == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("name"));
     }
     if (name.Length == 0)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("name"));
     }
     if (!string.IsNullOrEmpty(ns))
     {
         NamingHelper.CheckUriParameter(ns, "ns");
     }
     this.name = name;
     this.ns = ns;
     this.subCode = subCode;
     if (ns == "http://www.w3.org/2003/05/soap-envelope")
     {
         this.version = EnvelopeVersion.Soap12;
     }
     else if (ns == "http://schemas.xmlsoap.org/soap/envelope/")
     {
         this.version = EnvelopeVersion.Soap11;
     }
     else if (ns == "http://schemas.microsoft.com/ws/2005/05/envelope/none")
     {
         this.version = EnvelopeVersion.None;
     }
     else
     {
         this.version = null;
     }
 }

 private static WsrmHeaderFault CreateWsrmHeaderFault(ReliableMessagingVersion reliableMessagingVersion, FaultCode code, string subcode, FaultReason reason, XmlDictionaryReader detailReader)
 {
     if (code.IsSenderFault)
     {
         if (subcode == "InvalidAcknowledgement")
         {
             return new InvalidAcknowledgementFault(code, reason, detailReader, reliableMessagingVersion);
         }
         if (subcode == "MessageNumberRollover")
         {
             return new MessageNumberRolloverFault(code, reason, detailReader, reliableMessagingVersion);
         }
         if (subcode == "UnknownSequence")
         {
             return new UnknownSequenceFault(code, reason, detailReader, reliableMessagingVersion);
         }
         if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
         {
             if (subcode == "LastMessageNumberExceeded")
             {
                 return new LastMessageNumberExceededFault(code, reason, detailReader, reliableMessagingVersion);
             }
         }
         else if ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) && (subcode == "SequenceClosed"))
         {
             return new SequenceClosedFault(code, reason, detailReader, reliableMessagingVersion);
         }
     }
     if (!code.IsSenderFault && !code.IsReceiverFault)
     {
         return null;
     }
     return new SequenceTerminatedFault(code, reason, detailReader, reliableMessagingVersion);
 }

 public virtual bool Check(FaultCode code)
 {
    return code.IsReceiverFault &&
           code.SubCode != null &&
           CheckCodeName(code) &&
           CheckCodeNamespace(code);
 }

 protected FaultException(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     this.code = this.ReconstructFaultCode(info, "code");
     this.reason = this.ReconstructFaultReason(info, "reason");
     this.fault = (MessageFault) info.GetValue("messageFault", typeof(MessageFault));
     this.action = info.GetString("action");
 }

		public void TestDefaults ()
		{
			code = new FaultCode ("foo");
			Assert.AreEqual ("foo", code.Name);
			Assert.AreEqual (String.Empty, code.Namespace);
			Assert.AreEqual (null, code.SubCode);			
		}

 internal FaultException(string reason, FaultCode code, string action, Exception innerException)
     : base(reason, innerException)
 {
     this.code = FaultException.EnsureCode(code);
     this.reason = FaultException.CreateReason(reason);
     this.action = action;
 }

 // remote
 protected WsrmFault(FaultCode code, string subcode, FaultReason reason)
 {
     this.code = code;
     this.subcode = subcode;
     this.reason = reason;
     this.isRemote = true;
 }

 public Message CreateMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion)
 {
     this.SetReliableMessagingVersion(reliableMessagingVersion);
     string faultActionString = WsrmIndex.GetFaultActionString(messageVersion.Addressing, reliableMessagingVersion);
     if (messageVersion.Envelope == EnvelopeVersion.Soap11)
     {
         this.code = this.Get11Code(this.code, this.subcode);
     }
     else
     {
         if (messageVersion.Envelope != EnvelopeVersion.Soap12)
         {
             throw Fx.AssertAndThrow("Unsupported MessageVersion.");
         }
         if (this.code.SubCode == null)
         {
             FaultCode subCode = new FaultCode(this.subcode, WsrmIndex.GetNamespaceString(reliableMessagingVersion));
             this.code = new FaultCode(this.code.Name, this.code.Namespace, subCode);
         }
         this.hasDetail = this.Get12HasDetail();
     }
     Message message = Message.CreateMessage(messageVersion, this, faultActionString);
     this.OnFaultMessageCreated(messageVersion, message);
     return message;
 }

 internal FaultException(FaultReason reason, FaultCode code, string action, Exception innerException)
     : base(FaultException.GetSafeReasonText(reason), innerException)
 {
     _code = FaultException.EnsureCode(code);
     _reason = FaultException.EnsureReason(reason);
     _action = action;
 }

 public static OperationExecutionFault CreateInstanceNotFoundFault(string description)
 {
     if (instanceNotFoundCode == null)
     {
         instanceNotFoundCode = new FaultCode(XD2.WorkflowControlServiceFaults.InstanceNotFound, XD2.WorkflowServices.Namespace);
     }
     return new OperationExecutionFault(description, instanceNotFoundCode);
 }

 protected MakeConnectionMessageFault(Message message, FaultCode code, string subcode, FaultReason reason)
 {
     this.code = code;
     this.subcode = subcode;
     this.reason = reason;
     this.isRemote = true;
     this.originalMessageId = message.Headers.MessageId;
 }

 public static OperationExecutionFault CreateSuspendedFault(Guid instanceId, string operationName)
 {
     if (instanceSuspendedFaultCode == null)
     {
         instanceSuspendedFaultCode = new FaultCode("InstanceSuspended", "http://schemas.datacontract.org/2008/10/WorkflowServices");
     }
     return new OperationExecutionFault(System.ServiceModel.Activities.SR.InstanceSuspended(operationName, instanceId), instanceSuspendedFaultCode);
 }

 public static OperationExecutionFault CreateOperationNotAvailableFault(Guid instanceId, string operationName)
 {
     if (operationNotAvailableFaultCode == null)
     {
         operationNotAvailableFaultCode = new FaultCode("OperationNotAvailable", "http://schemas.datacontract.org/2008/10/WorkflowServices");
     }
     return new OperationExecutionFault(System.ServiceModel.Activities.SR.OperationNotAvailable(operationName, instanceId), operationNotAvailableFaultCode);
 }

 public static OperationExecutionFault CreateInstanceUnloadedFault(string description)
 {
     if (instanceUnloadedFaultCode == null)
     {
         instanceUnloadedFaultCode = new FaultCode("InstanceUnloaded", "http://schemas.datacontract.org/2008/10/WorkflowServices");
     }
     return new OperationExecutionFault(description, instanceUnloadedFaultCode);
 }

 public WSAddressing10ProblemHeaderQNameFault(ActionMismatchAddressingException e)
 {
     this.invalidHeaderName = "Action";
     this.code = FaultCode.CreateSenderFaultCode(new FaultCode("ActionMismatch", AddressingVersion.WSAddressing10.Namespace));
     this.reason = new FaultReason(e.Message, CultureInfo.CurrentCulture);
     this.actor = "";
     this.node = "";
 }

 public static OperationExecutionFault CreateTransactedLockException(Guid instanceId, string operationName)
 {
     if (instanceLockedFaultCode == null)
     {
         instanceLockedFaultCode = new FaultCode(XD2.WorkflowControlServiceFaults.InstanceLockedUnderTransaction, XD2.WorkflowServices.Namespace);
     }
     return new OperationExecutionFault(SR2.InstanceLockedUnderTransaction(operationName, instanceId), instanceLockedFaultCode);
 }

 public static FaultCode CreateReceiverFaultCode(FaultCode subCode)
 {
     if (subCode == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("subCode"));
     }
     return new FaultCode("Receiver", subCode);
 }