//Can only be called inside a service
        public static void PromoteException(Exception error,MessageVersion version,ref Message fault)
        {
            StackFrame frame = new StackFrame(1);

             Type serviceType = frame.GetMethod().ReflectedType;
             PromoteException(serviceType,error,version,ref fault);
        }

 //- @ProvideFault -//
 public virtual void ProvideFault(Exception error, MessageVersion version, ref Message fault)
 {
     fault.Properties[HttpResponseMessageProperty.Name] = new HttpResponseMessageProperty
                                                          {
                                                              StatusCode = HttpStatusCode.OK
                                                          };
 }

 internal ErrorBehavior(ChannelDispatcher channelDispatcher)
 {
     this.handlers = EmptyArray<IErrorHandler>.ToArray(channelDispatcher.ErrorHandlers);
     this.debug = channelDispatcher.IncludeExceptionDetailInFaults;
     this.isOnServer = channelDispatcher.IsOnServer;
     this.messageVersion = channelDispatcher.MessageVersion;
 }

      /// <summary>
      ///    Enables the creation of a custom System.ServiceModel.FaultException{TDetail}
      ///    that is returned from an exception in the course of a service method.
      /// </summary>
      /// <param name="error">The System.Exception object thrown in the course of the service operation.</param>
      /// <param name="version">The SOAP version of the message.</param>
      /// <param name="fault">
      ///    The System.ServiceModel.Channels.Message object that is returned to the client, or service in
      ///    duplex case
      /// </param>
      public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
      {
         if (error is FaultException<ApplicationServiceError>)
         {
            var messageFault = ((FaultException<ApplicationServiceError>) error).CreateMessageFault();

            //propagate FaultException
            fault = Message.CreateMessage(
               version,
               messageFault,
               ((FaultException<ApplicationServiceError>) error).Action);
         }
         else
         {
            //create service error
            var defaultError = new ApplicationServiceError()
            {
               ErrorMessage = Messages.message_DefaultErrorMessage
            };

            //Create fault exception and message fault
            var defaultFaultException = new FaultException<ApplicationServiceError>(defaultError);
            var defaultMessageFault = defaultFaultException.CreateMessageFault();

            //propagate FaultException
            fault = Message.CreateMessage(version, defaultMessageFault, defaultFaultException.Action);
         }
      }

        public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
        {
            FaultException faultException;
            var logger = LogManager.GetCurrentClassLogger();

            if (error != null && error is ObjectValidationException)
            {
                faultException = new FaultException<ValidationFault>(new ValidationFault(((ObjectValidationException)error).ValidationErrors.Select(item =>
                    new ValidationError
                    {
                        ErrorMessage = item.ErrorMessage,
                        ObjectName = item.ObjectName,
                        PropertyName = item.PropertyName
                    })), new FaultReason("Validation error"));

                logger.Error(error, "Validation error in GlobalError filter");
            }
            else
            {
                faultException = new FaultException<InternalServiceFault>(new InternalServiceFault(error,
                string.Format("Exception caught at GlobalErrorHandler{0}Method: {1}{2}Message:{3}",
                             Environment.NewLine, error.TargetSite.Name, Environment.NewLine, error.Message)));

                logger.Error(error, "Generic internal error in GlobalError filter");
            }
            // Shield the unknown exception
            //FaultException faultException = new FaultException<SimpleErrorFault>(new SimpleErrorFault(), new FaultReason("Server error encountered. All details have been logged."));
            //new FaultException("Server error encountered. All details have been logged.");
            MessageFault messageFault = faultException.CreateMessageFault();

            fault = Message.CreateMessage(version, messageFault, faultException.Action);
        }

 internal Message ProvideFault(MessageVersion messageVersion)
 {
     WSAddressing10ProblemHeaderQNameFault fault = new WSAddressing10ProblemHeaderQNameFault(this);
     Message message = Message.CreateMessage(messageVersion, fault, messageVersion.Addressing.FaultAction);
     fault.AddHeaders(message.Headers);
     return message;
 }

        public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
        {
            WebOperationContext currentContext = WebOperationContext.Current;
            OutgoingWebResponseContext outgoingResponse = null;

            if (currentContext != null)
            {
                outgoingResponse = currentContext.OutgoingResponse;
            }
            
            WebMessageFormat format = this.defaultFormat;
            if (outgoingResponse != null)
            {
                WebMessageFormat? nullableFormat = outgoingResponse.Format;
                if (nullableFormat.HasValue)
                {
                    format = nullableFormat.Value;
                }
            }

            if (!this.formatters.ContainsKey(format))
            {
                string operationName = "<null>";

                if (OperationContext.Current != null)
                {
                    MessageProperties messageProperties = OperationContext.Current.IncomingMessageProperties;
                    if (messageProperties.ContainsKey(WebHttpDispatchOperationSelector.HttpOperationNamePropertyName))
                    {
                        operationName = messageProperties[WebHttpDispatchOperationSelector.HttpOperationNamePropertyName] as string;
                    }
                }
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.OperationDoesNotSupportFormat, operationName, format.ToString())));
            }

            if (outgoingResponse != null && string.IsNullOrEmpty(outgoingResponse.ContentType))
            {
                string automatedSelectionContentType = outgoingResponse.AutomatedFormatSelectionContentType;
                if (!string.IsNullOrEmpty(automatedSelectionContentType))
                {
                    // Don't set the content-type if it is default xml for backwards compatiabilty
                    if (!string.Equals(automatedSelectionContentType, defaultContentTypes[WebMessageFormat.Xml], StringComparison.OrdinalIgnoreCase))
                    {
                        outgoingResponse.ContentType = automatedSelectionContentType;
                    }
                }
                else
                {
                    // Don't set the content-type if it is default xml for backwards compatiabilty
                    if (format != WebMessageFormat.Xml)
                    {
                        outgoingResponse.ContentType = defaultContentTypes[format];
                    }
                }
            }

            Message message = this.formatters[format].SerializeReply(messageVersion, parameters, result);

            return message;
        }

		protected virtual void OnImportPolicy (XmlElement assertion,
			MessageVersion messageVersion,
			MetadataImporter exporter,
			PolicyConversionContext context)
		{
			throw new NotImplementedException ();
		}

 internal CustomTextMessageEncoderFactory(string mediaType, string charSet, MessageVersion version)
 {
     _version = version;
     _mediaType = mediaType;
     _charSet = charSet;
     _encoder = new CustomTextMessageEncoder(this);
 }

 public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
 {
     JObject json = new JObject();
     json[JsonRpcConstants.ErrorKey] = null;
     json[JsonRpcConstants.ResultKey] = JToken.FromObject(result);
     return JsonRpcHelpers.SerializeMessage(json, null);
 }

        public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
        {
            Contract.Requires<NullReferenceException>(error != null);

            FaultCode code = FaultCode.CreateSenderFaultCode(error.GetType().Name, FaultNs);
            fault = Message.CreateMessage(version, code, error.Message, null);

        if (this.Context != null)
        {
            var se = error as ServiceException;
            if (se != null)
            {
                Context.OutgoingResponse.StatusCode = ((ServiceException)error).StatusCode;
            }

            var sb = new StringBuilder();

            for (int i = 0; i < error.Message.Length; i++)
            {
                var ch = (char)('\x00ff' & error.Message[i]);
                if (((ch <= '\x001f') && (ch != '\t')) || (ch == '\x007f'))
                {
                    // Specified value has invalid Control characters.
                    // See HttpListenerResponse.StatusDescription implementation.
                }
                else
                {
                    sb.Append(ch);
                }
            }

            Context.OutgoingResponse.StatusDescription = sb.ToString();
            Context.OutgoingResponse.SuppressEntityBody = false;
            }
        }

        /// <summary>
        /// Serializes a reply message from a specified message version, array of parameters, and a return value.
        /// </summary>
        /// <param name="messageVersion">The SOAP message version.</param>
        /// <param name="parameters">The out parameters.</param>
        /// <param name="result">The return value.</param>
        /// <returns>he serialized reply message.</returns>
        Message IDispatchMessageFormatter.SerializeReply(
            MessageVersion messageVersion,
            object[] parameters,
            object result)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            if (messageVersion != MessageVersion.None)
            {
                throw new NotSupportedException(
                    string.Format(
                        CultureInfo.CurrentCulture,
                        SR.HttpMessageFormatterMessageVersion,
                        this.GetType()));
            }

            HttpResponseMessage response = this.GetDefaultResponse();
            if (response == null)
            {
                 throw new InvalidOperationException(
                    string.Format(
                        CultureInfo.CurrentCulture,
                        SR.HttpMessageFormatterNullResponse,
                        this.GetType()));
            }

            this.SerializeReply(parameters, result, response);

            return response.ToMessage();
        }

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

 public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes)
 {
     this.streamed = true;
     this.buffer = buffer;
     this.version = version;
     MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam);
     this.name = reader.LocalName;
     this.ns = reader.NamespaceURI;
     this.bufferIndex = buffer.SectionCount;
     XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
     writer.WriteStartElement("Envelope");
     if (envelopeAttributes != null)
     {
         XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer);
     }
     writer.WriteStartElement("Header");
     if (headerAttributes != null)
     {
         XmlAttributeHolder.WriteAttributes(headerAttributes, writer);
     }
     writer.WriteNode(reader, false);
     writer.WriteEndElement();
     writer.WriteEndElement();
     buffer.CloseSection();
 }

            public void ProvideFault(Exception exception, MessageVersion version, ref Message fault)
            {
                if (exception.GetType() == typeof(HttpException))
                {
                    var httpException = (HttpException)exception;

                    var inResponse = WebOperationContext.Current.IncomingRequest;

                    var webGetAttribute = GetCurrentAttribute(inResponse);
                    
                    if(webGetAttribute == null)
                    {
                        throw new RestException();    
                    }

                    var currentResponseFormat = webGetAttribute.ResponseFormat;

                    var restErrorMessage = new RestErrorMessage(httpException.Data, httpException.GetHttpCode(), httpException.ErrorCode);
                    fault = CreateMessage(restErrorMessage, version, currentResponseFormat);
                    fault.Properties.Add(WebBodyFormatMessageProperty.Name, GetBodyFormat(currentResponseFormat));

                    var outResponse = WebOperationContext.Current.OutgoingResponse;
                    outResponse.StatusCode = (HttpStatusCode)httpException.GetHttpCode();
                    outResponse.ContentType = string.Format("application/{0}", currentResponseFormat);
                }
                else
                {
                    throw new RestException();
                }
            }

        public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
        {
            var newEx = new FaultException(string.Format("服务端错误 {0}", error.TargetSite.Name));
            MessageFault msgFault = newEx.CreateMessageFault();

            fault = Message.CreateMessage(version, msgFault, newEx.Action);
        }

        /// <summary>
        /// Enables the creation of a custom <see cref="System.ServiceModel.FaultException"/>
        /// that is returned from an exception in the course of a service method.
        /// </summary>
        /// <param name="error"></param>
        /// <param name="version"></param>
        /// <param name="faultMessage"></param>
        public void ProvideFault(Exception error, MessageVersion version, ref Message faultMessage)
        {
            // Gets a serializable Fault object fromn error.
            Fault fault = Fault.GetFault(error);

            // Now we make the message by serializing the Fault to JSON.
            faultMessage = Message.CreateMessage(version, null, fault,
              new DataContractJsonSerializer(fault.GetType()));

            // Gotta set HTTP status codes.
            HttpResponseMessageProperty prop = new HttpResponseMessageProperty()
            {
                StatusCode = HttpStatusCode.InternalServerError, // 500
                StatusDescription = "An internal server error occurred." // Could use elaboration.
            };

            // Make sure to set the content type. Important for avoiding
            // certain kinds of encoding-specific XSS attacks.
            prop.Headers[HttpResponseHeader.ContentType] = "application/json; charset=utf-8";

            // Set a few other properties of the Message.
            faultMessage.Properties.Add(HttpResponseMessageProperty.Name, prop);
            faultMessage.Properties.Add(WebBodyFormatMessageProperty.Name,
                new WebBodyFormatMessageProperty(WebContentFormat.Json));
        }

 public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession, Message message, MessageHeaders headers)
 {
     CreateSequenceInfo info;
     if (message.IsEmpty)
     {
         string reason = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion) });
         Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
     }
     using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
     {
         info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader);
         message.ReadFromBodyContentsToEnd(reader);
     }
     info.SetMessageId(messageVersion, headers);
     info.SetReplyTo(messageVersion, headers);
     if (info.AcksTo.Uri != info.ReplyTo.Uri)
     {
         string str2 = System.ServiceModel.SR.GetString("CSRefusedAcksToMustEqualReplyTo");
         Message message3 = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, str2);
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(message3, str2, new ProtocolException(str2)));
     }
     info.to = message.Headers.To;
     if ((info.to == null) && (messageVersion.Addressing == AddressingVersion.WSAddressing10))
     {
         info.to = messageVersion.Addressing.AnonymousUri;
     }
     return info;
 }

 public IssuedTokensHeader(XmlReader xmlReader, MessageVersion version, SecurityStandardsManager standardsManager)
     : base()
 {
     if (xmlReader == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader");
     }
     if (standardsManager == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("standardsManager"));
     }
     this.standardsManager = standardsManager;
     XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(xmlReader);
     MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam);
     reader.ReadStartElement(this.Name, this.Namespace);
     Collection<RequestSecurityTokenResponse> coll = new Collection<RequestSecurityTokenResponse>();
     if (this.standardsManager.TrustDriver.IsAtRequestSecurityTokenResponseCollection(reader))
     {
         RequestSecurityTokenResponseCollection rstrColl = this.standardsManager.TrustDriver.CreateRequestSecurityTokenResponseCollection(reader);
         foreach (RequestSecurityTokenResponse rstr in rstrColl.RstrCollection)
         {
             coll.Add(rstr);
         }
     }
     else
     {
         RequestSecurityTokenResponse rstr = this.standardsManager.TrustDriver.CreateRequestSecurityTokenResponse(reader);
         coll.Add(rstr);
     }
     this.tokenIssuances = new ReadOnlyCollection<RequestSecurityTokenResponse>(coll);
     reader.ReadEndElement();
 }

 protected override IChannelFactory<IRequestReplyService> SelectChannelFactory(out MessageVersion messageVersion)
 {
     base.interoperating = false;
     EndpointIdentity identity = base.to.Identity;
     if (identity != null)
     {
         string claimType = identity.IdentityClaim.ClaimType;
         if ((claimType != ClaimTypes.Spn) && (claimType != ClaimTypes.Upn))
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CreateChannelFailureException(Microsoft.Transactions.SR.GetString("InvalidTrustIdentityType", new object[] { claimType })));
         }
     }
     string scheme = base.to.Uri.Scheme;
     if (string.Compare(scheme, Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase) == 0)
     {
         messageVersion = base.coordinationService.NamedPipeActivationBinding.MessageVersion;
         return base.coordinationService.NamedPipeActivationChannelFactory;
     }
     if (!base.coordinationService.Config.RemoteClientsEnabled || (string.Compare(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) != 0))
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CreateChannelFailureException(Microsoft.Transactions.SR.GetString("InvalidSchemeWithTrustIdentity", new object[] { scheme })));
     }
     messageVersion = base.coordinationService.WindowsActivationBinding.MessageVersion;
     return base.coordinationService.WindowsActivationChannelFactory;
 }