Decompiled source of System ServiceModel Primitives v8.1.200
BepInEx/core/System.ServiceModel.Primitives/netstandard2.0/System.ServiceModel.Primitives.dll
Decompiled 2 months ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel; using System.Diagnostics; using System.Globalization; using System.IO; using System.IdentityModel.Claims; using System.IdentityModel.Policy; using System.IdentityModel.Selectors; using System.IdentityModel.Tokens; using System.Net; using System.Net.Security; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Serialization; using System.Runtime.Versioning; using System.Security; using System.Security.Cryptography; using System.Security.Cryptography.X509Certificates; using System.Security.Permissions; using System.Security.Principal; using System.ServiceModel.Channels; using System.ServiceModel.Description; using System.ServiceModel.Dispatcher; using System.ServiceModel.Security; using System.ServiceModel.Security.Tokens; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Xml; using System.Xml.Serialization; using Microsoft.CodeAnalysis; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] [assembly: AssemblyMetadata("Serviceable", "True")] [assembly: AssemblyMetadata("PreferInbox", "True")] [assembly: AssemblyDefaultAlias("System.ServiceModel.Primitives")] [assembly: CLSCompliant(true)] [assembly: AssemblyCompany("Microsoft Corporation")] [assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] [assembly: AssemblyDescription("System.ServiceModel.Primitives")] [assembly: AssemblyFileVersion("8.100.225.15402")] [assembly: AssemblyInformationalVersion("8.1.2+a47960f931a813617a061adc2ba9cabe1816a551")] [assembly: AssemblyProduct("Microsoft® .NET Core")] [assembly: AssemblyTitle("System.ServiceModel.Primitives")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/wcf")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("8.1.2.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } namespace System.ServiceModel { public class ActionNotSupportedException : CommunicationException { public ActionNotSupportedException() { } public ActionNotSupportedException(string message) { } public ActionNotSupportedException(string message, Exception innerException) { } protected ActionNotSupportedException(SerializationInfo info, StreamingContext context) { } } public enum CacheSetting { Default, AlwaysOn, AlwaysOff } public abstract class ChannelFactory : CommunicationObject, IDisposable, IChannelFactory, ICommunicationObject { public ClientCredentials Credentials => null; protected override TimeSpan DefaultCloseTimeout => default(TimeSpan); protected override TimeSpan DefaultOpenTimeout => default(TimeSpan); public ServiceEndpoint Endpoint => null; protected abstract ServiceEndpoint CreateDescription(); protected virtual IChannelFactory CreateFactory() { return null; } protected internal void EnsureOpened() { } public T GetProperty<T>() where T : class { return null; } protected void InitializeEndpoint(Binding binding, EndpointAddress address) { } protected void InitializeEndpoint(ServiceEndpoint endpoint) { } protected override void OnAbort() { } protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return null; } protected override void OnClose(TimeSpan timeout) { } protected override void OnEndClose(IAsyncResult result) { } protected override void OnEndOpen(IAsyncResult result) { } protected override void OnOpen(TimeSpan timeout) { } protected override void OnOpened() { } protected override void OnOpening() { } void IDisposable.Dispose() { } } public class ChannelFactory<TChannel> : ChannelFactory, IChannelFactory, ICommunicationObject, IChannelFactory<TChannel> { public ChannelFactory(Binding binding) { } public ChannelFactory(Binding binding, EndpointAddress remoteAddress) { } public ChannelFactory(ServiceEndpoint endpoint) { } protected ChannelFactory(Type channelType) { } public TChannel CreateChannel() { return default(TChannel); } public TChannel CreateChannel(EndpointAddress address) { return default(TChannel); } public virtual TChannel CreateChannel(EndpointAddress address, Uri via) { return default(TChannel); } protected override ServiceEndpoint CreateDescription() { return null; } } public class ChannelTerminatedException : CommunicationException { public ChannelTerminatedException() { } public ChannelTerminatedException(string message) { } public ChannelTerminatedException(string message, Exception innerException) { } protected ChannelTerminatedException(SerializationInfo info, StreamingContext context) { } } public abstract class ClientBase<TChannel> : IDisposable, ICommunicationObject where TChannel : class { protected delegate IAsyncResult BeginOperationDelegate(object[] inValues, AsyncCallback asyncCallback, object state); protected class ChannelBase<T> : IDisposable, IChannel, ICommunicationObject, IOutputChannel, IRequestChannel, IClientChannel, IContextChannel, IExtensibleObject<IContextChannel> where T : class { EndpointAddress IOutputChannel.RemoteAddress => null; Uri IOutputChannel.Via => null; EndpointAddress IRequestChannel.RemoteAddress => null; Uri IRequestChannel.Via => null; bool IClientChannel.AllowInitializationUI { get { return false; } set { } } bool IClientChannel.DidInteractiveInitialization => false; Uri IClientChannel.Via => null; CommunicationState ICommunicationObject.State => CommunicationState.Created; bool IContextChannel.AllowOutputBatching { get { return false; } set { } } IInputSession IContextChannel.InputSession => null; EndpointAddress IContextChannel.LocalAddress => null; TimeSpan IContextChannel.OperationTimeout { get { return default(TimeSpan); } set { } } IOutputSession IContextChannel.OutputSession => null; EndpointAddress IContextChannel.RemoteAddress => null; string IContextChannel.SessionId => null; IExtensionCollection<IContextChannel> IExtensibleObject<IContextChannel>.Extensions => null; event EventHandler<UnknownMessageReceivedEventArgs> IClientChannel.UnknownMessageReceived { add { } remove { } } event EventHandler ICommunicationObject.Closed { add { } remove { } } event EventHandler ICommunicationObject.Closing { add { } remove { } } event EventHandler ICommunicationObject.Faulted { add { } remove { } } event EventHandler ICommunicationObject.Opened { add { } remove { } } event EventHandler ICommunicationObject.Opening { add { } remove { } } protected ChannelBase(ClientBase<T> client) { } protected IAsyncResult BeginInvoke(string methodName, object[] args, AsyncCallback callback, object state) { return null; } protected object EndInvoke(string methodName, object[] args, IAsyncResult result) { return null; } void IDisposable.Dispose() { } TProperty IChannel.GetProperty<TProperty>() { return null; } IAsyncResult IOutputChannel.BeginSend(Message message, AsyncCallback callback, object state) { return null; } IAsyncResult IOutputChannel.BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state) { return null; } void IOutputChannel.EndSend(IAsyncResult result) { } void IOutputChannel.Send(Message message) { } void IOutputChannel.Send(Message message, TimeSpan timeout) { } IAsyncResult IRequestChannel.BeginRequest(Message message, AsyncCallback callback, object state) { return null; } IAsyncResult IRequestChannel.BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state) { return null; } Message IRequestChannel.EndRequest(IAsyncResult result) { return null; } Message IRequestChannel.Request(Message message) { return null; } Message IRequestChannel.Request(Message message, TimeSpan timeout) { return null; } [EditorBrowsable(EditorBrowsableState.Never)] IAsyncResult IClientChannel.BeginDisplayInitializationUI(AsyncCallback callback, object state) { return null; } [EditorBrowsable(EditorBrowsableState.Never)] void IClientChannel.DisplayInitializationUI() { } [EditorBrowsable(EditorBrowsableState.Never)] void IClientChannel.EndDisplayInitializationUI(IAsyncResult result) { } void ICommunicationObject.Abort() { } IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state) { return null; } IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state) { return null; } IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return null; } void ICommunicationObject.Close() { } void ICommunicationObject.Close(TimeSpan timeout) { } void ICommunicationObject.EndClose(IAsyncResult result) { } void ICommunicationObject.EndOpen(IAsyncResult result) { } void ICommunicationObject.Open() { } void ICommunicationObject.Open(TimeSpan timeout) { } } protected delegate object[] EndOperationDelegate(IAsyncResult result); protected class InvokeAsyncCompletedEventArgs : AsyncCompletedEventArgs { public object[] Results => null; internal InvokeAsyncCompletedEventArgs() : base(null, cancelled: false, null) { } } protected TChannel Channel => null; public static CacheSetting CacheSetting { get { return CacheSetting.Default; } set { } } public ChannelFactory<TChannel> ChannelFactory => null; public ClientCredentials ClientCredentials => null; public ServiceEndpoint Endpoint => null; public IClientChannel InnerChannel => null; public CommunicationState State => CommunicationState.Created; event EventHandler ICommunicationObject.Closed { add { } remove { } } event EventHandler ICommunicationObject.Closing { add { } remove { } } event EventHandler ICommunicationObject.Faulted { add { } remove { } } event EventHandler ICommunicationObject.Opened { add { } remove { } } event EventHandler ICommunicationObject.Opening { add { } remove { } } protected ClientBase() { } protected ClientBase(Binding binding, EndpointAddress remoteAddress) { } protected ClientBase(ServiceEndpoint endpoint) { } public void Abort() { } public void Close() { } public void Open() { } protected virtual TChannel CreateChannel() { return null; } protected T GetDefaultValueForInitialization<T>() { return default(T); } protected void InvokeAsync(BeginOperationDelegate beginOperationDelegate, object[] inValues, EndOperationDelegate endOperationDelegate, SendOrPostCallback operationCompletedCallback, object userState) { } IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state) { return null; } IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state) { return null; } IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return null; } void ICommunicationObject.Close() { } void ICommunicationObject.Close(TimeSpan timeout) { } void ICommunicationObject.EndClose(IAsyncResult result) { } void ICommunicationObject.EndOpen(IAsyncResult result) { } void ICommunicationObject.Open() { } void ICommunicationObject.Open(TimeSpan timeout) { } void IDisposable.Dispose() { } } public class ClientCredentialsSecurityTokenManager : SecurityTokenManager { public ClientCredentials ClientCredentials => null; public ClientCredentialsSecurityTokenManager(ClientCredentials clientCredentials) { } public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement) { return null; } public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version) { return null; } public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver) { outOfBandTokenResolver = null; return null; } } public class CommunicationException : Exception { public CommunicationException() { } public CommunicationException(string message) { } public CommunicationException(string message, Exception innerException) { } protected CommunicationException(SerializationInfo info, StreamingContext context) { } } public class CommunicationObjectAbortedException : CommunicationException { public CommunicationObjectAbortedException() { } public CommunicationObjectAbortedException(string message) { } public CommunicationObjectAbortedException(string message, Exception innerException) { } protected CommunicationObjectAbortedException(SerializationInfo info, StreamingContext context) { } } public class CommunicationObjectFaultedException : CommunicationException { public CommunicationObjectFaultedException() { } public CommunicationObjectFaultedException(string message) { } public CommunicationObjectFaultedException(string message, Exception innerException) { } protected CommunicationObjectFaultedException(SerializationInfo info, StreamingContext context) { } } public enum CommunicationState { Closed = 4, Closing = 3, Created = 0, Faulted = 5, Opened = 2, Opening = 1 } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)] public sealed class DataContractFormatAttribute : Attribute { public OperationFormatStyle Style { get { return OperationFormatStyle.Document; } set { } } } public sealed class DeliveryRequirementsAttribute : Attribute, IContractBehavior { public QueuedDeliveryRequirementsMode QueuedDeliveryRequirements { get; set; } public bool RequireOrderedDelivery { get; set; } void IContractBehavior.AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { } void IContractBehavior.ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime) { } void IContractBehavior.ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime) { } void IContractBehavior.Validate(ContractDescription contractDescription, ServiceEndpoint endpoint) { } } public class EndpointAddress { public static Uri AnonymousUri => null; public AddressHeaderCollection Headers => null; public EndpointIdentity Identity => null; public bool IsAnonymous => false; public bool IsNone => false; public static Uri NoneUri => null; public Uri Uri => null; public EndpointAddress(string uri) { } public EndpointAddress(Uri uri, params AddressHeader[] addressHeaders) { } public EndpointAddress(Uri uri, EndpointIdentity identity, params AddressHeader[] addressHeaders) { } public void ApplyTo(Message message) { } public override bool Equals(object obj) { return false; } public override int GetHashCode() { return 0; } public static bool operator ==(EndpointAddress address1, EndpointAddress address2) { return false; } public static bool operator !=(EndpointAddress address1, EndpointAddress address2) { return false; } public static EndpointAddress ReadFrom(AddressingVersion addressingVersion, XmlDictionaryReader reader) { return null; } public override string ToString() { return null; } public void WriteContentsTo(AddressingVersion addressingVersion, XmlDictionaryWriter writer) { } } public class EndpointAddressBuilder { public Collection<AddressHeader> Headers => null; public EndpointIdentity Identity { get { return null; } set { } } public Uri Uri { get { return null; } set { } } public EndpointAddressBuilder() { } public EndpointAddressBuilder(EndpointAddress address) { } public EndpointAddress ToEndpointAddress() { return null; } } public abstract class EndpointIdentity { public Claim IdentityClaim => null; protected void Initialize(Claim identityClaim) { } protected void Initialize(Claim identityClaim, IEqualityComparer<Claim> claimComparer) { } public override bool Equals(object obj) { return false; } public override int GetHashCode() { return 0; } public override string ToString() { return null; } public static EndpointIdentity CreateIdentity(Claim identity) { return null; } } public class EndpointNotFoundException : CommunicationException { public EndpointNotFoundException(string message) { } public EndpointNotFoundException(string message, Exception innerException) { } protected EndpointNotFoundException(SerializationInfo info, StreamingContext context) { } } public sealed class EnvelopeVersion { public string NextDestinationActorValue => null; public static EnvelopeVersion None => null; public static EnvelopeVersion Soap11 => null; public static EnvelopeVersion Soap12 => null; internal EnvelopeVersion() { } public string[] GetUltimateDestinationActorValues() { return null; } public override string ToString() { return null; } } [DataContract] public class ExceptionDetail { [DataMember] public string HelpLink { get { return null; } set { } } [DataMember] public ExceptionDetail InnerException { get { return null; } set { } } [DataMember] public string Message { get { return null; } set { } } [DataMember] public string StackTrace { get { return null; } set { } } [DataMember] public string Type { get { return null; } set { } } public ExceptionDetail(Exception exception) { } public override string ToString() { return null; } } public sealed class ExtensionCollection<T> : SynchronizedCollection<IExtension<T>>, IExtensionCollection<T>, ICollection<IExtension<T>>, IEnumerable<IExtension<T>>, IEnumerable where T : IExtensibleObject<T> { public ExtensionCollection(T owner) { } public ExtensionCollection(T owner, object syncRoot) : base(syncRoot) { } protected override void ClearItems() { } public E Find<E>() { return default(E); } public Collection<E> FindAll<E>() { return null; } protected override void InsertItem(int index, IExtension<T> item) { } protected override void RemoveItem(int index) { } protected override void SetItem(int index, IExtension<T> item) { } } public class FaultCode { public bool IsPredefinedFault => false; public bool IsReceiverFault => false; public bool IsSenderFault => false; public string Name => null; public string Namespace => null; public FaultCode SubCode => null; public FaultCode(string name) { } public FaultCode(string name, FaultCode subCode) { } public FaultCode(string name, string ns) { } public FaultCode(string name, string ns, FaultCode subCode) { } public static FaultCode CreateSenderFaultCode(FaultCode subCode) { return null; } } [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)] public sealed class FaultContractAttribute : Attribute { public string Action { get { return null; } set { } } public Type DetailType => null; public string Name { get { return null; } set { } } public string Namespace { get { return null; } set { } } public FaultContractAttribute(Type detailType) { } } [Serializable] public class FaultException : CommunicationException { public string Action => null; public FaultCode Code => null; public override string Message => null; public FaultReason Reason => null; public FaultException() { } public FaultException(string reason) { } public FaultException(MessageFault fault, string action) { } public FaultException(FaultReason reason, FaultCode code, string action) { } protected FaultException(SerializationInfo info, StreamingContext context) { } public static FaultException CreateFault(MessageFault messageFault, string action, params Type[] faultDetailTypes) { return null; } public static FaultException CreateFault(MessageFault messageFault, params Type[] faultDetailTypes) { return null; } public virtual MessageFault CreateMessageFault() { return null; } } [Serializable] public class FaultException<TDetail> : FaultException { public TDetail Detail => default(TDetail); public FaultException(TDetail detail) { } public FaultException(TDetail detail, FaultReason reason) { } public FaultException(TDetail detail, FaultReason reason, FaultCode code, string action) { } public FaultException(TDetail detail, FaultReason reason, FaultCode code) { } public FaultException(TDetail detail, string reason) { } public FaultException(TDetail detail, string reason, FaultCode code) { } public FaultException(TDetail detail, string reason, FaultCode code, string action) { } protected FaultException(SerializationInfo info, StreamingContext context) { } public override MessageFault CreateMessageFault() { return null; } public override string ToString() { return null; } } public class FaultReason { public FaultReason(IEnumerable<FaultReasonText> translations) { } public FaultReason(FaultReasonText translation) { } public FaultReason(string text) { } public FaultReasonText GetMatchingTranslation() { return null; } public FaultReasonText GetMatchingTranslation(CultureInfo cultureInfo) { return null; } public override string ToString() { return null; } } public class FaultReasonText { public string Text => null; public string XmlLang => null; public FaultReasonText(string text) { } public FaultReasonText(string text, string xmlLang) { } public bool Matches(CultureInfo cultureInfo) { return false; } } public enum HostNameComparisonMode { StrongWildcard, Exact, WeakWildcard } public interface IClientChannel : IDisposable, IChannel, ICommunicationObject, IContextChannel, IExtensibleObject<IContextChannel> { bool AllowInitializationUI { get; set; } bool DidInteractiveInitialization { get; } Uri Via { get; } event EventHandler<UnknownMessageReceivedEventArgs> UnknownMessageReceived; IAsyncResult BeginDisplayInitializationUI(AsyncCallback callback, object state); void DisplayInitializationUI(); void EndDisplayInitializationUI(IAsyncResult result); } public interface ICommunicationObject { CommunicationState State { get; } event EventHandler Closed; event EventHandler Closing; event EventHandler Faulted; event EventHandler Opened; event EventHandler Opening; void Abort(); IAsyncResult BeginClose(AsyncCallback callback, object state); IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state); IAsyncResult BeginOpen(AsyncCallback callback, object state); IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state); void Close(); void Close(TimeSpan timeout); void EndClose(IAsyncResult result); void EndOpen(IAsyncResult result); void Open(); void Open(TimeSpan timeout); } public interface IContextChannel : IChannel, ICommunicationObject, IExtensibleObject<IContextChannel> { bool AllowOutputBatching { get; set; } IInputSession InputSession { get; } EndpointAddress LocalAddress { get; } TimeSpan OperationTimeout { get; set; } IOutputSession OutputSession { get; } EndpointAddress RemoteAddress { get; } string SessionId { get; } } public interface IDefaultCommunicationTimeouts { TimeSpan CloseTimeout { get; } TimeSpan OpenTimeout { get; } TimeSpan ReceiveTimeout { get; } TimeSpan SendTimeout { get; } } public interface IExtensibleObject<T> where T : IExtensibleObject<T> { IExtensionCollection<T> Extensions { get; } } public interface IExtension<T> where T : IExtensibleObject<T> { void Attach(T owner); void Detach(T owner); } public interface IExtensionCollection<T> : ICollection<IExtension<T>>, IEnumerable<IExtension<T>>, IEnumerable where T : IExtensibleObject<T> { E Find<E>(); Collection<E> FindAll<E>(); } public class InvalidMessageContractException : Exception { public InvalidMessageContractException() { } public InvalidMessageContractException(string message) { } public InvalidMessageContractException(string message, Exception innerException) { } protected InvalidMessageContractException(SerializationInfo info, StreamingContext context) { } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)] public class MessageHeaderAttribute : MessageContractMemberAttribute { public bool MustUnderstand { get { return false; } set { } } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)] public sealed class MessageHeaderArrayAttribute : MessageHeaderAttribute { } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, Inherited = false)] public class MessageBodyMemberAttribute : MessageContractMemberAttribute { public int Order { get { return 0; } set { } } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)] public sealed class MessageContractAttribute : Attribute { public bool IsWrapped { get { return false; } set { } } public string WrapperName { get { return null; } set { } } public string WrapperNamespace { get { return null; } set { } } } public abstract class MessageContractMemberAttribute : Attribute { public string Name { get { return null; } set { } } public string Namespace { get { return null; } set { } } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)] public sealed class MessagePropertyAttribute : Attribute { public string Name { get { return null; } set { } } } public enum MessageCredentialType { Certificate = 3, IssuedToken = 4, None = 0, UserName = 2, Windows = 1 } public class MessageHeader<T> { public string Actor { get { return null; } set { } } public T Content { get { return default(T); } set { } } public bool MustUnderstand { get { return false; } set { } } public bool Relay { get { return false; } set { } } public MessageHeader() { } public MessageHeader(T content) { } public MessageHeader(T content, bool mustUnderstand, string actor, bool relay) { } public MessageHeader GetUntypedHeader(string name, string ns) { return null; } } public class MessageHeaderException : ProtocolException { public string HeaderName => null; public string HeaderNamespace => null; public bool IsDuplicate => false; public MessageHeaderException(string message) : base(null) { } public MessageHeaderException(string message, bool isDuplicate) : base(null) { } public MessageHeaderException(string message, Exception innerException) : base(null) { } public MessageHeaderException(string message, string headerName, string ns) : base(null) { } public MessageHeaderException(string message, string headerName, string ns, bool isDuplicate) : base(null) { } public MessageHeaderException(string message, string headerName, string ns, bool isDuplicate, Exception innerException) : base(null) { } public MessageHeaderException(string message, string headerName, string ns, Exception innerException) : base(null) { } protected MessageHeaderException(SerializationInfo info, StreamingContext context) : base(info, context) { } } [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)] public sealed class MessageParameterAttribute : Attribute { public string Name { get { return null; } set { } } } public sealed class OperationContext : IExtensibleObject<OperationContext> { public static OperationContext Current { get { return null; } set { } } public IExtensionCollection<OperationContext> Extensions => null; public MessageHeaders IncomingMessageHeaders => null; public MessageProperties IncomingMessageProperties => null; public MessageVersion IncomingMessageVersion => null; public bool IsUserContext => false; public MessageHeaders OutgoingMessageHeaders => null; public MessageProperties OutgoingMessageProperties => null; public RequestContext RequestContext { get { return null; } set { } } public IContextChannel Channel => null; public event EventHandler OperationCompleted { add { } remove { } } public OperationContext(IContextChannel channel) { } public T GetCallbackChannel<T>() { return default(T); } } public sealed class OperationContextScope : IDisposable { public OperationContextScope(IContextChannel channel) { } public OperationContextScope(OperationContext context) { } public void Dispose() { } } [AttributeUsage(AttributeTargets.Method)] public sealed class OperationContractAttribute : Attribute { public string Action { get { return null; } set { } } public bool AsyncPattern { get { return false; } set { } } public bool IsInitiating { get { return false; } set { } } public bool IsTerminating { get { return false; } set { } } public bool IsOneWay { get { return false; } set { } } public string Name { get { return null; } set { } } public string ReplyAction { get { return null; } set { } } } public enum OperationFormatStyle { Document, Rpc } public enum OperationFormatUse { Literal, Encoded } public class OptionalReliableSession : ReliableSession { public bool Enabled { get; set; } public OptionalReliableSession() { } public OptionalReliableSession(ReliableSessionBindingElement reliableSessionBindingElement) { } } public class ProtocolException : CommunicationException { public ProtocolException(string message) { } public ProtocolException(string message, Exception innerException) { } protected ProtocolException(SerializationInfo info, StreamingContext context) { } } public enum QueuedDeliveryRequirementsMode { Allowed, Required, NotAllowed } public class QuotaExceededException : Exception { public QuotaExceededException(string message) { } public QuotaExceededException(string message, Exception innerException) { } protected QuotaExceededException(SerializationInfo info, StreamingContext context) { } } public abstract class ReliableMessagingVersion { public static ReliableMessagingVersion Default => null; public static ReliableMessagingVersion WSReliableMessaging11 => null; public static ReliableMessagingVersion WSReliableMessagingFebruary2005 => null; internal ReliableMessagingVersion(string ns, XmlDictionaryString dictionaryNs) { } } public class ReliableSession { public bool Ordered { get; set; } public TimeSpan InactivityTimeout { get; set; } public ReliableSession() { } public ReliableSession(ReliableSessionBindingElement reliableSessionBindingElement) { } } public enum SecurityMode { Message = 2, None = 0, Transport = 1, TransportWithMessageCredential = 3 } public class ServerTooBusyException : CommunicationException { public ServerTooBusyException(string message) { } public ServerTooBusyException(string message, Exception innerException) { } protected ServerTooBusyException(SerializationInfo info, StreamingContext context) { } } public class ServiceActivationException : CommunicationException { public ServiceActivationException(string message) { } public ServiceActivationException(string message, Exception innerException) { } protected ServiceActivationException(SerializationInfo info, StreamingContext context) { } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)] public sealed class ServiceContractAttribute : Attribute { public Type CallbackContract { get { return null; } set { } } public string ConfigurationName { get { return null; } set { } } public string Name { get { return null; } set { } } public string Namespace { get { return null; } set { } } public SessionMode SessionMode { get { return SessionMode.Allowed; } set { } } } public enum SessionMode { Allowed, Required, NotAllowed } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface, Inherited = true, AllowMultiple = true)] public sealed class ServiceKnownTypeAttribute : Attribute { public Type DeclaringType => null; public string MethodName => null; public Type Type => null; public ServiceKnownTypeAttribute(string methodName) { } public ServiceKnownTypeAttribute(string methodName, Type declaringType) { } public ServiceKnownTypeAttribute(Type type) { } } public enum TransferMode { Buffered, Streamed, StreamedRequest, StreamedResponse } public sealed class UnknownMessageReceivedEventArgs : EventArgs { public Message Message => null; internal UnknownMessageReceivedEventArgs() { } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)] public sealed class XmlSerializerFormatAttribute : Attribute { public OperationFormatStyle Style { get { return OperationFormatStyle.Document; } set { } } public bool SupportFaults { get { return false; } set { } } public OperationFormatUse Use { get { throw null; } set { } } } public sealed class InstanceContext : CommunicationObject, IExtensibleObject<InstanceContext> { protected override TimeSpan DefaultCloseTimeout => default(TimeSpan); protected override TimeSpan DefaultOpenTimeout => default(TimeSpan); public SynchronizationContext SynchronizationContext { get { return null; } set { } } public IExtensionCollection<InstanceContext> Extensions => null; public InstanceContext(object implementation) { } public object GetServiceInstance(Message message) { return null; } protected override void OnAbort() { } protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return null; } protected override void OnClose(TimeSpan timeout) { } protected override void OnClosed() { } protected override void OnEndClose(IAsyncResult result) { } protected override void OnEndOpen(IAsyncResult result) { } protected override void OnFaulted() { } protected override void OnOpen(TimeSpan timeout) { } protected override void OnOpened() { } protected override void OnOpening() { } } public class DnsEndpointIdentity : EndpointIdentity { public DnsEndpointIdentity(string dnsName) { } } public abstract class MessageSecurityVersion { public abstract BasicSecurityProfileVersion BasicSecurityProfileVersion { get; } public SecureConversationVersion SecureConversationVersion => null; public abstract SecurityPolicyVersion SecurityPolicyVersion { get; } public SecurityVersion SecurityVersion => null; public TrustVersion TrustVersion => null; public static MessageSecurityVersion WSSecurity10WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10 => null; public static MessageSecurityVersion WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11 => null; public static MessageSecurityVersion WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10 => null; public static MessageSecurityVersion WSSecurity11WSTrust13WSSecureConversation13WSSecurityPolicy12BasicSecurityProfile10 => null; internal MessageSecurityVersion() { } } public class ServiceSecurityContext { public static ServiceSecurityContext Anonymous => null; public bool IsAnonymous => false; public IIdentity PrimaryIdentity => null; public ReadOnlyCollection<IAuthorizationPolicy> AuthorizationPolicies { get; set; } public AuthorizationContext AuthorizationContext => null; public ServiceSecurityContext(ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies) { } public ServiceSecurityContext(AuthorizationContext authorizationContext) { } public ServiceSecurityContext(AuthorizationContext authorizationContext, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies) { } } public class SpnEndpointIdentity : EndpointIdentity { public static TimeSpan SpnLookupTime { get { return default(TimeSpan); } set { } } public SpnEndpointIdentity(string spnName) { } } public class UpnEndpointIdentity : EndpointIdentity { public UpnEndpointIdentity(string upnName) { } } public class X509CertificateEndpointIdentity : EndpointIdentity { public X509Certificate2Collection Certificates { get; } public X509CertificateEndpointIdentity(X509Certificate2 certificate) { } } [AttributeUsage(AttributeTargets.Class)] public sealed class CallbackBehaviorAttribute : Attribute, IEndpointBehavior { public bool AutomaticSessionShutdown { get { return false; } set { } } public bool UseSynchronizationContext { get { return false; } set { } } public ConcurrencyMode ConcurrencyMode { get { return ConcurrencyMode.Single; } set { } } void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection parameters) { } void IEndpointBehavior.ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime clientRuntime) { } void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher) { } void IEndpointBehavior.Validate(ServiceEndpoint serviceEndpoint) { } } public enum ConcurrencyMode { Single, [Obsolete] Reentrant, Multiple } public class DuplexChannelFactory<TChannel> : ChannelFactory<TChannel> { public DuplexChannelFactory(Type callbackInstanceType) : base((Type)null) { } public DuplexChannelFactory(Type callbackInstanceType, Binding binding) : base((Type)null) { } public DuplexChannelFactory(Type callbackInstanceType, Binding binding, EndpointAddress remoteAddress) : base((Type)null) { } public DuplexChannelFactory(Type callbackInstanceType, Binding binding, string remoteAddress) : base((Type)null) { } public DuplexChannelFactory(Type callbackInstanceType, ServiceEndpoint serviceEndpoint) : base((Type)null) { } public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding) : base((Type)null) { } public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress) : base((Type)null) { } public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding, string remoteAddress) : base((Type)null) { } public override TChannel CreateChannel(EndpointAddress address, Uri via) { return default(TChannel); } public TChannel CreateChannel(InstanceContext callbackInstance) { return default(TChannel); } public TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address) { return default(TChannel); } public virtual TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address, Uri via) { return default(TChannel); } } public abstract class DuplexClientBase<TChannel> : ClientBase<TChannel> where TChannel : class { protected DuplexClientBase(InstanceContext callbackInstance) { } protected DuplexClientBase(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress) { } } } namespace System.ServiceModel.Security { public sealed class HttpDigestClientCredential { public NetworkCredential ClientCredential { get { return null; } set { } } internal HttpDigestClientCredential() { } } public interface ISecuritySession : ISession { EndpointIdentity RemoteIdentity { get; } } public class MessageSecurityException : CommunicationException { public MessageSecurityException(string message) { } public MessageSecurityException(string message, Exception innerException) { } protected MessageSecurityException(SerializationInfo info, StreamingContext context) { } } public class SecurityAccessDeniedException : CommunicationException { public SecurityAccessDeniedException(string message) { } public SecurityAccessDeniedException(string message, Exception innerException) { } protected SecurityAccessDeniedException(SerializationInfo info, StreamingContext context) { } } public abstract class SecurityCredentialsManager { public abstract SecurityTokenManager CreateSecurityTokenManager(); } public class SecurityNegotiationException : CommunicationException { public SecurityNegotiationException() { } public SecurityNegotiationException(string message) { } public SecurityNegotiationException(string message, Exception innerException) { } protected SecurityNegotiationException(SerializationInfo info, StreamingContext context) { } } public sealed class UserNamePasswordClientCredential { public string Password { get { return null; } set { } } public string UserName { get { return null; } set { } } internal UserNamePasswordClientCredential() { } } public sealed class WindowsClientCredential { public TokenImpersonationLevel AllowedImpersonationLevel { get { return TokenImpersonationLevel.None; } set { } } public NetworkCredential ClientCredential { get { return null; } set { } } internal WindowsClientCredential() { } } public sealed class X509ServiceCertificateAuthentication { public X509CertificateValidationMode CertificateValidationMode { get { return X509CertificateValidationMode.None; } set { } } public X509CertificateValidator CustomCertificateValidator { get { return null; } set { } } public X509RevocationMode RevocationMode { get { return X509RevocationMode.NoCheck; } set { } } public StoreLocation TrustedStoreLocation { get { return (StoreLocation)0; } set { } } } public sealed class X509CertificateInitiatorClientCredential { public X509Certificate2 Certificate { get { return null; } set { } } internal X509CertificateInitiatorClientCredential() { } public void SetCertificate(StoreLocation storeLocation, StoreName storeName, X509FindType findType, object findValue) { } public void SetCertificate(string subjectName, StoreLocation storeLocation, StoreName storeName) { } } public sealed class X509CertificateRecipientClientCredential { public X509ServiceCertificateAuthentication Authentication => null; public X509Certificate2 DefaultCertificate { get { return null; } set { } } public Dictionary<Uri, X509Certificate2> ScopedCertificates => null; public X509ServiceCertificateAuthentication SslCertificateAuthentication { get { return null; } set { } } internal X509CertificateRecipientClientCredential() { } public void SetDefaultCertificate(StoreLocation storeLocation, StoreName storeName, X509FindType findType, object findValue) { } public void SetDefaultCertificate(string subjectName, StoreLocation storeLocation, StoreName storeName) { } public void SetScopedCertificate(StoreLocation storeLocation, StoreName storeName, X509FindType findType, object findValue, Uri targetService) { } public void SetScopedCertificate(string subjectName, StoreLocation storeLocation, StoreName storeName, Uri targetService) { } } public enum X509CertificateValidationMode { ChainTrust = 2, Custom = 4, None = 0, PeerOrChainTrust = 3, PeerTrust = 1 } internal interface ISecurityCommunicationObject { TimeSpan DefaultOpenTimeout { get; } TimeSpan DefaultCloseTimeout { get; } void OnAbort(); Task OnCloseAsync(TimeSpan timeout); void OnClosed(); void OnClosing(); void OnFaulted(); Task OnOpenAsync(TimeSpan timeout); void OnOpened(); void OnOpening(); } public enum SecurityKeyEntropyMode { ClientEntropy, ServerEntropy, CombinedEntropy } public abstract class BasicSecurityProfileVersion { public static BasicSecurityProfileVersion BasicSecurityProfile10 => null; internal BasicSecurityProfileVersion() { } } public abstract class IdentityVerifier { public static IdentityVerifier CreateDefault() { return null; } public abstract bool CheckAccess(EndpointIdentity identity, AuthorizationContext authContext); public abstract bool TryGetIdentity(EndpointAddress reference, out EndpointIdentity identity); } public class SecurityMessageProperty : IMessageProperty, IDisposable { public ServiceSecurityContext ServiceSecurityContext { get; set; } public ReadOnlyCollection<IAuthorizationPolicy> ExternalAuthorizationPolicies { get; set; } public SecurityTokenSpecification ProtectionToken { get; set; } public SecurityTokenSpecification InitiatorToken { get; set; } public SecurityTokenSpecification RecipientToken { get; set; } public SecurityTokenSpecification TransportToken { get; set; } public string SenderIdPrefix { get; set; } public bool HasIncomingSupportingTokens => false; public Collection<SupportingTokenSpecification> IncomingSupportingTokens => null; public Collection<SupportingTokenSpecification> OutgoingSupportingTokens => null; internal bool HasOutgoingSupportingTokens => false; public IMessageProperty CreateCopy() { return null; } public static SecurityMessageProperty GetOrCreate(Message message) { return null; } public void Dispose() { } } public abstract class SecureConversationVersion { public static SecureConversationVersion Default => null; public XmlDictionaryString Namespace => null; public XmlDictionaryString Prefix => null; public static SecureConversationVersion WSSecureConversationFeb2005 => null; public static SecureConversationVersion WSSecureConversation13 => null; internal SecureConversationVersion() { } } public abstract class SecurityAlgorithmSuite { public static SecurityAlgorithmSuite TripleDes => null; public abstract string DefaultCanonicalizationAlgorithm { get; } public abstract string DefaultDigestAlgorithm { get; } public abstract string DefaultEncryptionAlgorithm { get; } public abstract int DefaultEncryptionKeyDerivationLength { get; } public abstract string DefaultSymmetricKeyWrapAlgorithm { get; } public abstract string DefaultAsymmetricKeyWrapAlgorithm { get; } public abstract string DefaultSymmetricSignatureAlgorithm { get; } public abstract string DefaultAsymmetricSignatureAlgorithm { get; } public abstract int DefaultSignatureKeyDerivationLength { get; } public abstract int DefaultSymmetricKeyLength { get; } public static SecurityAlgorithmSuite Default { get; } public static SecurityAlgorithmSuite Basic256 { get; } public static SecurityAlgorithmSuite Basic256Sha256 { get; } public abstract bool IsSymmetricKeyLengthSupported(int length); public abstract bool IsAsymmetricKeyLengthSupported(int length); } public enum SecurityTokenAttachmentMode { Signed, Endorsing, SignedEndorsing, SignedEncrypted } public class SecurityTokenSpecification { public SecurityToken SecurityToken => null; public ReadOnlyCollection<IAuthorizationPolicy> SecurityTokenPolicies => null; public SecurityTokenSpecification(SecurityToken token, ReadOnlyCollection<IAuthorizationPolicy> tokenPolicies) { } } public abstract class SecurityPolicyVersion { public string Namespace => null; public string Prefix => null; public static SecurityPolicyVersion WSSecurityPolicy11 => null; public static SecurityPolicyVersion WSSecurityPolicy12 => null; internal SecurityPolicyVersion() { } } public abstract class SecurityVersion { public static SecurityVersion WSSecurity10 => null; public static SecurityVersion WSSecurity11 => null; internal SecurityVersion() { } } public class SupportingTokenSpecification : SecurityTokenSpecification { public SecurityTokenAttachmentMode SecurityTokenAttachmentMode => SecurityTokenAttachmentMode.Signed; public SupportingTokenSpecification(SecurityToken token, ReadOnlyCollection<IAuthorizationPolicy> tokenPolicies, SecurityTokenAttachmentMode attachmentMode) : base(null, null) { } public SupportingTokenSpecification(SecurityToken token, ReadOnlyCollection<IAuthorizationPolicy> tokenPolicies, SecurityTokenAttachmentMode attachmentMode, SecurityTokenParameters tokenParameters) : base(null, null) { } } public abstract class TrustVersion { public static TrustVersion Default => null; public XmlDictionaryString Namespace => null; public XmlDictionaryString Prefix => null; public static TrustVersion WSTrustFeb2005 => null; public static TrustVersion WSTrust13 => null; internal TrustVersion() { } } } namespace System.ServiceModel.Security.Tokens { public class BinarySecretSecurityToken : SecurityToken { public override string Id => null; public override DateTime ValidFrom => default(DateTime); public override DateTime ValidTo => default(DateTime); public int KeySize => 0; public override ReadOnlyCollection<SecurityKey> SecurityKeys => null; public BinarySecretSecurityToken(string id, byte[] key) { } public BinarySecretSecurityToken(byte[] key) { } protected BinarySecretSecurityToken(string id, int keySizeInBits, bool allowCrypto) { } protected BinarySecretSecurityToken(string id, byte[] key, bool allowCrypto) { } public byte[] GetKeyBytes() { return null; } } public sealed class InitiatorServiceModelSecurityTokenRequirement : ServiceModelSecurityTokenRequirement { public EndpointAddress TargetAddress { get { return null; } set { } } public Uri Via { get { return null; } set { } } public override string ToString() { return null; } } public class IssuedSecurityTokenParameters : SecurityTokenParameters { public Collection<XmlElement> AdditionalRequestParameters => null; public MessageSecurityVersion DefaultMessageSecurityVersion { get { return null; } set { } } public EndpointAddress IssuerAddress { get { return null; } set { } } public Binding IssuerBinding { get { return null; } set { } } public SecurityKeyType KeyType { get { return SecurityKeyType.SymmetricKey; } set { } } public int KeySize { get { return 0; } set { } } public string TokenType { get { return null; } set { } } protected IssuedSecurityTokenParameters(IssuedSecurityTokenParameters other) { } public IssuedSecurityTokenParameters() { } protected override SecurityTokenParameters CloneCore() { return null; } } public class SecureConversationSecurityTokenParameters : SecurityTokenParameters { public SecurityBindingElement BootstrapSecurityBindingElement { get { return null; } set { } } public bool RequireCancellation { get { return false; } set { } } public SecureConversationSecurityTokenParameters() { } public SecureConversationSecurityTokenParameters(SecurityBindingElement bootstrapSecurityBindingElement) { } protected override SecurityTokenParameters CloneCore() { return null; } } public abstract class SecurityTokenParameters { public bool RequireDerivedKeys { get { return false; } set { } } internal SecurityTokenParameters() { } protected abstract SecurityTokenParameters CloneCore(); public SecurityTokenParameters Clone() { return null; } } public abstract class ServiceModelSecurityTokenRequirement : SecurityTokenRequirement { public bool IsInitiator => false; public SecurityAlgorithmSuite SecurityAlgorithmSuite { get { return null; } set { } } public SecurityBindingElement SecurityBindingElement { get { return null; } set { } } public EndpointAddress IssuerAddress { get { return null; } set { } } public Binding IssuerBinding { get { return null; } set { } } public SecurityBindingElement SecureConversationSecurityBindingElement { get { return null; } set { } } public SecurityTokenVersion MessageSecurityVersion { get { return null; } set { } } public string TransportScheme { get { return null; } set { } } public static string ChannelParametersCollectionProperty => null; } public class SspiSecurityToken : SecurityToken { public override string Id => null; public override DateTime ValidFrom => default(DateTime); public override DateTime ValidTo => default(DateTime); public bool AllowUnauthenticatedCallers => false; public TokenImpersonationLevel ImpersonationLevel => TokenImpersonationLevel.None; public bool AllowNtlm => false; public NetworkCredential NetworkCredential => null; public bool ExtractGroupsForWindowsAccounts => false; public override ReadOnlyCollection<SecurityKey> SecurityKeys => null; public SspiSecurityToken(TokenImpersonationLevel impersonationLevel, bool allowNtlm, NetworkCredential networkCredential) { } public SspiSecurityToken(NetworkCredential networkCredential, bool extractGroupsForWindowsAccounts, bool allowUnauthenticatedCallers) { } } public class SupportingTokenParameters { public Collection<SecurityTokenParameters> Endorsing => null; public Collection<SecurityTokenParameters> SignedEncrypted => null; public Collection<SecurityTokenParameters> Signed => null; public SupportingTokenParameters Clone() { return null; } } public class UserNameSecurityTokenParameters : SecurityTokenParameters { protected override SecurityTokenParameters CloneCore() { return null; } } } namespace System.ServiceModel.Dispatcher { public sealed class ClientOperation { public string Action => null; public SynchronizedCollection<FaultContractInfo> FaultContractInfos => null; public ICollection<IParameterInspector> ClientParameterInspectors => null; public bool DeserializeReply { get { return false; } set { } } public IClientMessageFormatter Formatter { get { return null; } set { } } public bool IsOneWay { get { return false; } set { } } public string Name => null; public ClientRuntime Parent => null; public string ReplyAction => null; public bool SerializeRequest { get { return false; } set { } } public MethodInfo TaskMethod { get { return null; } set { } } public Type TaskTResult { get { return null; } set { } } public MethodInfo BeginMethod { get { return null; } set { } } public MethodInfo EndMethod { get { return null; } set { } } public MethodInfo SyncMethod { get { return null; } set { } } public ClientOperation(ClientRuntime parent, string name, string action) { } public ClientOperation(ClientRuntime parent, string name, string action, string replyAction) { } } public sealed class ClientRuntime { public SynchronizedCollection<IChannelInitializer> ChannelInitializers => null; public ICollection<IClientMessageInspector> ClientMessageInspectors => null; public DispatchRuntime CallbackDispatchRuntime => null; public ICollection<ClientOperation> ClientOperations => null; public Type ContractClientType { get { return null; } set { } } public string ContractName => null; public string ContractNamespace => null; public SynchronizedCollection<IInteractiveChannelInitializer> InteractiveChannelInitializers => null; public bool ManualAddressing { get { return false; } set { } } public int MaxFaultSize { get { return 0; } set { } } public IClientOperationSelector OperationSelector { get { return null; } set { } } public ClientOperation UnhandledClientOperation => null; public Uri Via { get { return null; } set { } } internal ClientRuntime() { } } public sealed class DispatchOperation { public string Action => null; public bool AutoDisposeParameters { get { return false; } set { } } public bool DeserializeRequest { get { return false; } set { } } public bool IsOneWay => false; public string Name => null; public DispatchRuntime Parent => null; public bool SerializeReply { get { return false; } set { } } public DispatchOperation(DispatchRuntime parent, string name, string action) { } } public sealed class DispatchRuntime { public SynchronizedCollection<IDispatchMessageInspector> MessageInspectors => null; public ChannelDispatcher ChannelDispatcher => null; internal DispatchRuntime() { } } public class ChannelDispatcher { public bool IncludeExceptionDetailInFaults { get { return false; } set { } } internal ChannelDispatcher() { } } public class EndpointDispatcher { internal EndpointDispatcher() { } } public class FaultContractInfo { public string Action => null; public Type Detail => null; public FaultContractInfo(string action, Type detail) { } } public interface IChannelInitializer { void Initialize(IClientChannel channel); } public interface IClientMessageFormatter { object DeserializeReply(Message message, object[] parameters); Message SerializeRequest(MessageVersion messageVersion, object[] parameters); } public interface IClientMessageInspector { void AfterReceiveReply(ref Message reply, object correlationState); object BeforeSendRequest(ref Message request, IClientChannel channel); } public interface IDispatchMessageInspector { object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext); void BeforeSendReply(ref Message reply, object correlationState); } public interface IClientOperationSelector { bool AreParametersRequiredForSelection { get; } string SelectOperation(MethodBase method, object[] parameters); } public interface IInteractiveChannelInitializer { IAsyncResult BeginDisplayInitializationUI(IClientChannel channel, AsyncCallback callback, object state); void EndDisplayInitializationUI(IAsyncResult result); } public interface IParameterInspector { void AfterCall(string operationName, object[] outputs, object returnValue, object correlationState); object BeforeCall(string operationName, object[] inputs); } } namespace System.ServiceModel.Description { public class CallbackDebugBehavior : IEndpointBehavior { public bool IncludeExceptionDetailInFaults { get { return false; } set { } } public CallbackDebugBehavior(bool includeExceptionDetailInFaults) { } void IEndpointBehavior.ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime behavior) { } void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection bindingParameters) { } void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher) { } void IEndpointBehavior.Validate(ServiceEndpoint serviceEndpoint) { } } public class ClientCredentials : SecurityCredentialsManager, IEndpointBehavior { public X509CertificateInitiatorClientCredential ClientCertificate => null; public HttpDigestClientCredential HttpDigest => null; public X509CertificateRecipientClientCredential ServiceCertificate => null; public UserNamePasswordClientCredential UserName => null; public WindowsClientCredential Windows => null; public ClientCredentials() { } protected ClientCredentials(ClientCredentials other) { } public override SecurityTokenManager CreateSecurityTokenManager() { return null; } public virtual void ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime behavior) { } public ClientCredentials Clone() { return null; } protected virtual ClientCredentials CloneCore() { return null; } void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection bindingParameters) { } void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher) { } void IEndpointBehavior.Validate(ServiceEndpoint serviceEndpoint) { } } public class ContractDescription { public Type CallbackContractType { get { return null; } set { } } [DefaultValue(null)] public string ConfigurationName { get { return null; } set { } } public KeyedCollection<Type, IContractBehavior> ContractBehaviors => null; public Type ContractType { get { return null; } set { } } public string Name { get { return null; } set { } } public string Namespace { get { return null; } set { } } public OperationDescriptionCollection Operations => null; public ContractDescription(string name) { } public ContractDescription(string name, string ns) { } public static ContractDescription GetContract(Type contractType) { return null; } } public class DataContractSerializerOperationBehavior : IOperationBehavior { public DataContractFormatAttribute DataContractFormatAttribute => null; public DataContractResolver DataContractResolver { get { return null; } set { } } public int MaxItemsInObjectGraph { get { return 0; } set { } } public DataContractSerializerOperationBehavior(OperationDescription operation) { } public DataContractSerializerOperationBehavior(OperationDescription operation, DataContractFormatAttribute dataContractFormatAttribute) { } public virtual XmlObjectSerializer CreateSerializer(Type type, string name, string ns, IList<Type> knownTypes) { return null; } public virtual XmlObjectSerializer CreateSerializer(Type type, XmlDictionaryString name, XmlDictionaryString ns, IList<Type> knownTypes) { return null; } void IOperationBehavior.AddBindingParameters(OperationDescription description, BindingParameterCollection parameters) { } void IOperationBehavior.ApplyClientBehavior(OperationDescription description, ClientOperation proxy) { } void IOperationBehavior.ApplyDispatchBehavior(OperationDescription description, DispatchOperation dispatch) { } void IOperationBehavior.Validate(OperationDescription description) { } } public class FaultDescription { public string Action => null; public Type DetailType { get { return null; } set { } } public string Name { get { return null; } set { } } public string Namespace { get { return null; } set { } } public FaultDescription(string action) { } } public class FaultDescriptionCollection : Collection<FaultDescription> { internal FaultDescriptionCollection() { } } public interface IContractBehavior { void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters); void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime); void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime); void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint); } public interface IEndpointBehavior { void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters); void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime); void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher); void Validate(ServiceEndpoint endpoint); } public interface IOperationBehavior { void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters); void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation); void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation); void Validate(OperationDescription operationDescription); } public class MessageBodyDescription { public MessagePartDescriptionCollection Parts => null; [DefaultValue(null)] public MessagePartDescription ReturnValue { get { return null; } set { } } [DefaultValue(null)] public string WrapperName { get { return null; } set { } } [DefaultValue(null)] public string WrapperNamespace { get { return null; } set { } } } public class MessageDescription { public string Action => null; public MessageBodyDescription Body => null; public MessageDirection Direction => MessageDirection.Input; public MessageHeaderDescriptionCollection Headers => null; [DefaultValue(null)] public Type MessageType { get { return null; } set { } } public MessagePropertyDescriptionCollection Properties => null; public MessageDescription(string action, MessageDirection direction) { } } public class MessageDescriptionCollection : Collection<MessageDescription> { internal MessageDescriptionCollection() { } public MessageDescription Find(string action) { return null; } public Collection<MessageDescription> FindAll(string action) { return null; } } public enum MessageDirection { Input, Output } public class MessageHeaderDescription : MessagePartDescription { [DefaultValue(null)] public string Actor { get { return null; } set { } } [DefaultValue(false)] public bool MustUnderstand { get { return false; } set { } } [DefaultValue(false)] public bool Relay { get { return false; } set { } } [DefaultValue(false)] public bool TypedHeader { get { return false; } set { } } public MessageHeaderDescription(string name, string ns) : base(null, null) { } } public class MessageHeaderDescriptionCollection : KeyedCollection<XmlQualifiedName, MessageHeaderDescription> { internal MessageHeaderDescriptionCollection() { } protected override XmlQualifiedName GetKeyForItem(MessageHeaderDescription item) { return null; } } public class MessagePartDescription { public int Index { get { return 0; } set { } } public MemberInfo MemberInfo { get { return null; } set { } } [DefaultValue(false)] public bool Multiple { get { return false; } set { } } public string Name => null; public string Namespace => null; public Type Type { get { return null; } set { } } public MessagePartDescription(string name, string ns) { } } public class MessagePartDescriptionCollection : KeyedCollection<XmlQualifiedName, MessagePartDescription> { internal MessagePartDescriptionCollection() { } protected override XmlQualifiedName GetKeyForItem(MessagePartDescription item) { return null; } } public class MessagePropertyDescription : MessagePartDescription { public MessagePropertyDescription(string name) : base(null, null) { } } public class MessagePropertyDescriptionCollection : KeyedCollection<string, MessagePropertyDescription> { internal MessagePropertyDescriptionCollection() { } protected override string GetKeyForItem(MessagePropertyDescription item) { return null; } } public class OperationDescription { [EditorBrowsable(EditorBrowsableState.Never)] public KeyedByTypeCollection<IOperationBehavior> Behaviors => null; public ContractDescription DeclaringContract { get { return null; } set { } } public FaultDescriptionCollection Faults => null; public bool IsOneWay => false; public Collection<Type> KnownTypes => null; public MessageDescriptionCollection Messages => null; public string Name => null; public KeyedCollection<Type, IOperationBehavior> OperationBehaviors => null; public MethodInfo TaskMethod { get { return null; } set { } } public MethodInfo BeginMethod { get { return null; } set { } } public MethodInfo EndMethod { get { return null; } set { } } public MethodInfo SyncMethod { get { return null; } set { } } public OperationDescription(string name, ContractDescription declaringContract) { } } public class OperationDescriptionCollection : Collection<OperationDescription> { internal OperationDescriptionCollection() { } public OperationDescription Find(string name) { return null; } public Collection<OperationDescription> FindAll(string name) { return null; } protected override void InsertItem(int index, OperationDescription item) { } protected override void SetItem(int index, OperationDescription item) { } } public class ServiceEndpoint { public EndpointAddress Address { get { return null; } set { } } public Binding Binding { get { return null; } set { } } public ContractDescription Contract { get { return null; } set { } } public KeyedCollection<Type, IEndpointBehavior> EndpointBehaviors => null; public string Name { get { return null; } set { } } public ServiceEndpoint(ContractDescription contract) { } public ServiceEndpoint(ContractDescription contract, Binding binding, EndpointAddress address) { } } public class XmlSerializerOperationBehavior : IOperationBehavior { public XmlSerializerFormatAttribute XmlSerializerFormatAttribute => null; public XmlSerializerOperationBehavior(OperationDescription operation) { } public XmlSerializerOperationBehavior(OperationDescription operation, XmlSerializerFormatAttribute attribute) { } public Collection<XmlMapping> GetXmlMappings() { throw null; } void IOperationBehavior.Validate(OperationDescription description) { } void IOperationBehavior.AddBindingParameters(OperationDescription description, BindingParameterCollection parameters) { } void IOperationBehavior.ApplyDispatchBehavior(OperationDescription description, DispatchOperation dispatch) { } void IOperationBehavior.ApplyClientBehavior(OperationDescription description, ClientOperation proxy) { } } public abstract class TypedMessageConverter { public static TypedMessageConverter Create(Type messageContract, string action) { return null; } public static TypedMessageConverter Create(Type messageContract, string action, string defaultNamespace) { return null; } public static TypedMessageConverter Create(Type messageContract, string action, XmlSerializerFormatAttribute formatterAttribute) { return null; } public static TypedMessageConverter Create(Type messageContract, string action, DataContractFormatAttribute formatterAttribute) { return null; } public static TypedMessageConverter Create(Type messageContract, string action, string defaultNamespace, XmlSerializerFormatAttribute formatterAttribute) { return null; } public static TypedMessageConverter Create(Type messageContract, string action, string defaultNamespace, DataContractFormatAttribute formatterAttribute) { return null; } public abstract Message ToMessage(object typedMessage); public abstract Message ToMessage(object typedMessage, MessageVersion version); public abstract object FromMessage(Message message); } } namespace System.ServiceModel.Channels { public abstract class AddressHeader { public abstract string Name { get; } public abstract string Namespace { get; } public static AddressHeader CreateAddressHeader(string name, string ns, object value) { return null; } public static AddressHeader CreateAddressHeader(string name, string ns, object value, XmlObjectSerializer serializer) { return null; } public override bool Equals(object obj) { return false; } public virtual XmlDictionaryReader GetAddressHeaderReader() { return null; } public override int GetHashCode() { return 0; } public T GetValue<T>() { return default(T); } public T GetValue<T>(XmlObjectSerializer serializer) { return default(T); } protected abstract void OnWriteAddressHeaderContents(XmlDictionaryWriter writer); protected virtual void OnWriteStartAddressHeader(XmlDictionaryWriter writer) { } public MessageHeader ToMessageHeader() { return null; } public void WriteAddressHeader(XmlDictionaryWriter writer) { } public void WriteAddressHeader(XmlWriter writer) { } public void WriteAddressHeaderContents(XmlDictionaryWriter writer) { } public void WriteStartAddressHeader(XmlDictionaryWriter writer) { } } public sealed class AddressHeaderCollection : ReadOnlyCollection<AddressHeader> { public AddressHeaderCollection() : base((IList<AddressHeader>)null) { } public AddressHeaderCollection(IEnumerable<AddressHeader> addressHeaders) : base((IList<AddressHeader>)null) { } public void AddHeadersTo(Message message) { } public AddressHeader[] FindAll(string name, string ns) { return null; } public AddressHeader FindHeader(string name, string ns) { return null; } } public sealed class AddressingVersion { public static AddressingVersion None => null; public static AddressingVersion WSAddressing10 => null; public static AddressingVersion WSAddressingAugust2004 => null; internal AddressingVersion() { } public override string ToString() { return null; } } public sealed class BinaryMessageEncodingBindingElement : MessageEncodingBindingElement { [DefaultValue(CompressionFormat.None)] public CompressionFormat CompressionFormat { get { return CompressionFormat.None; } set { } } [DefaultValue(2048)] public int MaxSessionSize { get { return 0; } set { } } public int MaxReadPoolSize { get { return 0; } set { } } public int MaxWritePoolSize { get { return 0; } set { } } public override MessageVersion MessageVersion { get { return null; } set { } } public XmlDictionaryReaderQuotas ReaderQuotas { get { return null; } set { } } public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context) { return null; } public override BindingElement Clone() { return null; } public override MessageEncoderFactory CreateMessageEncoderFactory() { return null; } public override T GetProperty<T>(BindingContext context) { return null; } } public abstract class Binding : IDefaultCommunicationTimeouts { [DefaultValue(typeof(TimeSpan), "00:01:00")] public TimeSpan CloseTimeout { get { return default(TimeSpan); } set { } } public MessageVersion MessageVersion => null; public string Name { get { return null; } set { } } public string Namespace { get { return null; } set { } } [DefaultValue(typeof(TimeSpan), "00:01:00")] public TimeSpan OpenTimeout { get { return default(TimeSpan); } set { } } [DefaultValue(typeof(TimeSpan), "00:10:00")] public TimeSpan ReceiveTimeout { get { return default(TimeSpan); } set { } } public abstract string Scheme { get; } [DefaultValue(typeof(TimeSpan), "00:01:00")] public TimeSpan SendTimeout { get { return default(TimeSpan); } set { } } protected Binding() { } protected Binding(string name, string ns) { } public IChannelFactory<TChannel> BuildChannelFactory<TChannel>(params object[] parameters) { return null; } public virtual IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingParameterCollection parameters) { return null; } public bool CanBuildChannelFactory<TChannel>(params object[] parameters) { return false; } public virtual bool CanBuildChannelFactory<TChannel>(BindingParameterCollection parameters) { return false; } public abstract BindingElementCollection CreateBindingElements(); public T GetProperty<T>(BindingParameterCollection parameters) where T : class { return null; } } public class BindingContext { public CustomBinding Binding => null; public BindingParameterCollection BindingParameters => null; public BindingElementCollection RemainingBindingElements => null; public BindingContext(CustomBinding binding, BindingParameterCollection parameters) { } public IChannelFactory<TChannel> BuildInnerChannelFactory<TChannel>() { return null; } public bool CanBuildInnerChannelFactory<TChannel>() { return false; } public BindingContext Clone() { return null; } public T GetInnerProperty<T>() where T : class { return null; } } public abstract class BindingElement { protected BindingElement() { } protected BindingElement(BindingElement elementToBeCloned) { } public virtual IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context) { return null; } public virtual bool CanBuildChannelFactory<TChannel>(BindingContext context) { return false; } public abstract BindingElement Clone(); public abstract T GetProperty<T>(BindingContext context) where T : class; } public class BindingElementCollection : Collection<BindingElement> { public BindingElementCollection() { } public BindingElementCollection(IEnumerable<BindingElement> elements) { } public BindingElementCollection(BindingElement[] elements) { } public void AddRange(params BindingElement[] elements) { } public BindingElementCollection Clone() { return null; } public bool Contains(Type bindingElementType) { return false; } public T Find<T>() { return default(T); } public Collection<T> FindAll<T>() { return null; } protected override void InsertItem(int index, BindingElement item) { } public T Remove<T>() { return default(T); } public Collection<T> RemoveAll<T>() { return null; } protected override void SetItem(int index, BindingElement item) { } } public class BindingParameterCollection : KeyedByTypeCollection<object> { } public abstract class BodyWriter { public bool IsBuffered => false; protected BodyWriter(bool isBuffered) { } public BodyWriter CreateBufferedCopy(int maxBufferSize) { return null; } protected virtual BodyWriter OnCreateBufferedCopy(int maxBufferSize) { return null; } protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer); public void WriteBodyContents(XmlDictionaryWriter writer) { } } public abstract class BufferManager { public abstract void Clear(); public static BufferManager CreateBufferManager(long maxBufferPoolSize, int maxBufferSize) { return null; } public abstract void ReturnBuffer(byte[] buffer); public abstract byte[] TakeBuffer(int bufferSize); } public abstract class ChannelBase : CommunicationObject, IChannel, ICommunicationObject, IDefaultCommunicationTimeouts { protected override TimeSpan DefaultCloseTimeout => default(TimeSpan); protected override TimeSpan DefaultOpenTimeout => default(TimeSpan); protected TimeSpan DefaultReceiveTimeout => default(TimeSpan); protected TimeSpan DefaultSendTimeout => default(TimeSpan); protected ChannelManagerBase Manager => null; TimeSpan IDefaultCommunicationTimeouts.CloseTimeout => default(TimeSpan); TimeSpan IDefaultCommunicationTimeouts.OpenTimeout => default(TimeSpan); TimeSpan IDefaultCommunicationTimeouts.ReceiveTimeout => default(TimeSpan); TimeSpan IDefaultCommunicationTimeouts.SendTimeout => default(TimeSpan); protected ChannelBase(ChannelManagerBase channelManager) { } public virtual T GetProperty<T>() where T : class { return null; } protected override void OnClosed() { } } public abstract class ChannelFactoryBase : ChannelManagerBase, IChannelFactory, ICommunicationObject { protected override TimeSpan DefaultCloseTimeout => default(TimeSpan); protected override TimeSpan DefaultOpenTimeout => default(TimeSpan); protected override TimeSpan DefaultReceiveTimeout => default(TimeSpan); protected override TimeSpan DefaultSendTimeout => default(TimeSpan); protected ChannelFactoryBase() { } protected ChannelFactoryBase(IDefaultCommunicationTimeouts timeouts) { } public virtual T GetProperty<T>() where T : class { return null; } protected override void OnAbort() { } protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } protected override void OnClose(TimeSpan timeout) { } protected override void OnEndClose(IAsyncResult result) { } } public abstract class ChannelFactoryBase<TChannel> : ChannelFactoryBase, IChannelFactory, ICommunicationObject, IChannelFactory<TChannel> { protected ChannelFactoryBase() { } protected ChannelFactoryBase(IDefaultCommunicationTimeouts timeouts) { } public TChannel CreateChannel(EndpointAddress address) { return default(TChannel); } public TChannel CreateChannel(EndpointAddress address, Uri via) { return default(TChannel); } protected override void OnAbort() { } protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } protected override void OnClose(TimeSpan timeout) { } protected abstract TChannel OnCreateChannel(EndpointAddress address, Uri via); protected override void OnEndClose(IAsyncResult result) { } protected void ValidateCreateChannel() { } } public abstract class ChannelManagerBase : CommunicationObject, IDefaultCommunicationTimeouts { protected abstract TimeSpan DefaultReceiveTimeout { get; } protected abstract TimeSpan DefaultSendTimeout { get; } TimeSpan IDefaultCommunicationTimeouts.CloseTimeout => default(TimeSpan); TimeSpan IDefaultCommunicationTimeouts.OpenTimeout => default(TimeSpan); TimeSpan IDefaultCommunicationTimeouts.ReceiveTimeout => default(TimeSpan); TimeSpan IDefaultCommunicationTimeouts.SendTimeout => default(TimeSpan); } public class ChannelParameterCollection : Collection<object> { protected virtual IChannel Channel => null; public ChannelParameterCollection() { } public ChannelParameterCollection(IChannel channel) { } protected override void ClearItems() { } protected override void InsertItem(int index, object item) { } public void PropagateChannelParameters(IChannel innerChannel) { } protected override void RemoveItem(int index) { } protected override void SetItem(int index, object item) { } } public abstract class CommunicationObject : ICommunicationObject { protected abstract TimeSpan DefaultCloseTimeout { get; } protected abstract TimeSpan DefaultOpenTimeout { get; } protected bool IsDisposed => false; public CommunicationState State => CommunicationState.Created; protected object ThisLock => null; public event EventHandler Closed { add { } remove { } } public event EventHandler Closing { add { } remove { } } public event EventHandler Faulted { add { } remove { } } public event EventHandler Opened { add { } remove { } } public event EventHandler Opening { add { } remove { } } protected CommunicationObject() { } protected CommunicationObject(object mutex) { } public void Abort() { } public IAsyncResult BeginClose(AsyncCallback callback, object state) { return null; } public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return null; } public IAsyncResult BeginOpen(AsyncCallback callback, object state) { return null; } public IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return null; } public void Close() { } public void Close(TimeSpan timeout) { } public void EndClose(IAsyncResult result) { } public void EndOpen(IAsyncResult result) { } protected void Fault() { } protected virtual Type GetCommunicationObjectType() { return null; } protected abstract void OnAbort(); protected abstract IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state); protected abstract IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state); protected abstract void OnClose(TimeSpan timeout); protected virtual void OnClosed() { } protected virtual void OnClosing() { } protected abstract void OnEndClose(IAsyncResult result); protected abstract void OnEndOpen(IAsyncResult result); protected virtual void OnFaulted() { } protected abstract void OnOpen(TimeSpan timeout); protected virtual void OnOpened() { } protected virtual void OnOpening() { } public void Open() { } public void Open(TimeSpan timeout) { } } public enum CompressionFormat { Deflate = 2, GZip = 1, None = 0 } public class CustomBinding : Binding { public BindingElementCollection Elements => null; public override string Scheme => null; public CustomBinding() { } public CustomBinding(IEnumerable<BindingElement> bindingElementsInTopDownChannelStackOrder) { } public CustomBinding(Binding binding) { } public CustomBinding(params BindingElement[] bindingElementsInTopDownChannelStackOrder) { } public CustomBinding(string name, string ns, params BindingElement[] bindingElementsInTopDownChannelStackOrder) { } public override BindingElementCollection CreateBindingElements() { return null; } } public abstract class FaultConverter { public static FaultConverter GetDefaultFaultConverter(MessageVersion version) { return null; } protected abstract bool OnTryCreateException(Message message, MessageFault fault, out Exception exception); protected abstract bool OnTryCreateFaultMessage(Exception exception, out Message message); public bool TryCreateException(Message message, MessageFault fault, out Exception exception) { exception = null; return false; } } public interface IChannel : ICommunicationObject { T GetProperty<T>() where T : class; } public interface IChannelFactory : ICommunicationObject { T GetProperty<T>() where T : class; } public interface IChannelFactory<TChannel> : IChannelFactory, ICommunicationObject { TChannel CreateChannel(EndpointAddress to); TChannel CreateChannel(EndpointAddress to, Uri via); } public interface IBindingDeliveryCapabilities { bool AssuresOrderedDelivery { get; } bool QueuedDelivery { get; } } public interface IDuplexChannel : IChannel, ICommunicationObject, IInputChannel, IOutputChannel { } public interface IDuplexSession : IInputSession, ISession, IOutputSession { IAsyncResult BeginCloseOutputSession(AsyncCallback callback, object state); IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state); void CloseOutputSession(); void CloseOutputSession(TimeSpan timeout); void EndCloseOutputSession(IAsyncResult result); } public interface IDuplexSessionChannel : IChannel, ICommunicationObject, IDuplexChannel, IInputChannel, IOutputChannel, ISessionChannel<IDuplexSession> { } public interface IInputChannel : IChannel, ICommunicationObject { EndpointAddress LocalAddress { get; } IAsyncResult BeginReceive(AsyncCallback callback, object state); IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state); IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, object state); IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, object state); Message EndReceive(IAsyncResult result); bool EndTryReceive(IAsyncResult result, out Message message); bool EndWaitForMessage(IAsyncResult result); Message Receive(); Message Receive(TimeSpan timeout); bool TryReceive(TimeSpan timeout, out Message message); bool WaitForMessage(TimeSpan timeout); } public interface IInputSession : ISession { } public interface IInputSessionChannel : IChannel, ICommunicationObject, IInputChannel, ISessionChannel<IInputSession> { } public interface IMessageProperty { IMessageProperty CreateCopy(); } public interface IOutputChannel : IChannel, ICommunicationObject { EndpointAddress RemoteAddress { get; } Uri Via { get; } IAsyncResult BeginSend(Message message, AsyncCallback callback, object state); IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state); void EndSend(IAsyncResult result); void Send(Message message); void Send(Message message, TimeSpan timeout); } public interface IOutputSession : ISession { } public interface IOutputSessionChannel : IChannel, ICommunicationObject, IOutputChannel, ISessionChannel<IOutputSession> { } public interface IRequestChannel : IChannel, ICommunicationObject { EndpointAddress RemoteAddress { get; } Uri Via { get; } IAsyncResult BeginRequest(Message message, AsyncCallback callback, object state); IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state); Message EndRequest(IAsyncResult result); Message Request(Message message); Message Request(Message message, TimeSpan timeout); } public interface IRequestSessionChannel : IChannel, ICommunicationObject, IRequestChannel, ISessionChannel<IOutputSession> { } public interface ISession { string Id { get; } } public interface ISessionChannel<TSession> where TSession : ISession { TSession Session { get; } } public abstract class Message : IDisposable { public abstract MessageHeaders Headers { get; } protected bool IsDisposed => false; public virtual bool IsEmpty => false; public virtual bool IsFault => false; public abstract MessageProperties Properties { get; } public MessageState State => MessageState.Created; public abstract MessageVersion Version { get; } public void Close() { } public MessageBuffer CreateBufferedCopy(int maxBufferSize) { return null; } public static Message CreateMessage(MessageVersion version, string action) { return null; } public static Message CreateMessage(MessageVersion version, string action, object body) { return null; } public static Message CreateMessage(MessageVersion version, string action, object body, XmlObjectSerializer serializer) { return null; } public static Message CreateMessage(MessageVersion version, string action, BodyWriter body) { return null; } public static Message CreateMessage(MessageVersion version, string action, XmlDictionaryReader body) { return null; } public static Message CreateMessage(MessageVersion version, string action, XmlReader body) { return null; } public static Message CreateMessage(XmlDictionaryReader envelopeReader, int maxSizeOfHeaders, MessageVersion version) { return null; } public static Message CreateMessage(XmlReader envelopeReader, int maxSizeOfHeaders, MessageVersion version) { return null; } public static Message CreateMessage(MessageVersion version, FaultCode faultCode, string reason, string action) { return null; } public static Message CreateMessage(MessageVersion version, FaultCode faultCode, string reason, object detail, string action) { return null; } public T GetBody<T>() { return default(T); } public T GetBody<T>(XmlObjectSerializer serializer) { return default(T); } public string GetBodyAttribute(string localName, string ns) { return null; } public XmlDictionaryReader GetReaderAtBodyContents() { return null; } protected virtual void OnBodyToString(XmlDictionaryWriter writer) { } protected virtual void OnClose() { } protected virtual MessageBuffer OnCreateBufferedCopy(int maxBufferSize) { return null; } protected virtual T OnGetBody<T>(XmlDictionaryReader reader) { return default(T); } protected virtual string OnGetBodyAttribute(string localName, string ns) { return null; } protected virtual XmlDictionaryReader OnGetReaderAtBodyContents() { return null; } protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer); protected virtual void OnWriteMessage(XmlDictionaryWriter writer) { } protected virtual void OnWriteStartBody(XmlDictionaryWriter writer) { } protected virtual void OnWriteStartEnvelope(XmlDictionaryWriter writer) { } protected virtual void OnWriteStartHeaders(XmlDictionaryWriter writer) { } void IDisposable.Dispose() { } public override string ToString() { return null; } public void WriteBody(XmlDictionaryWriter writer) { } public void WriteBody(XmlWriter writer) { } public void WriteBodyContents(XmlDictionaryWriter writer) { } public void WriteMessage(XmlDictionaryWriter writer) { } public void WriteMessage(XmlWriter writer) { } public void WriteStartBody(XmlDictionaryWriter writer) { } public void WriteStartBody(XmlWriter writer) { } public void WriteStartEnvelope(XmlDictionaryWriter writer) { } } public abstract class MessageBuffer : IDisposable { public abstract int BufferSize { get; } public virtual string MessageContentType => null; public abstract void Close(); public abstract Message CreateMessage(); void IDisposable.Dispose() { } public virtual void WriteMessage(Stream stream) { } } public abstract class MessageEncoder { public abstract string ContentType { get; } public abstract string MediaType { get; } public abstract MessageVersion MessageVersion { get; } public virtual T GetProperty<T>() where T : class { return null; } public virtual bool IsContentTypeSupported(string contentType) { return false; } public Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager) { return null; } public abstract Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType); public Message ReadMessage(Stream stream, int maxSizeOfHeaders) { return null; } public abstract Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType); public override string ToString() { return null; } public ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager) { return default(ArraySegment<byte>); } public abstract ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset); public abstract void WriteMessage(Message message, Stream stream); } public abstract class MessageEncoderFactory { public abstract MessageEncoder Encoder { get; } public abstract MessageVersion MessageVersion { get; } public virtual MessageEncoder CreateSessionEncoder() { return null; } } public abstract class MessageEncodingBindingElement : BindingElement { public abstract MessageVersion MessageVersion { get; set; } protected MessageEncodingBindingElement() { } protected MessageEncodingBindingElement(MessageEncodingBindingElement elementToBeCloned) { } public abstract MessageEncoderFactory CreateMessageEncoderFactory(); public override T GetProperty<T>(BindingContext context) { return null; } } public abstract class MessageFault { public virtual string Actor => null; public abstract FaultCode Code { get; } public abstract bool HasDetail { get; } public virtual string Node => null; public abstract FaultReason Reason { get; } public static MessageFault CreateFault(Message message, int maxBufferSize) { return null; } public T GetDetail<T>() { return default(T); } public T GetDetail<T>(XmlObjectSerializer serializer) { return default(T); } public XmlDictionaryReader GetReaderAtDetailContents() { return null; } protected virtual XmlDictionaryReader OnGetReaderAtDetailContents() { return null; } protected virtual void OnWriteDetail(XmlDictionaryWriter writer, EnvelopeVersion version) { } protected abstract void OnWriteDetailContents(XmlDictionaryWriter writer); protected virtual void OnWriteStartDetail(XmlDictionaryWriter writer, EnvelopeVersion version) { } } public abstract class MessageHeader : MessageHeaderInfo { public override string Actor => null; public override bool IsReferenceParameter => false; public override bool MustUnderstand => false; public override bool Relay => false; public static MessageHeader CreateHeader(string name, string ns, object value) { return null; } public static Mes
BepInEx/core/System.ServiceModel.Primitives/netstandard2.0/System.ServiceModel.Duplex.dll
Decompiled 2 months agousing System; using System.Diagnostics; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.ServiceModel; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] [assembly: AssemblyMetadata("Serviceable", "True")] [assembly: AssemblyMetadata("PreferInbox", "True")] [assembly: AssemblyDefaultAlias("System.ServiceModel.Duplex")] [assembly: CLSCompliant(true)] [assembly: AssemblyCompany("Microsoft Corporation")] [assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] [assembly: AssemblyDescription("System.ServiceModel.Duplex")] [assembly: AssemblyFileVersion("8.100.225.15402")] [assembly: AssemblyInformationalVersion("8.1.2-rtm.25154.2+a47960f931a813617a061adc2ba9cabe1816a551")] [assembly: AssemblyProduct("Microsoft® .NET Core")] [assembly: AssemblyTitle("System.ServiceModel.Duplex")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/wcf")] [assembly: AssemblyVersion("8.1.2.0")] [assembly: TypeForwardedTo(typeof(CallbackBehaviorAttribute))] [assembly: TypeForwardedTo(typeof(ConcurrencyMode))] [assembly: TypeForwardedTo(typeof(DuplexChannelFactory<>))] [assembly: TypeForwardedTo(typeof(DuplexClientBase<>))] [assembly: TypeForwardedTo(typeof(InstanceContext))]
BepInEx/core/System.ServiceModel.Primitives/netstandard2.0/System.ServiceModel.Security.dll
Decompiled 2 months agousing System; using System.Diagnostics; using System.IdentityModel.Claims; using System.IdentityModel.Policy; using System.IdentityModel.Tokens; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.ServiceModel; using System.ServiceModel.Channels; using System.ServiceModel.Security; using System.ServiceModel.Security.Tokens; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] [assembly: AssemblyMetadata("Serviceable", "True")] [assembly: AssemblyMetadata("PreferInbox", "True")] [assembly: AssemblyDefaultAlias("System.ServiceModel.Security")] [assembly: CLSCompliant(true)] [assembly: AssemblyCompany("Microsoft Corporation")] [assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] [assembly: AssemblyDescription("System.ServiceModel.Security")] [assembly: AssemblyFileVersion("8.100.225.15402")] [assembly: AssemblyInformationalVersion("8.1.2-rtm.25154.2+a47960f931a813617a061adc2ba9cabe1816a551")] [assembly: AssemblyProduct("Microsoft® .NET Core")] [assembly: AssemblyTitle("System.ServiceModel.Security")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/wcf")] [assembly: AssemblyVersion("8.1.2.0")] [assembly: TypeForwardedTo(typeof(Claim))] [assembly: TypeForwardedTo(typeof(ClaimSet))] [assembly: TypeForwardedTo(typeof(AuthorizationContext))] [assembly: TypeForwardedTo(typeof(IAuthorizationComponent))] [assembly: TypeForwardedTo(typeof(IAuthorizationPolicy))] [assembly: TypeForwardedTo(typeof(GenericXmlSecurityKeyIdentifierClause))] [assembly: TypeForwardedTo(typeof(GenericXmlSecurityToken))] [assembly: TypeForwardedTo(typeof(ISecurityCapabilities))] [assembly: TypeForwardedTo(typeof(LocalClientSecuritySettings))] [assembly: TypeForwardedTo(typeof(SecurityBindingElement))] [assembly: TypeForwardedTo(typeof(SecurityHeaderLayout))] [assembly: TypeForwardedTo(typeof(TransportSecurityBindingElement))] [assembly: TypeForwardedTo(typeof(DnsEndpointIdentity))] [assembly: TypeForwardedTo(typeof(MessageSecurityVersion))] [assembly: TypeForwardedTo(typeof(BasicSecurityProfileVersion))] [assembly: TypeForwardedTo(typeof(IdentityVerifier))] [assembly: TypeForwardedTo(typeof(SecureConversationVersion))] [assembly: TypeForwardedTo(typeof(SecurityAlgorithmSuite))] [assembly: TypeForwardedTo(typeof(SecurityKeyEntropyMode))] [assembly: TypeForwardedTo(typeof(SecurityPolicyVersion))] [assembly: TypeForwardedTo(typeof(SecurityVersion))] [assembly: TypeForwardedTo(typeof(BinarySecretSecurityToken))] [assembly: TypeForwardedTo(typeof(IssuedSecurityTokenParameters))] [assembly: TypeForwardedTo(typeof(SecureConversationSecurityTokenParameters))] [assembly: TypeForwardedTo(typeof(SecurityTokenParameters))] [assembly: TypeForwardedTo(typeof(ServiceModelSecurityTokenRequirement))] [assembly: TypeForwardedTo(typeof(SupportingTokenParameters))] [assembly: TypeForwardedTo(typeof(UserNameSecurityTokenParameters))] [assembly: TypeForwardedTo(typeof(TrustVersion))] [assembly: TypeForwardedTo(typeof(SpnEndpointIdentity))] [assembly: TypeForwardedTo(typeof(UpnEndpointIdentity))] [assembly: TypeForwardedTo(typeof(X509CertificateEndpointIdentity))]