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
481 lines
19 KiB
C#
481 lines
19 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel
|
|
{
|
|
using System.ServiceModel.Administration;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Configuration;
|
|
using System.Runtime.Serialization;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.Transactions;
|
|
using System.Runtime.CompilerServices;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
|
|
[AttributeUsage(ServiceModelAttributeTargets.ServiceBehavior)]
|
|
public sealed class ServiceBehaviorAttribute : Attribute, IServiceBehavior
|
|
{
|
|
internal static IsolationLevel DefaultIsolationLevel = IsolationLevel.Unspecified;
|
|
ConcurrencyMode concurrencyMode = ConcurrencyMode.Single;
|
|
bool ensureOrderedDispatch = false;
|
|
string configurationName;
|
|
bool includeExceptionDetailInFaults = false;
|
|
InstanceContextMode instanceMode;
|
|
bool releaseServiceInstanceOnTransactionComplete = true;
|
|
bool releaseServiceInstanceOnTransactionCompleteSet = false;
|
|
bool transactionAutoCompleteOnSessionClose = false;
|
|
bool transactionAutoCompleteOnSessionCloseSet = false;
|
|
object wellKnownSingleton = null; // if the user passes an object to the ServiceHost, it is stored here
|
|
object hiddenSingleton = null; // if the user passes a type to the ServiceHost, and instanceMode==Single, we store the instance here
|
|
bool validateMustUnderstand = true;
|
|
bool ignoreExtensionDataObject = DataContractSerializerDefaults.IgnoreExtensionDataObject;
|
|
int maxItemsInObjectGraph = DataContractSerializerDefaults.MaxItemsInObjectGraph;
|
|
IsolationLevel transactionIsolationLevel = DefaultIsolationLevel;
|
|
bool isolationLevelSet = false;
|
|
bool automaticSessionShutdown = true;
|
|
IInstanceProvider instanceProvider = null;
|
|
TimeSpan transactionTimeout = TimeSpan.Zero;
|
|
string transactionTimeoutString;
|
|
bool transactionTimeoutSet = false;
|
|
bool useSynchronizationContext = true;
|
|
string serviceName = null;
|
|
string serviceNamespace = null;
|
|
AddressFilterMode addressFilterMode = AddressFilterMode.Exact;
|
|
|
|
[DefaultValue(null)]
|
|
public string Name
|
|
{
|
|
get { return serviceName; }
|
|
set { serviceName = value; }
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
public string Namespace
|
|
{
|
|
get { return serviceNamespace; }
|
|
set { serviceNamespace = value; }
|
|
}
|
|
|
|
internal IInstanceProvider InstanceProvider
|
|
{
|
|
set { this.instanceProvider = value; }
|
|
}
|
|
|
|
[DefaultValue(AddressFilterMode.Exact)]
|
|
public AddressFilterMode AddressFilterMode
|
|
{
|
|
get { return this.addressFilterMode; }
|
|
set
|
|
{
|
|
if (!AddressFilterModeHelper.IsDefined(value))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
|
|
this.addressFilterMode = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
public bool AutomaticSessionShutdown
|
|
{
|
|
get { return this.automaticSessionShutdown; }
|
|
set { this.automaticSessionShutdown = value; }
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
public string ConfigurationName
|
|
{
|
|
get { return this.configurationName; }
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
|
|
}
|
|
if (value == string.Empty)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value",
|
|
SR.GetString(SR.SFxConfigurationNameCannotBeEmpty)));
|
|
}
|
|
this.configurationName = value;
|
|
}
|
|
}
|
|
|
|
public IsolationLevel TransactionIsolationLevel
|
|
{
|
|
get { return this.transactionIsolationLevel; }
|
|
set
|
|
{
|
|
switch (value)
|
|
{
|
|
case IsolationLevel.Serializable:
|
|
case IsolationLevel.RepeatableRead:
|
|
case IsolationLevel.ReadCommitted:
|
|
case IsolationLevel.ReadUncommitted:
|
|
case IsolationLevel.Unspecified:
|
|
case IsolationLevel.Chaos:
|
|
case IsolationLevel.Snapshot:
|
|
break;
|
|
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
|
|
this.transactionIsolationLevel = value;
|
|
isolationLevelSet = true;
|
|
}
|
|
}
|
|
|
|
public bool ShouldSerializeTransactionIsolationLevel()
|
|
{
|
|
return IsolationLevelSet;
|
|
}
|
|
|
|
internal bool IsolationLevelSet
|
|
{
|
|
get { return this.isolationLevelSet; }
|
|
}
|
|
|
|
[DefaultValue(false)]
|
|
public bool IncludeExceptionDetailInFaults
|
|
{
|
|
get { return this.includeExceptionDetailInFaults; }
|
|
set { this.includeExceptionDetailInFaults = value; }
|
|
}
|
|
|
|
[DefaultValue(ConcurrencyMode.Single)]
|
|
public ConcurrencyMode ConcurrencyMode
|
|
{
|
|
get { return this.concurrencyMode; }
|
|
set
|
|
{
|
|
if (!ConcurrencyModeHelper.IsDefined(value))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
|
|
this.concurrencyMode = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(false)]
|
|
public bool EnsureOrderedDispatch
|
|
{
|
|
get { return this.ensureOrderedDispatch; }
|
|
set { this.ensureOrderedDispatch = value; }
|
|
}
|
|
|
|
[DefaultValue(InstanceContextMode.PerSession)]
|
|
public InstanceContextMode InstanceContextMode
|
|
{
|
|
get { return this.instanceMode; }
|
|
set
|
|
{
|
|
if (!InstanceContextModeHelper.IsDefined(value))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
|
|
this.instanceMode = value;
|
|
}
|
|
}
|
|
|
|
public bool ReleaseServiceInstanceOnTransactionComplete
|
|
{
|
|
get { return releaseServiceInstanceOnTransactionComplete; }
|
|
set
|
|
{
|
|
this.releaseServiceInstanceOnTransactionComplete = value;
|
|
this.releaseServiceInstanceOnTransactionCompleteSet = true;
|
|
}
|
|
}
|
|
|
|
public bool ShouldSerializeConfigurationName()
|
|
{
|
|
return this.configurationName != null;
|
|
}
|
|
|
|
public bool ShouldSerializeReleaseServiceInstanceOnTransactionComplete()
|
|
{
|
|
return ReleaseServiceInstanceOnTransactionCompleteSet;
|
|
}
|
|
|
|
internal bool ReleaseServiceInstanceOnTransactionCompleteSet
|
|
{
|
|
get { return this.releaseServiceInstanceOnTransactionCompleteSet; }
|
|
}
|
|
|
|
public bool TransactionAutoCompleteOnSessionClose
|
|
{
|
|
get { return transactionAutoCompleteOnSessionClose; }
|
|
set
|
|
{
|
|
this.transactionAutoCompleteOnSessionClose = value;
|
|
this.transactionAutoCompleteOnSessionCloseSet = true;
|
|
}
|
|
}
|
|
|
|
public bool ShouldSerializeTransactionAutoCompleteOnSessionClose()
|
|
{
|
|
return TransactionAutoCompleteOnSessionCloseSet;
|
|
}
|
|
|
|
internal bool TransactionAutoCompleteOnSessionCloseSet
|
|
{
|
|
get { return this.transactionAutoCompleteOnSessionCloseSet; }
|
|
}
|
|
|
|
public string TransactionTimeout
|
|
{
|
|
get { return transactionTimeoutString; }
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
|
|
}
|
|
|
|
try
|
|
{
|
|
TimeSpan timeout = TimeSpan.Parse(value, CultureInfo.InvariantCulture);
|
|
|
|
if (timeout < TimeSpan.Zero)
|
|
{
|
|
string message = SR.GetString(SR.SFxTimeoutOutOfRange0);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, message));
|
|
}
|
|
|
|
this.transactionTimeout = timeout;
|
|
this.transactionTimeoutString = value;
|
|
this.transactionTimeoutSet = true;
|
|
}
|
|
catch (FormatException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SFxTimeoutInvalidStringFormat), "value", e));
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ShouldSerializeTransactionTimeout()
|
|
{
|
|
return TransactionTimeoutSet;
|
|
}
|
|
|
|
internal TimeSpan TransactionTimeoutTimespan
|
|
{
|
|
get { return this.transactionTimeout; }
|
|
}
|
|
|
|
internal bool TransactionTimeoutSet
|
|
{
|
|
get { return this.transactionTimeoutSet; }
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
public bool ValidateMustUnderstand
|
|
{
|
|
get { return validateMustUnderstand; }
|
|
set { validateMustUnderstand = value; }
|
|
}
|
|
|
|
[DefaultValue(DataContractSerializerDefaults.IgnoreExtensionDataObject)]
|
|
public bool IgnoreExtensionDataObject
|
|
{
|
|
get { return ignoreExtensionDataObject; }
|
|
set { ignoreExtensionDataObject = value; }
|
|
}
|
|
|
|
[DefaultValue(DataContractSerializerDefaults.MaxItemsInObjectGraph)]
|
|
public int MaxItemsInObjectGraph
|
|
{
|
|
get { return maxItemsInObjectGraph; }
|
|
set { maxItemsInObjectGraph = value; }
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
public bool UseSynchronizationContext
|
|
{
|
|
get { return this.useSynchronizationContext; }
|
|
set { this.useSynchronizationContext = value; }
|
|
}
|
|
|
|
public object GetWellKnownSingleton()
|
|
{
|
|
return this.wellKnownSingleton;
|
|
}
|
|
|
|
public void SetWellKnownSingleton(object value)
|
|
{
|
|
if (value == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
|
|
|
|
this.wellKnownSingleton = value;
|
|
}
|
|
|
|
internal object GetHiddenSingleton()
|
|
{
|
|
return this.hiddenSingleton;
|
|
}
|
|
|
|
internal void SetHiddenSingleton(object value)
|
|
{
|
|
if (value == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
|
|
|
|
this.hiddenSingleton = value;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
void SetIsolationLevel(ChannelDispatcher channelDispatcher)
|
|
{
|
|
if (channelDispatcher == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher");
|
|
|
|
channelDispatcher.TransactionIsolationLevel = this.transactionIsolationLevel;
|
|
}
|
|
|
|
void IServiceBehavior.Validate(ServiceDescription description, ServiceHostBase serviceHostBase)
|
|
{
|
|
if (this.concurrencyMode != ConcurrencyMode.Single && this.ensureOrderedDispatch)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxNonConcurrentOrEnsureOrderedDispatch, description.Name)));
|
|
}
|
|
}
|
|
|
|
void IServiceBehavior.AddBindingParameters(ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters)
|
|
{
|
|
}
|
|
|
|
void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription description, ServiceHostBase serviceHostBase)
|
|
{
|
|
for (int i = 0; i < serviceHostBase.ChannelDispatchers.Count; i++)
|
|
{
|
|
ChannelDispatcher channelDispatcher = serviceHostBase.ChannelDispatchers[i] as ChannelDispatcher;
|
|
if (channelDispatcher != null)
|
|
{
|
|
channelDispatcher.IncludeExceptionDetailInFaults = this.includeExceptionDetailInFaults;
|
|
|
|
if (channelDispatcher.HasApplicationEndpoints())
|
|
{
|
|
channelDispatcher.TransactionTimeout = transactionTimeout;
|
|
if (isolationLevelSet)
|
|
SetIsolationLevel(channelDispatcher);
|
|
|
|
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
|
|
{
|
|
if (endpointDispatcher.IsSystemEndpoint)
|
|
{
|
|
continue;
|
|
}
|
|
DispatchRuntime behavior = endpointDispatcher.DispatchRuntime;
|
|
behavior.ConcurrencyMode = this.concurrencyMode;
|
|
behavior.EnsureOrderedDispatch = this.ensureOrderedDispatch;
|
|
behavior.ValidateMustUnderstand = validateMustUnderstand;
|
|
behavior.AutomaticInputSessionShutdown = this.automaticSessionShutdown;
|
|
behavior.TransactionAutoCompleteOnSessionClose = this.transactionAutoCompleteOnSessionClose;
|
|
behavior.ReleaseServiceInstanceOnTransactionComplete = this.releaseServiceInstanceOnTransactionComplete;
|
|
if (!this.useSynchronizationContext)
|
|
{
|
|
behavior.SynchronizationContext = null;
|
|
}
|
|
|
|
if (!endpointDispatcher.AddressFilterSetExplicit)
|
|
{
|
|
EndpointAddress address = endpointDispatcher.OriginalAddress;
|
|
if (address == null || this.AddressFilterMode == AddressFilterMode.Any)
|
|
{
|
|
endpointDispatcher.AddressFilter = new MatchAllMessageFilter();
|
|
}
|
|
else if (this.AddressFilterMode == AddressFilterMode.Prefix)
|
|
{
|
|
endpointDispatcher.AddressFilter = new PrefixEndpointAddressMessageFilter(address);
|
|
}
|
|
else if (this.AddressFilterMode == AddressFilterMode.Exact)
|
|
{
|
|
endpointDispatcher.AddressFilter = new EndpointAddressMessageFilter(address);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#pragma warning suppress 56506
|
|
}
|
|
}
|
|
DataContractSerializerServiceBehavior.ApplySerializationSettings(description, ignoreExtensionDataObject, maxItemsInObjectGraph);
|
|
ApplyInstancing(description, serviceHostBase);
|
|
}
|
|
|
|
void ApplyInstancing(ServiceDescription description, ServiceHostBase serviceHostBase)
|
|
{
|
|
Type serviceType = description.ServiceType;
|
|
InstanceContext singleton = null;
|
|
|
|
for (int i = 0; i < serviceHostBase.ChannelDispatchers.Count; i++)
|
|
{
|
|
ChannelDispatcher channelDispatcher = serviceHostBase.ChannelDispatchers[i] as ChannelDispatcher;
|
|
if (channelDispatcher != null)
|
|
{
|
|
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
|
|
{
|
|
if (endpointDispatcher.IsSystemEndpoint)
|
|
{
|
|
continue;
|
|
}
|
|
DispatchRuntime dispatch = endpointDispatcher.DispatchRuntime;
|
|
if (dispatch.InstanceProvider == null)
|
|
{
|
|
if (instanceProvider == null)
|
|
{
|
|
if (serviceType == null && this.wellKnownSingleton == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.InstanceSettingsMustHaveTypeOrWellKnownObject0)));
|
|
|
|
if (this.instanceMode != InstanceContextMode.Single && this.wellKnownSingleton != null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWellKnownNonSingleton0)));
|
|
}
|
|
else
|
|
{
|
|
dispatch.InstanceProvider = instanceProvider;
|
|
}
|
|
}
|
|
dispatch.Type = serviceType;
|
|
dispatch.InstanceContextProvider = InstanceContextProviderBase.GetProviderForMode(this.instanceMode, dispatch);
|
|
|
|
if ((this.instanceMode == InstanceContextMode.Single) &&
|
|
(dispatch.SingletonInstanceContext == null))
|
|
{
|
|
if (singleton == null)
|
|
{
|
|
if (this.wellKnownSingleton != null)
|
|
{
|
|
singleton = new InstanceContext(serviceHostBase, this.wellKnownSingleton, true, false);
|
|
}
|
|
else if (this.hiddenSingleton != null)
|
|
{
|
|
singleton = new InstanceContext(serviceHostBase, this.hiddenSingleton, false, false);
|
|
}
|
|
else
|
|
{
|
|
singleton = new InstanceContext(serviceHostBase, false);
|
|
}
|
|
|
|
singleton.AutoClose = false;
|
|
}
|
|
dispatch.SingletonInstanceContext = singleton;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|