mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
492 lines
24 KiB
C#
492 lines
24 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
#pragma warning disable 1634, 1691
|
|
namespace System.ServiceModel.Description
|
|
{
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Net;
|
|
using System.Runtime.Serialization;
|
|
using System.Runtime.Serialization.Json;
|
|
using System.Security;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Activation;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.ServiceModel.Web;
|
|
using System.Xml;
|
|
|
|
public sealed class WebScriptEnablingBehavior : WebHttpBehavior
|
|
{
|
|
static readonly DataContractJsonSerializer jsonFaultSerializer = new DataContractJsonSerializer(typeof(JsonFaultDetail));
|
|
static readonly WebMessageBodyStyle webScriptBodyStyle = WebMessageBodyStyle.WrappedRequest;
|
|
static readonly WebMessageFormat webScriptDefaultMessageFormat = WebMessageFormat.Json;
|
|
const int MaxMetadataEndpointBufferSize = 2048;
|
|
WebMessageFormat requestMessageFormat = webScriptDefaultMessageFormat;
|
|
WebMessageFormat responseMessageFormat = webScriptDefaultMessageFormat;
|
|
|
|
public WebScriptEnablingBehavior()
|
|
{
|
|
}
|
|
|
|
public override WebMessageBodyStyle DefaultBodyStyle
|
|
{
|
|
get
|
|
{
|
|
return webScriptBodyStyle;
|
|
}
|
|
set
|
|
{
|
|
if (value != webScriptBodyStyle)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.BodyStyleNotSupportedByWebScript, value, this.GetType().Name, webScriptBodyStyle)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public override WebMessageFormat DefaultOutgoingRequestFormat
|
|
{
|
|
get
|
|
{
|
|
return this.requestMessageFormat;
|
|
}
|
|
set
|
|
{
|
|
if (!WebMessageFormatHelper.IsDefined(value))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
this.requestMessageFormat = value;
|
|
}
|
|
}
|
|
|
|
public override WebMessageFormat DefaultOutgoingResponseFormat
|
|
{
|
|
get
|
|
{
|
|
return this.responseMessageFormat;
|
|
}
|
|
set
|
|
{
|
|
if (!WebMessageFormatHelper.IsDefined(value))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
this.responseMessageFormat = value;
|
|
}
|
|
}
|
|
|
|
public override bool HelpEnabled
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.HelpPageNotSupportedInScripts)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool AutomaticFormatSelectionEnabled
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.AutomaticFormatSelectionNotSupportedInScripts)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool FaultExceptionEnabled
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.FaultExceptionEnabledNotSupportedInScripts)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
|
|
{
|
|
base.ApplyClientBehavior(endpoint, clientRuntime);
|
|
#pragma warning disable 56506 // [....], clientRuntime.MessageInspectors is never null
|
|
clientRuntime.MessageInspectors.Add(new JsonClientMessageInspector());
|
|
#pragma warning restore 56506
|
|
}
|
|
|
|
public override void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
|
|
{
|
|
base.ApplyDispatchBehavior(endpoint, endpointDispatcher);
|
|
|
|
try
|
|
{
|
|
AddMetadataEndpoint(endpoint, endpointDispatcher, false); // debugMode
|
|
AddMetadataEndpoint(endpoint, endpointDispatcher, true); // debugMode
|
|
}
|
|
catch (XmlException exception)
|
|
{
|
|
// [....], need to reference this resource string although fix for 13332 was removed
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.InvalidXmlCharactersInNameUsedWithPOSTMethod, string.Empty, string.Empty, string.Empty), exception));
|
|
}
|
|
}
|
|
|
|
public override void Validate(ServiceEndpoint endpoint)
|
|
{
|
|
base.Validate(endpoint);
|
|
|
|
#pragma warning disable 56506 // [....], endpoint.Contract is never null
|
|
foreach (OperationDescription operation in endpoint.Contract.Operations)
|
|
#pragma warning restore 56506
|
|
{
|
|
if (operation.Behaviors.Find<XmlSerializerOperationBehavior>() != null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.WebScriptNotSupportedForXmlSerializerFormat, typeof(XmlSerializerFormatAttribute).Name, this.GetType().ToString())));
|
|
}
|
|
string method = WebHttpBehavior.GetWebMethod(operation);
|
|
if (method != WebHttpBehavior.GET
|
|
&& method != WebHttpBehavior.POST)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.WebScriptInvalidHttpRequestMethod, operation.Name,
|
|
endpoint.Contract.Name, method, this.GetType().ToString())));
|
|
}
|
|
WebGetAttribute webGetAttribute = operation.Behaviors.Find<WebGetAttribute>();
|
|
if (webGetAttribute != null && webGetAttribute.UriTemplate != null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.WebScriptNotSupportedForXmlSerializerFormat, typeof(UriTemplate).Name, this.GetType().ToString())));
|
|
}
|
|
WebInvokeAttribute webInvokeAttribute = operation.Behaviors.Find<WebInvokeAttribute>();
|
|
if (webInvokeAttribute != null && webInvokeAttribute.UriTemplate != null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.WebScriptNotSupportedForXmlSerializerFormat, typeof(UriTemplate).Name, this.GetType().ToString())));
|
|
}
|
|
WebMessageBodyStyle bodyStyle = GetBodyStyle(operation);
|
|
if (bodyStyle != webScriptBodyStyle)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.BodyStyleNotSupportedByWebScript, bodyStyle, this.GetType().Name, webScriptBodyStyle)));
|
|
}
|
|
|
|
foreach (MessageDescription messageDescription in operation.Messages)
|
|
{
|
|
if (!messageDescription.IsTypedMessage &&
|
|
(messageDescription.Direction == MessageDirection.Output) &&
|
|
(messageDescription.Body.Parts.Count > 0))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.WebScriptOutRefOperationsNotSupported, operation.Name,
|
|
endpoint.Contract.Name)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override DataContractJsonSerializerOperationFormatter CreateDataContractJsonSerializerOperationFormatter(OperationDescription od, DataContractSerializerOperationBehavior dcsob, bool isWrapped)
|
|
{
|
|
return new DataContractJsonSerializerOperationFormatter(od, dcsob.MaxItemsInObjectGraph, dcsob.IgnoreExtensionDataObject, dcsob.DataContractSurrogate, isWrapped, true, this.JavascriptCallbackParameterName);
|
|
}
|
|
|
|
internal override string GetWmiTypeName()
|
|
{
|
|
return "WebScriptEnablingBehavior";
|
|
}
|
|
|
|
internal override bool UseBareReplyFormatter(WebMessageBodyStyle style, OperationDescription operationDescription, WebMessageFormat responseFormat, out Type parameterType)
|
|
{
|
|
if (responseFormat == WebMessageFormat.Json)
|
|
{
|
|
parameterType = null;
|
|
return false;
|
|
}
|
|
return base.UseBareReplyFormatter(style, operationDescription, responseFormat, out parameterType);
|
|
}
|
|
|
|
protected override void AddClientErrorInspector(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
|
|
{
|
|
clientRuntime.MessageInspectors.Add(new JsonClientMessageInspector());
|
|
}
|
|
|
|
protected override void AddServerErrorHandlers(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
|
|
{
|
|
if (endpointDispatcher.ChannelDispatcher == null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
|
|
"endpointDispatcher", SR2.GetString(SR2.ChannelDispatcherMustBePresent));
|
|
}
|
|
#pragma warning disable 56506 // [....], endpointDispatcher.ChannelDispatcher.ErrorHandlers never null
|
|
endpointDispatcher.ChannelDispatcher.ErrorHandlers.Add(new JsonErrorHandler(endpoint, endpointDispatcher.ChannelDispatcher.IncludeExceptionDetailInFaults));
|
|
#pragma warning restore 56506
|
|
}
|
|
|
|
protected override QueryStringConverter GetQueryStringConverter(OperationDescription operationDescription)
|
|
{
|
|
return new JsonQueryStringConverter(operationDescription);
|
|
}
|
|
|
|
void AddMetadataEndpoint(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher, bool debugMode)
|
|
{
|
|
Uri baseAddress = endpoint.Address.Uri;
|
|
if (baseAddress == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ServiceHostBase host = endpointDispatcher.ChannelDispatcher.Host;
|
|
|
|
UriBuilder builder = new UriBuilder(baseAddress);
|
|
builder.Path += builder.Path.EndsWith("/", StringComparison.OrdinalIgnoreCase)
|
|
? (WebScriptClientGenerator.GetMetadataEndpointSuffix(debugMode))
|
|
: ("/" + WebScriptClientGenerator.GetMetadataEndpointSuffix(debugMode));
|
|
EndpointAddress metadataAddress = new EndpointAddress(builder.Uri);
|
|
|
|
foreach (ServiceEndpoint serviceEndpoint in host.Description.Endpoints)
|
|
{
|
|
if (EndpointAddress.UriEquals(serviceEndpoint.Address.Uri, metadataAddress.Uri, true, false))// ignoreCase // includeHostNameInComparison
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new InvalidOperationException(SR2.GetString(SR2.JsonNoEndpointAtMetadataAddress, this.GetType().ToString(), serviceEndpoint.Address, serviceEndpoint.Name, host.Description.Name)));
|
|
}
|
|
}
|
|
|
|
HttpTransportBindingElement transportBindingElement;
|
|
HttpTransportBindingElement existingTransportBindingElement = endpoint.Binding.CreateBindingElements().Find<HttpTransportBindingElement>();
|
|
|
|
if (existingTransportBindingElement != null)
|
|
{
|
|
transportBindingElement = (HttpTransportBindingElement)existingTransportBindingElement.Clone();
|
|
}
|
|
else
|
|
{
|
|
if (baseAddress.Scheme == "https")
|
|
{
|
|
transportBindingElement = new HttpsTransportBindingElement();
|
|
}
|
|
else
|
|
{
|
|
transportBindingElement = new HttpTransportBindingElement();
|
|
}
|
|
}
|
|
|
|
transportBindingElement.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
|
|
transportBindingElement.TransferMode = TransferMode.Buffered;
|
|
transportBindingElement.MaxBufferSize = MaxMetadataEndpointBufferSize;
|
|
transportBindingElement.MaxReceivedMessageSize = MaxMetadataEndpointBufferSize;
|
|
Binding metadataBinding = new CustomBinding(
|
|
new WebScriptMetadataMessageEncodingBindingElement(),
|
|
transportBindingElement);
|
|
BindingParameterCollection parameters = host.GetBindingParameters(endpoint);
|
|
|
|
// build endpoint dispatcher
|
|
ContractDescription metadataContract = ContractDescription.GetContract(typeof(ServiceMetadataExtension.IHttpGetMetadata));
|
|
OperationDescription metadataOperation = metadataContract.Operations[0];
|
|
EndpointDispatcher metadataEndpointDispatcher = new EndpointDispatcher(metadataAddress, metadataContract.Name, metadataContract.Namespace);
|
|
DispatchOperation dispatchOperation = new DispatchOperation(metadataEndpointDispatcher.DispatchRuntime, metadataOperation.Name, metadataOperation.Messages[0].Action, metadataOperation.Messages[1].Action);
|
|
dispatchOperation.Formatter = new WebScriptMetadataFormatter();
|
|
dispatchOperation.Invoker = new SyncMethodInvoker(metadataOperation.SyncMethod);
|
|
metadataEndpointDispatcher.DispatchRuntime.Operations.Add(dispatchOperation);
|
|
metadataEndpointDispatcher.DispatchRuntime.SingletonInstanceContext = new InstanceContext(host, new WebScriptClientGenerator(endpoint, debugMode, !String.IsNullOrEmpty(this.JavascriptCallbackParameterName)));
|
|
metadataEndpointDispatcher.DispatchRuntime.InstanceContextProvider = new SingletonInstanceContextProvider(metadataEndpointDispatcher.DispatchRuntime);
|
|
|
|
// build channel dispatcher
|
|
IChannelListener<IReplyChannel> listener = null;
|
|
if (metadataBinding.CanBuildChannelListener<IReplyChannel>(parameters))
|
|
{
|
|
listener = metadataBinding.BuildChannelListener<IReplyChannel>(metadataAddress.Uri, parameters);
|
|
}
|
|
ChannelDispatcher metadataChannelDispatcher = new ChannelDispatcher(listener);
|
|
metadataChannelDispatcher.MessageVersion = MessageVersion.None;
|
|
metadataChannelDispatcher.Endpoints.Add(metadataEndpointDispatcher);
|
|
|
|
host.ChannelDispatchers.Add(metadataChannelDispatcher);
|
|
}
|
|
|
|
class JsonClientMessageInspector : WebFaultClientMessageInspector
|
|
{
|
|
public override void AfterReceiveReply(ref Message reply, object correlationState)
|
|
{
|
|
bool callBase = true;
|
|
if (reply != null)
|
|
{
|
|
object responseProperty = reply.Properties[HttpResponseMessageProperty.Name];
|
|
if (responseProperty != null)
|
|
{
|
|
if (((HttpResponseMessageProperty)responseProperty).Headers[JsonGlobals.jsonerrorString] == JsonGlobals.trueString)
|
|
{
|
|
callBase = false;
|
|
XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
|
|
JsonFaultDetail faultDetail = jsonFaultSerializer.ReadObject(reader) as JsonFaultDetail;
|
|
FaultCode faultCode = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch);
|
|
faultCode = FaultCode.CreateReceiverFaultCode(faultCode);
|
|
if (faultDetail != null)
|
|
{
|
|
if (faultDetail.ExceptionDetail != null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new FaultException<ExceptionDetail>(faultDetail.ExceptionDetail, faultDetail.Message, faultCode));
|
|
}
|
|
else
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new FaultException(MessageFault.CreateFault(faultCode, faultDetail.Message)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new FaultException(MessageFault.CreateFault(faultCode,
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInternalServerError))));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (callBase)
|
|
{
|
|
base.AfterReceiveReply(ref reply, correlationState);
|
|
}
|
|
}
|
|
}
|
|
|
|
class JsonErrorHandler : IErrorHandler
|
|
{
|
|
bool includeExceptionDetailInFaults;
|
|
string outgoingContentType;
|
|
|
|
public JsonErrorHandler(ServiceEndpoint endpoint, bool includeExceptionDetailInFaults)
|
|
{
|
|
WebMessageEncodingBindingElement webMEBE = endpoint.Binding.CreateBindingElements().Find<WebMessageEncodingBindingElement>();
|
|
outgoingContentType = JsonMessageEncoderFactory.GetContentType(webMEBE);
|
|
this.includeExceptionDetailInFaults = includeExceptionDetailInFaults;
|
|
}
|
|
|
|
public bool HandleError(Exception error)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
|
|
{
|
|
HttpResponseMessageProperty responseProperty;
|
|
if (fault == null)
|
|
{
|
|
FaultCode code = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch);
|
|
code = FaultCode.CreateReceiverFaultCode(code);
|
|
string action = FaultCodeConstants.Actions.NetDispatcher;
|
|
|
|
MessageFault innerFault;
|
|
innerFault = MessageFault.CreateFault(code, new FaultReason(error.Message, CultureInfo.CurrentCulture), new ExceptionDetail(error));
|
|
fault = Message.CreateMessage(version, action, new JsonFaultBodyWriter(innerFault, this.includeExceptionDetailInFaults));
|
|
|
|
responseProperty = new HttpResponseMessageProperty();
|
|
fault.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);
|
|
}
|
|
else
|
|
{
|
|
MessageFault innerFault = MessageFault.CreateFault(fault, TransportDefaults.MaxFaultSize);
|
|
Message newMessage = Message.CreateMessage(version, fault.Headers.Action, new JsonFaultBodyWriter(innerFault, this.includeExceptionDetailInFaults));
|
|
newMessage.Headers.To = fault.Headers.To;
|
|
newMessage.Properties.CopyProperties(fault.Properties);
|
|
|
|
object property = null;
|
|
if (newMessage.Properties.TryGetValue(HttpResponseMessageProperty.Name, out property))
|
|
{
|
|
responseProperty = (HttpResponseMessageProperty)property;
|
|
}
|
|
else
|
|
{
|
|
responseProperty = new HttpResponseMessageProperty();
|
|
newMessage.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);
|
|
}
|
|
|
|
fault.Close();
|
|
fault = newMessage;
|
|
}
|
|
responseProperty.Headers.Add(HttpResponseHeader.ContentType, outgoingContentType);
|
|
responseProperty.Headers.Add(JsonGlobals.jsonerrorString, JsonGlobals.trueString);
|
|
responseProperty.StatusCode = System.Net.HttpStatusCode.InternalServerError;
|
|
|
|
object bodyFormatPropertyObject;
|
|
if (fault.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatPropertyObject))
|
|
{
|
|
WebBodyFormatMessageProperty bodyFormatProperty = bodyFormatPropertyObject as WebBodyFormatMessageProperty;
|
|
if ((bodyFormatProperty == null) ||
|
|
(bodyFormatProperty.Format != WebContentFormat.Json))
|
|
{
|
|
fault.Properties[WebBodyFormatMessageProperty.Name] = WebBodyFormatMessageProperty.JsonProperty;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fault.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.JsonProperty);
|
|
}
|
|
}
|
|
|
|
class JsonFaultBodyWriter : BodyWriter
|
|
{
|
|
JsonFaultDetail faultDetail;
|
|
|
|
public JsonFaultBodyWriter(MessageFault fault, bool includeExceptionDetailInFaults)
|
|
: base(false)
|
|
{
|
|
faultDetail = new JsonFaultDetail();
|
|
if (includeExceptionDetailInFaults)
|
|
{
|
|
faultDetail.Message = fault.Reason.ToString();
|
|
if (fault.HasDetail)
|
|
{
|
|
try
|
|
{
|
|
ExceptionDetail originalFaultDetail = fault.GetDetail<ExceptionDetail>();
|
|
faultDetail.StackTrace = originalFaultDetail.StackTrace;
|
|
faultDetail.ExceptionType = originalFaultDetail.Type;
|
|
faultDetail.ExceptionDetail = originalFaultDetail;
|
|
}
|
|
catch (SerializationException exception)
|
|
{
|
|
System.ServiceModel.DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
|
|
// A SerializationException will be thrown if the detail isn't of type ExceptionDetail
|
|
// In that case, we want to just move on.
|
|
}
|
|
catch (SecurityException exception)
|
|
{
|
|
System.ServiceModel.DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
|
|
// A SecurityException will be thrown if the detail can't be obtained in partial trust
|
|
// (This is guaranteed to happen unless there's an Assert for MemberAccessPermission, since ExceptionDetail
|
|
// has DataMembers that have private setters.)
|
|
// In that case, we want to just move on.
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
faultDetail.Message = System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInternalServerError);
|
|
}
|
|
}
|
|
|
|
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
|
|
{
|
|
jsonFaultSerializer.WriteObject(writer, faultDetail);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|