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

 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;
 }

 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");
 }

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

 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);
 }

 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 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 void Simple ()
		{
			FaultReason r = new FaultReason ("testing");
			FaultReasonText t = r.GetMatchingTranslation ();
			Assert.IsNotNull (t);
			Assert.AreEqual ("testing", t.Text, "#1");
			Assert.AreEqual (CultureInfo.CurrentCulture.Name,
				t.XmlLang, "#2");
		}

 public XmlObjectSerializerFault(FaultCode code, FaultReason reason, object detail, XmlObjectSerializer serializer, string actor, string node)
 {
     this.code = code;
     this.reason = reason;
     this.detail = detail;
     this.serializer = serializer;
     this.actor = actor;
     this.node = node;
 }

 public WSAddressing10ProblemHeaderQNameFault(ActionMismatchAddressingException e)
 {
     _invalidHeaderName = AddressingStrings.Action;
     _code = FaultCode.CreateSenderFaultCode(
         new FaultCode(Addressing10Strings.ActionMismatch, AddressingVersion.WSAddressing10.Namespace));
     _reason = new FaultReason(e.Message, CultureInfo.CurrentCulture);
     _actor = "";
     _node = "";
 }

 public InvalidAcknowledgementFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader, ReliableMessagingVersion reliableMessagingVersion) : base(code, "InvalidAcknowledgement", reason, true, false)
 {
     UniqueId id;
     bool flag;
     WsrmAcknowledgmentInfo.ReadAck(reliableMessagingVersion, detailReader, out id, out this.ranges, out flag);
     base.SequenceID = id;
     while (detailReader.IsStartElement())
     {
         detailReader.Skip();
     }
     detailReader.ReadEndElement();
 }

 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 void ThrowGenericFaultException()
        {
            var details = new ErrorDetails
            {
                Code = 666,
                Name = "Devil",
                Description = "This is the end!"
            };

            var reason = new FaultReason("This is the FulaReason");
            var code = FaultCode.CreateReceiverFaultCode("ThrowGenericFaultException", "Server.Service");

            throw new FaultException<ErrorDetails>(details, reason, code);
        }

 internal Message ProvideFault(MessageVersion messageVersion)
 {
     string name = _notUnderstoodHeaders[0].Name;
     string ns = _notUnderstoodHeaders[0].Namespace;
     FaultCode code = new FaultCode(MessageStrings.MustUnderstandFault, _envelopeVersion.Namespace);
     FaultReason reason = new FaultReason(SR.Format(SR.SFxHeaderNotUnderstood, name, ns), CultureInfo.CurrentCulture);
     MessageFault fault = MessageFault.CreateFault(code, reason);
     string faultAction = messageVersion.Addressing.DefaultFaultAction;
     Message message = System.ServiceModel.Channels.Message.CreateMessage(messageVersion, fault, faultAction);
     if (_envelopeVersion == EnvelopeVersion.Soap12)
     {
         this.AddNotUnderstoodHeaders(message.Headers);
     }
     return message;
 }

        /// <summary>
        /// Creates a new FaultException with our fault details based on an existing exception.
        /// </summary>
        /// <param name="exception">The exception to wrap.</param>
        /// <returns></returns>
        public static FaultException<AlarmWorkflowFaultDetails> CreateFault(Exception exception)
        {
            Assertions.AssertNotNull(exception, "exception");

            if (exception is FaultException<AlarmWorkflowFaultDetails>)
            {
                return (FaultException<AlarmWorkflowFaultDetails>)exception;
            }

            FaultReason reason = new FaultReason(exception.Message);
            FaultCode code = new FaultCode("(No code)");
            AlarmWorkflowFaultDetails detail = new AlarmWorkflowFaultDetails(exception);

            return new FaultException<AlarmWorkflowFaultDetails>(detail, reason, code);
        }

 internal Message ProvideFault(MessageVersion messageVersion)
 {
     string name = this.notUnderstoodHeaders[0].Name;
     string str2 = this.notUnderstoodHeaders[0].Namespace;
     FaultCode code = new FaultCode("MustUnderstand", this.envelopeVersion.Namespace);
     FaultReason reason = new FaultReason(System.ServiceModel.SR.GetString("SFxHeaderNotUnderstood", new object[] { name, str2 }), CultureInfo.CurrentCulture);
     MessageFault fault = MessageFault.CreateFault(code, reason);
     string defaultFaultAction = messageVersion.Addressing.DefaultFaultAction;
     Message message = Message.CreateMessage(messageVersion, fault, defaultFaultAction);
     if (this.envelopeVersion == System.ServiceModel.EnvelopeVersion.Soap12)
     {
         this.AddNotUnderstoodHeaders(message.Headers);
     }
     return message;
 }

 protected WsrmFault(bool isSenderFault, string subcode, string faultReason, string exceptionMessage)
 {
     if (isSenderFault)
     {
         this.code = new FaultCode("Sender", "");
     }
     else
     {
         this.code = new FaultCode("Receiver", "");
     }
     this.subcode = subcode;
     this.reason = new FaultReason(faultReason, CultureInfo.CurrentCulture);
     this.exceptionMessage = exceptionMessage;
     this.isRemote = false;
 }

        public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
        {
            if (error is FaultException)
                return;
            ServiceOperationFault serviceOperationFault = new ServiceOperationFault();
            FaultReason fr = new FaultReason(error.ToString());
            FaultCode fc = new FaultCode("0001");
            // Creates the exception we want to send back to the client
            var exception = new FaultException<ServiceOperationFault>(serviceOperationFault, fr);

            // Creates a message fault
            var messageFault = exception.CreateMessageFault();

            // Creates the new message based on the message fault
            fault = Message.CreateMessage(version, messageFault, exception.Action);
        }

 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);
 }

        void IErrorHandler.ProvideFault(Exception error, MessageVersion version, ref Message fault)
        {
            try
            {
                // Add code here to build faultreason for client based on exception
                FaultReason faultReason = new FaultReason(error.Message);
                ExceptionDetail exceptionDetail = new ExceptionDetail(error);

                // For security reasons you can also decide to not give the ExceptionDetail back to the client or change the message, etc
                FaultException<ExceptionDetail> faultException = new FaultException<ExceptionDetail>(exceptionDetail, faultReason, FaultCode.CreateSenderFaultCode(new FaultCode("0")));

                MessageFault messageFault = faultException.CreateMessageFault();
                fault = Message.CreateMessage(version, messageFault, faultException.Action);
            }
            catch
            {
                // Todo log error
            }
        }