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("10.0.25.52802")]
[assembly: AssemblyInformationalVersion("10.0.0+e9d8c1c2a051618689bc22ab263f6ff0f2493d64")]
[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("10.0.0.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
