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
603 lines
19 KiB
C#
603 lines
19 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Net;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Security;
|
|
using System.Xml;
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Compat", Justification = "Compat is an accepted abbreviation")]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public class ClientRuntimeCompatBase
|
|
{
|
|
internal ClientRuntimeCompatBase() { }
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
|
|
public IList<IClientMessageInspector> MessageInspectors
|
|
{
|
|
get
|
|
{
|
|
return this.messageInspectors;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
|
|
public KeyedCollection<string, ClientOperation> Operations
|
|
{
|
|
get
|
|
{
|
|
return this.compatOperations;
|
|
}
|
|
}
|
|
internal SynchronizedCollection<IClientMessageInspector> messageInspectors;
|
|
internal SynchronizedKeyedCollection<string, ClientOperation> operations;
|
|
internal KeyedCollection<string, ClientOperation> compatOperations;
|
|
}
|
|
|
|
public sealed class ClientRuntime : ClientRuntimeCompatBase
|
|
{
|
|
bool addTransactionFlowProperties = true;
|
|
Type callbackProxyType;
|
|
ProxyBehaviorCollection<IChannelInitializer> channelInitializers;
|
|
string contractName;
|
|
string contractNamespace;
|
|
Type contractProxyType;
|
|
DispatchRuntime dispatchRuntime;
|
|
IdentityVerifier identityVerifier;
|
|
ProxyBehaviorCollection<IInteractiveChannelInitializer> interactiveChannelInitializers;
|
|
|
|
IClientOperationSelector operationSelector;
|
|
ImmutableClientRuntime runtime;
|
|
ClientOperation unhandled;
|
|
bool useSynchronizationContext = true;
|
|
Uri via;
|
|
SharedRuntimeState shared;
|
|
int maxFaultSize;
|
|
bool messageVersionNoneFaultsEnabled;
|
|
|
|
internal ClientRuntime(DispatchRuntime dispatchRuntime, SharedRuntimeState shared)
|
|
: this(dispatchRuntime.EndpointDispatcher.ContractName,
|
|
dispatchRuntime.EndpointDispatcher.ContractNamespace,
|
|
shared)
|
|
{
|
|
if (dispatchRuntime == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dispatchRuntime");
|
|
|
|
this.dispatchRuntime = dispatchRuntime;
|
|
this.shared = shared;
|
|
|
|
Fx.Assert(shared.IsOnServer, "Server constructor called on client?");
|
|
}
|
|
|
|
internal ClientRuntime(string contractName, string contractNamespace)
|
|
: this(contractName, contractNamespace, new SharedRuntimeState(false))
|
|
{
|
|
Fx.Assert(!shared.IsOnServer, "Client constructor called on server?");
|
|
}
|
|
|
|
ClientRuntime(string contractName, string contractNamespace, SharedRuntimeState shared)
|
|
{
|
|
this.contractName = contractName;
|
|
this.contractNamespace = contractNamespace;
|
|
this.shared = shared;
|
|
|
|
OperationCollection operations = new OperationCollection(this);
|
|
this.operations = operations;
|
|
this.compatOperations = new OperationCollectionWrapper(operations);
|
|
this.channelInitializers = new ProxyBehaviorCollection<IChannelInitializer>(this);
|
|
this.messageInspectors = new ProxyBehaviorCollection<IClientMessageInspector>(this);
|
|
this.interactiveChannelInitializers = new ProxyBehaviorCollection<IInteractiveChannelInitializer>(this);
|
|
|
|
this.unhandled = new ClientOperation(this, "*", MessageHeaders.WildcardAction, MessageHeaders.WildcardAction);
|
|
this.unhandled.InternalFormatter = new MessageOperationFormatter();
|
|
this.maxFaultSize = TransportDefaults.MaxFaultSize;
|
|
}
|
|
|
|
internal bool AddTransactionFlowProperties
|
|
{
|
|
get { return this.addTransactionFlowProperties; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.addTransactionFlowProperties = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Type CallbackClientType
|
|
{
|
|
get { return this.callbackProxyType; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.callbackProxyType = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public SynchronizedCollection<IChannelInitializer> ChannelInitializers
|
|
{
|
|
get { return this.channelInitializers; }
|
|
}
|
|
|
|
public string ContractName
|
|
{
|
|
get { return this.contractName; }
|
|
}
|
|
|
|
public string ContractNamespace
|
|
{
|
|
get { return this.contractNamespace; }
|
|
}
|
|
|
|
public Type ContractClientType
|
|
{
|
|
get { return this.contractProxyType; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.contractProxyType = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal IdentityVerifier IdentityVerifier
|
|
{
|
|
get
|
|
{
|
|
if (this.identityVerifier == null)
|
|
{
|
|
this.identityVerifier = IdentityVerifier.CreateDefault();
|
|
}
|
|
|
|
return this.identityVerifier;
|
|
}
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
|
|
}
|
|
this.InvalidateRuntime();
|
|
|
|
this.identityVerifier = value;
|
|
}
|
|
}
|
|
|
|
public Uri Via
|
|
{
|
|
get { return this.via; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.via = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ValidateMustUnderstand
|
|
{
|
|
get { return this.shared.ValidateMustUnderstand; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.shared.ValidateMustUnderstand = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool MessageVersionNoneFaultsEnabled
|
|
{
|
|
get
|
|
{
|
|
return this.messageVersionNoneFaultsEnabled;
|
|
}
|
|
set
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.messageVersionNoneFaultsEnabled = value;
|
|
}
|
|
}
|
|
|
|
internal DispatchRuntime DispatchRuntime
|
|
{
|
|
get { return this.dispatchRuntime; }
|
|
}
|
|
|
|
public DispatchRuntime CallbackDispatchRuntime
|
|
{
|
|
get
|
|
{
|
|
if (this.dispatchRuntime == null)
|
|
this.dispatchRuntime = new DispatchRuntime(this, this.shared);
|
|
|
|
return this.dispatchRuntime;
|
|
}
|
|
}
|
|
|
|
internal bool EnableFaults
|
|
{
|
|
get
|
|
{
|
|
if (this.IsOnServer)
|
|
{
|
|
return this.dispatchRuntime.EnableFaults;
|
|
}
|
|
else
|
|
{
|
|
return this.shared.EnableFaults;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.IsOnServer)
|
|
{
|
|
string text = SR.GetString(SR.SFxSetEnableFaultsOnChannelDispatcher0);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(text));
|
|
}
|
|
else
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.shared.EnableFaults = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public SynchronizedCollection<IInteractiveChannelInitializer> InteractiveChannelInitializers
|
|
{
|
|
get { return this.interactiveChannelInitializers; }
|
|
}
|
|
|
|
public int MaxFaultSize
|
|
{
|
|
get
|
|
{
|
|
return this.maxFaultSize;
|
|
}
|
|
set
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.maxFaultSize = value;
|
|
}
|
|
}
|
|
|
|
internal bool IsOnServer
|
|
{
|
|
get { return this.shared.IsOnServer; }
|
|
}
|
|
|
|
public bool ManualAddressing
|
|
{
|
|
get
|
|
{
|
|
if (this.IsOnServer)
|
|
{
|
|
return this.dispatchRuntime.ManualAddressing;
|
|
}
|
|
else
|
|
{
|
|
return this.shared.ManualAddressing;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.IsOnServer)
|
|
{
|
|
string text = SR.GetString(SR.SFxSetManualAddresssingOnChannelDispatcher0);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(text));
|
|
}
|
|
else
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.shared.ManualAddressing = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal int MaxParameterInspectors
|
|
{
|
|
get
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
int max = 0;
|
|
|
|
for (int i = 0; i < this.operations.Count; i++)
|
|
max = System.Math.Max(max, this.operations[i].ParameterInspectors.Count);
|
|
|
|
return max;
|
|
}
|
|
}
|
|
}
|
|
|
|
public ICollection<IClientMessageInspector> ClientMessageInspectors
|
|
{
|
|
get { return this.MessageInspectors; }
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public new SynchronizedCollection<IClientMessageInspector> MessageInspectors
|
|
{
|
|
get { return this.messageInspectors; }
|
|
}
|
|
|
|
public ICollection<ClientOperation> ClientOperations
|
|
{
|
|
get { return this.Operations; }
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public new SynchronizedKeyedCollection<string, ClientOperation> Operations
|
|
{
|
|
get { return this.operations; }
|
|
}
|
|
|
|
public IClientOperationSelector OperationSelector
|
|
{
|
|
get { return this.operationSelector; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.operationSelector = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal object ThisLock
|
|
{
|
|
get { return this.shared; }
|
|
}
|
|
|
|
public ClientOperation UnhandledClientOperation
|
|
{
|
|
get { return this.unhandled; }
|
|
}
|
|
|
|
internal bool UseSynchronizationContext
|
|
{
|
|
get { return this.useSynchronizationContext; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.InvalidateRuntime();
|
|
this.useSynchronizationContext = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal T[] GetArray<T>(SynchronizedCollection<T> collection)
|
|
{
|
|
lock (collection.SyncRoot)
|
|
{
|
|
if (collection.Count == 0)
|
|
{
|
|
return EmptyArray<T>.Instance;
|
|
}
|
|
else
|
|
{
|
|
T[] array = new T[collection.Count];
|
|
collection.CopyTo(array, 0);
|
|
return array;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal ImmutableClientRuntime GetRuntime()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.runtime == null)
|
|
this.runtime = new ImmutableClientRuntime(this);
|
|
|
|
return this.runtime;
|
|
}
|
|
}
|
|
|
|
internal void InvalidateRuntime()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.shared.ThrowIfImmutable();
|
|
this.runtime = null;
|
|
}
|
|
}
|
|
|
|
internal void LockDownProperties()
|
|
{
|
|
this.shared.LockDownProperties();
|
|
}
|
|
|
|
internal SynchronizedCollection<T> NewBehaviorCollection<T>()
|
|
{
|
|
return new ProxyBehaviorCollection<T>(this);
|
|
}
|
|
|
|
internal bool IsFault(ref Message reply)
|
|
{
|
|
if (reply == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (reply.IsFault)
|
|
{
|
|
return true;
|
|
}
|
|
if (this.MessageVersionNoneFaultsEnabled && IsMessageVersionNoneFault(ref reply, this.MaxFaultSize))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal static bool IsMessageVersionNoneFault(ref Message message, int maxFaultSize)
|
|
{
|
|
if (message.Version != MessageVersion.None || message.IsEmpty)
|
|
{
|
|
return false;
|
|
}
|
|
HttpResponseMessageProperty prop = message.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty;
|
|
if (prop == null || prop.StatusCode != HttpStatusCode.InternalServerError)
|
|
{
|
|
return false;
|
|
}
|
|
using (MessageBuffer buffer = message.CreateBufferedCopy(maxFaultSize))
|
|
{
|
|
message.Close();
|
|
message = buffer.CreateMessage();
|
|
using (Message copy = buffer.CreateMessage())
|
|
{
|
|
using (XmlDictionaryReader reader = copy.GetReaderAtBodyContents())
|
|
{
|
|
return reader.IsStartElement(XD.MessageDictionary.Fault, MessageVersion.None.Envelope.DictionaryNamespace);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ProxyBehaviorCollection<T> : SynchronizedCollection<T>
|
|
{
|
|
ClientRuntime outer;
|
|
|
|
internal ProxyBehaviorCollection(ClientRuntime outer)
|
|
: base(outer.ThisLock)
|
|
{
|
|
this.outer = outer;
|
|
}
|
|
|
|
protected override void ClearItems()
|
|
{
|
|
this.outer.InvalidateRuntime();
|
|
base.ClearItems();
|
|
}
|
|
|
|
protected override void InsertItem(int index, T item)
|
|
{
|
|
if (item == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
}
|
|
|
|
this.outer.InvalidateRuntime();
|
|
base.InsertItem(index, item);
|
|
}
|
|
|
|
protected override void RemoveItem(int index)
|
|
{
|
|
this.outer.InvalidateRuntime();
|
|
base.RemoveItem(index);
|
|
}
|
|
|
|
protected override void SetItem(int index, T item)
|
|
{
|
|
if (item == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
}
|
|
|
|
this.outer.InvalidateRuntime();
|
|
base.SetItem(index, item);
|
|
}
|
|
}
|
|
|
|
class OperationCollection : SynchronizedKeyedCollection<string, ClientOperation>
|
|
{
|
|
ClientRuntime outer;
|
|
|
|
internal OperationCollection(ClientRuntime outer)
|
|
: base(outer.ThisLock)
|
|
{
|
|
this.outer = outer;
|
|
}
|
|
|
|
protected override void ClearItems()
|
|
{
|
|
this.outer.InvalidateRuntime();
|
|
base.ClearItems();
|
|
}
|
|
|
|
protected override string GetKeyForItem(ClientOperation item)
|
|
{
|
|
return item.Name;
|
|
}
|
|
|
|
protected override void InsertItem(int index, ClientOperation item)
|
|
{
|
|
if (item == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
if (item.Parent != this.outer)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SFxMismatchedOperationParent));
|
|
|
|
this.outer.InvalidateRuntime();
|
|
base.InsertItem(index, item);
|
|
}
|
|
|
|
protected override void RemoveItem(int index)
|
|
{
|
|
this.outer.InvalidateRuntime();
|
|
base.RemoveItem(index);
|
|
}
|
|
|
|
protected override void SetItem(int index, ClientOperation item)
|
|
{
|
|
if (item == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
if (item.Parent != this.outer)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SFxMismatchedOperationParent));
|
|
|
|
this.outer.InvalidateRuntime();
|
|
base.SetItem(index, item);
|
|
}
|
|
|
|
internal void InternalClearItems() { this.ClearItems(); }
|
|
internal string InternalGetKeyForItem(ClientOperation item) { return this.GetKeyForItem(item); }
|
|
internal void InternalInsertItem(int index, ClientOperation item) { this.InsertItem(index, item); }
|
|
internal void InternalRemoveItem(int index) { this.RemoveItem(index); }
|
|
internal void InternalSetItem(int index, ClientOperation item) { this.SetItem(index, item); }
|
|
}
|
|
|
|
|
|
class OperationCollectionWrapper : KeyedCollection<string, ClientOperation>
|
|
{
|
|
OperationCollection inner;
|
|
internal OperationCollectionWrapper(OperationCollection inner) { this.inner = inner; }
|
|
protected override void ClearItems() { this.inner.InternalClearItems(); }
|
|
protected override string GetKeyForItem(ClientOperation item) { return this.inner.InternalGetKeyForItem(item); }
|
|
protected override void InsertItem(int index, ClientOperation item) { this.inner.InternalInsertItem(index, item); }
|
|
protected override void RemoveItem(int index) { this.inner.InternalRemoveItem(index); }
|
|
protected override void SetItem(int index, ClientOperation item) { this.inner.InternalSetItem(index, item); }
|
|
}
|
|
|
|
}
|
|
}
|