Silverlight 5

WinRT

	sealed class WaitAsyncResult
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(CommunicationObject communicationObject, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(CommunicationObject communicationObject);

	sealed class AddressChangeHelper
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke();

public sealed class AddressHeaderCollection	public sealed class AddressHeaderCollection
: ReadOnlyCollection`1<AddressHeader>, IList`1<AddressHeader>, ICollection`1<AddressHeader>, IEnumerable`1<AddressHeader>, IEnumerable, IList, ICollection	: ReadOnlyCollection`1<AddressHeader>, IList`1<AddressHeader>, ICollection`1<AddressHeader>, IEnumerable`1<AddressHeader>, IEnumerable, IList, ICollection, IReadOnlyList`1<AddressHeader>
public void AddHeadersTo(Message message);	public void AddHeadersTo(Message message);
public AddressHeader FindAll(String name, String ns);	public AddressHeader FindAll(String name, String ns);
public AddressHeader FindHeader(String name, String ns);	public AddressHeader FindHeader(String name, String ns);

public sealed class AddressingVersion	public sealed class AddressingVersion

static public AddressingVersion None { get; }	static public AddressingVersion None { get; }
static public AddressingVersion WSAddressing10 { get; }	static public AddressingVersion WSAddressing10 { get; }
	static public AddressingVersion WSAddressingAugust2004 { get; }
public virtual String ToString();	public virtual String ToString();

	public sealed class ApplicationContainerSettings

	public String PackageMoniker { get; set; }
	public Int32 SessionId { get; set; }

	public sealed class AsymmetricSecurityBindingElement
	: SecurityBindingElement, IPolicyExportExtension
	public Boolean AllowSerializedSigningTokenOnReply { get; set; }
	public SecurityTokenParameters InitiatorTokenParameters { get; set; }
	public MessageProtectionOrder MessageProtectionOrder { get; set; }
	public SecurityTokenParameters RecipientTokenParameters { get; set; }
	public Boolean RequireSignatureConfirmation { get; set; }
	protected virtual IChannelFactory`1<TChannel> BuildChannelFactoryCore(BindingContext context);
	protected virtual IChannelListener`1<TChannel> BuildChannelListenerCore(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public virtual void SetKeyDerivation(Boolean requireDerivedKeys);
	public virtual String ToString();

	sealed class ChannelSynchronizer<TChannel>
	: AsyncResult, IAsyncResult, IWaiter<TChannel> where TChannel : IChannel
	public virtual Boolean CanGetChannel { get; }
	public virtual void Close();
	public Boolean End(out TChannel& channel);
	public virtual void Fault();
	public virtual void GetChannel(Boolean onUserThread);
	public virtual void Set(TChannel channel);
	public void Wait();

	public abstract class BaseChannelObjectWithProperties
	: IDictionary, ICollection, IEnumerable
	public virtual Int32 Count { get; }
	public virtual Boolean IsFixedSize { get; }
	public virtual Boolean IsReadOnly { get; }
	public virtual Boolean IsSynchronized { get; }
	public virtual Object Item { get; set; }
	public virtual ICollection Keys { get; }
	public virtual IDictionary Properties { get; }
	public virtual Object SyncRoot { get; }
	public virtual ICollection Values { get; }
	public virtual void Add(Object key, Object value);
	public virtual void Clear();
	public virtual Boolean Contains(Object key);
	public virtual void CopyTo(Array array, Int32 index);
	public virtual IDictionaryEnumerator GetEnumerator();
	public virtual void Remove(Object key);

	public abstract class BaseChannelSinkWithProperties
	: BaseChannelObjectWithProperties, IDictionary, ICollection, IEnumerable

	public abstract class BaseChannelWithProperties
	: BaseChannelObjectWithProperties, IDictionary, ICollection, IEnumerable
	public virtual IDictionary Properties { get; }

public sealed class BinaryMessageEncodingBindingElement	public sealed class BinaryMessageEncodingBindingElement
: MessageEncodingBindingElement	: MessageEncodingBindingElement, IWsdlExportExtension, IPolicyExportExtension
	public CompressionFormat CompressionFormat { get; set; }
	public Int32 MaxReadPoolSize { get; set; }
	public Int32 MaxSessionSize { get; set; }
	public Int32 MaxWritePoolSize { get; set; }
public virtual MessageVersion MessageVersion { get; set; }	public virtual MessageVersion MessageVersion { get; set; }
	public XmlDictionaryReaderQuotas ReaderQuotas { get; set; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
public virtual BindingElement Clone();	public virtual BindingElement Clone();
public virtual MessageEncoderFactory CreateMessageEncoderFactory();	public virtual MessageEncoderFactory CreateMessageEncoderFactory();
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeMessageVersion();

public abstract class Binding	public abstract class Binding
: IDefaultCommunicationTimeouts	: IDefaultCommunicationTimeouts
public virtual TimeSpan CloseTimeout { get; set; }	public virtual TimeSpan CloseTimeout { get; set; }
public MessageVersion MessageVersion { get; }	public MessageVersion MessageVersion { get; }
public String Name { get; set; }	public String Name { get; set; }
public String Namespace { get; set; }	public String Namespace { get; set; }
public virtual TimeSpan OpenTimeout { get; set; }	public virtual TimeSpan OpenTimeout { get; set; }
public virtual TimeSpan ReceiveTimeout { get; set; }	public virtual TimeSpan ReceiveTimeout { get; set; }
public abstract virtual String Scheme { get; }	public abstract virtual String Scheme { get; }
public virtual TimeSpan SendTimeout { get; set; }	public virtual TimeSpan SendTimeout { get; set; }
public IChannelFactory`1<TChannel> BuildChannelFactory(Object parameters);	public IChannelFactory`1<TChannel> BuildChannelFactory(Object parameters);
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingParameterCollection parameters);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingParameterCollection parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Object parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Uri listenUriBaseAddress, Object parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Uri listenUriBaseAddress, String listenUriRelativeAddress, Object parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Uri listenUriBaseAddress, String listenUriRelativeAddress, ListenUriMode listenUriMode, Object parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingParameterCollection parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Uri listenUriBaseAddress, BindingParameterCollection parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Uri listenUriBaseAddress, String listenUriRelativeAddress, BindingParameterCollection parameters);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(Uri listenUriBaseAddress, String listenUriRelativeAddress, ListenUriMode listenUriMode, BindingParameterCollection parameters);
public Boolean CanBuildChannelFactory(Object parameters);	public Boolean CanBuildChannelFactory(Object parameters);
public virtual Boolean CanBuildChannelFactory(BindingParameterCollection parameters);	public virtual Boolean CanBuildChannelFactory(BindingParameterCollection parameters);
	public Boolean CanBuildChannelListener(Object parameters);
	public virtual Boolean CanBuildChannelListener(BindingParameterCollection parameters);
public abstract virtual BindingElementCollection CreateBindingElements();	public abstract virtual BindingElementCollection CreateBindingElements();
public T GetProperty(BindingParameterCollection parameters);	public T GetProperty(BindingParameterCollection parameters);
	public Boolean ShouldSerializeName();

public class BindingContext	public class BindingContext

public CustomBinding Binding { get; }	public CustomBinding Binding { get; }
public BindingParameterCollection BindingParameters { get; }	public BindingParameterCollection BindingParameters { get; }
	public Uri ListenUriBaseAddress { get; set; }
	public ListenUriMode ListenUriMode { get; set; }
	public String ListenUriRelativeAddress { get; set; }
public BindingElementCollection RemainingBindingElements { get; }	public BindingElementCollection RemainingBindingElements { get; }
public IChannelFactory`1<TChannel> BuildInnerChannelFactory();	public IChannelFactory`1<TChannel> BuildInnerChannelFactory();
	public IChannelListener`1<TChannel> BuildInnerChannelListener();
public Boolean CanBuildInnerChannelFactory();	public Boolean CanBuildInnerChannelFactory();
	public Boolean CanBuildInnerChannelListener();
public BindingContext Clone();	public BindingContext Clone();
public T GetInnerProperty();	public T GetInnerProperty();

public abstract class BindingElement	public abstract class BindingElement

public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
public virtual Boolean CanBuildChannelFactory(BindingContext context);	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
public abstract virtual BindingElement Clone();	public abstract virtual BindingElement Clone();
public abstract virtual T GetProperty(BindingContext context);	public abstract virtual T GetProperty(BindingContext context);

public class BindingElementCollection	public class BindingElementCollection
: Collection`1<BindingElement>, IList`1<BindingElement>, ICollection`1<BindingElement>, IEnumerable`1<BindingElement>, IEnumerable, IList, ICollection	: Collection`1<BindingElement>, IList`1<BindingElement>, ICollection`1<BindingElement>, IEnumerable`1<BindingElement>, IEnumerable, IList, ICollection, IReadOnlyList`1<BindingElement>
public void AddRange(BindingElement elements);	public void AddRange(BindingElement elements);
public BindingElementCollection Clone();	public BindingElementCollection Clone();
public Boolean Contains(Type bindingElementType);	public Boolean Contains(Type bindingElementType);
public T Find();	public T Find();
public Collection`1<T> FindAll();	public Collection`1<T> FindAll();
	protected virtual void InsertItem(Int32 index, BindingElement item);
public T Remove();	public T Remove();
public Collection`1<T> RemoveAll();	public Collection`1<T> RemoveAll();

public class BindingParameterCollection	public class BindingParameterCollection
: KeyedByTypeCollection`1<Object>, IList`1<Object>, ICollection`1<Object>, IEnumerable`1<Object>, IEnumerable, IList, ICollection	: KeyedByTypeCollection`1<Object>, IList`1<Object>, ICollection`1<Object>, IEnumerable`1<Object>, IEnumerable, IList, ICollection, IReadOnlyList`1<Object>

public abstract class BodyWriter	public abstract class BodyWriter

public Boolean IsBuffered { get; }	public Boolean IsBuffered { get; }
	public IAsyncResult BeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, Object state);
public BodyWriter CreateBufferedCopy(Int32 maxBufferSize);	public BodyWriter CreateBufferedCopy(Int32 maxBufferSize);
	public void EndWriteBodyContents(IAsyncResult result);
	protected virtual IAsyncResult OnBeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, Object state);
	protected virtual BodyWriter OnCreateBufferedCopy(Int32 maxBufferSize);
	protected virtual void OnEndWriteBodyContents(IAsyncResult result);
	protected abstract virtual void OnWriteBodyContents(XmlDictionaryWriter writer);
public void WriteBodyContents(XmlDictionaryWriter writer);	public void WriteBodyContents(XmlDictionaryWriter writer);

	class NativeMsmqMessage
	: MsmqProperty, IDisposable
	public Boolean Value { get; set; }

public abstract class BufferManager	public abstract class BufferManager

public abstract virtual void Clear();	public abstract virtual void Clear();
static public BufferManager CreateBufferManager(Int64 maxBufferPoolSize, Int32 maxBufferSize);	static public BufferManager CreateBufferManager(Int64 maxBufferPoolSize, Int32 maxBufferSize);
public abstract virtual void ReturnBuffer(Byte buffer);	public abstract virtual void ReturnBuffer(Byte buffer);
public abstract virtual Byte TakeBuffer(Int32 bufferSize);	public abstract virtual Byte TakeBuffer(Int32 bufferSize);

	public class CallbackContextMessageProperty
	: IMessageProperty
	public EndpointAddress CallbackAddress { get; }
	public IDictionary`2<String, String> Context { get; }
	static public String Name { get; }
	public void AddOrReplaceInMessage(Message message);
	public void AddOrReplaceInMessageProperties(MessageProperties properties);
	public EndpointAddress CreateCallbackAddress(Uri listenAddress);
	public virtual IMessageProperty CreateCopy();
	public void GetListenAddressAndContext(out EndpointAddress& listenAddress, out IDictionary`2& context);
	static public Boolean TryGet(Message message, out CallbackContextMessageProperty& contextMessageProperty);
	static public Boolean TryGet(MessageProperties properties, out CallbackContextMessageProperty& contextMessageProperty);

	sealed struct MQPROPVARIANT
	: ValueType

public abstract class ChannelBase	public abstract class ChannelBase
: CommunicationObject, ICommunicationObject, IChannel, IDefaultCommunicationTimeouts	: CommunicationObject, ICommunicationObject, IChannel, IDefaultCommunicationTimeouts
	protected virtual TimeSpan DefaultCloseTimeout { get; }
	protected virtual TimeSpan DefaultOpenTimeout { get; }
	protected TimeSpan DefaultReceiveTimeout { get; }
	protected TimeSpan DefaultSendTimeout { get; }
	protected ChannelManagerBase Manager { get; }
public virtual T GetProperty();	public virtual T GetProperty();

	sealed class PeerService
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(IClientChannel channel, AsyncCallback callback, Object object);
	public virtual Boolean EndInvoke(IAsyncResult result);
	public virtual Boolean Invoke(IClientChannel channel);

	public class ChannelDataStore
	: IChannelDataStore
	public virtual String ChannelUris { get; set; }
	public virtual Object Item { get; set; }

public abstract class ChannelFactoryBase	public abstract class ChannelFactoryBase
: ChannelManagerBase, ICommunicationObject, IDefaultCommunicationTimeouts, IChannelFactory	: ChannelManagerBase, ICommunicationObject, IDefaultCommunicationTimeouts, IChannelFactory
	protected virtual TimeSpan DefaultCloseTimeout { get; }
	protected virtual TimeSpan DefaultOpenTimeout { get; }
	protected virtual TimeSpan DefaultReceiveTimeout { get; }
	protected virtual TimeSpan DefaultSendTimeout { get; }
public virtual T GetProperty();	public virtual T GetProperty();
	protected virtual void OnAbort();
	protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual void OnClose(TimeSpan timeout);

public abstract class ChannelFactoryBase`1<TChannel>	public abstract class ChannelFactoryBase`1<TChannel>
: ChannelFactoryBase, ICommunicationObject, IDefaultCommunicationTimeouts, IChannelFactory, IChannelFactory`1<TChannel>	: ChannelFactoryBase, ICommunicationObject, IDefaultCommunicationTimeouts, IChannelFactory, IChannelFactory`1<TChannel>
public virtual TChannel CreateChannel(EndpointAddress address);	public virtual TChannel CreateChannel(EndpointAddress address);
public virtual TChannel CreateChannel(EndpointAddress address, Uri via);	public virtual TChannel CreateChannel(EndpointAddress address, Uri via);
	protected virtual void OnAbort();
	protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual void OnClose(TimeSpan timeout);
	protected abstract virtual TChannel OnCreateChannel(EndpointAddress address, Uri via);
	protected virtual void OnEndClose(IAsyncResult result);

	public abstract class ChannelListenerBase
	: ChannelManagerBase, ICommunicationObject, IDefaultCommunicationTimeouts, IChannelListener
	protected virtual TimeSpan DefaultCloseTimeout { get; }
	protected virtual TimeSpan DefaultOpenTimeout { get; }
	protected virtual TimeSpan DefaultReceiveTimeout { get; }
	protected virtual TimeSpan DefaultSendTimeout { get; }
	public abstract virtual Uri Uri { get; }
	public virtual IAsyncResult BeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, Object state);
	public virtual Boolean EndWaitForChannel(IAsyncResult result);
	public virtual T GetProperty();
	protected abstract virtual IAsyncResult OnBeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual Boolean OnEndWaitForChannel(IAsyncResult result);
	protected abstract virtual Boolean OnWaitForChannel(TimeSpan timeout);
	public virtual Boolean WaitForChannel(TimeSpan timeout);

	public abstract class ChannelListenerBase`1<TChannel>
	: ChannelListenerBase, ICommunicationObject, IDefaultCommunicationTimeouts, IChannelListener, IChannelListener`1<TChannel> where TChannel : IChannel
	public virtual TChannel AcceptChannel();
	public virtual TChannel AcceptChannel(TimeSpan timeout);
	public virtual IAsyncResult BeginAcceptChannel(AsyncCallback callback, Object state);
	public virtual IAsyncResult BeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, Object state);
	public virtual TChannel EndAcceptChannel(IAsyncResult result);
	protected abstract virtual TChannel OnAcceptChannel(TimeSpan timeout);
	protected abstract virtual IAsyncResult OnBeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual TChannel OnEndAcceptChannel(IAsyncResult result);

public abstract class ChannelManagerBase	public abstract class ChannelManagerBase
: CommunicationObject, ICommunicationObject, IDefaultCommunicationTimeouts	: CommunicationObject, ICommunicationObject, IDefaultCommunicationTimeouts
	protected abstract virtual TimeSpan DefaultReceiveTimeout { get; }

public class ChannelParameterCollection	public class ChannelParameterCollection
: Collection`1<Object>, IList`1<Object>, ICollection`1<Object>, IEnumerable`1<Object>, IEnumerable, IList, ICollection	: Collection`1<Object>, IList`1<Object>, ICollection`1<Object>, IEnumerable`1<Object>, IEnumerable, IList, ICollection, IReadOnlyList`1<Object>
	protected virtual IChannel Channel { get; }
	protected virtual void ClearItems();
	protected virtual void InsertItem(Int32 index, Object item);
public void PropagateChannelParameters(IChannel innerChannel);	public void PropagateChannelParameters(IChannel innerChannel);
	protected virtual void RemoveItem(Int32 index);

	public class ChannelPoolSettings

	public TimeSpan IdleTimeout { get; set; }
	public TimeSpan LeaseTimeout { get; set; }
	public Int32 MaxOutboundChannelsPerEndpoint { get; set; }

	public sealed class ChannelServices

	static public IChannel RegisteredChannels { get; }
	static public IMessageCtrl AsyncDispatchMessage(IMessage msg, IMessageSink replySink);
	static public IServerChannelSink CreateServerChannelSinkChain(IServerChannelSinkProvider provider, IChannelReceiver channel);
	static public ServerProcessing DispatchMessage(IServerChannelSinkStack sinkStack, IMessage msg, out IMessage& replyMsg);
	static public IChannel GetChannel(String name);
	static public IDictionary GetChannelSinkProperties(Object obj);
	static public String GetUrlsForObject(MarshalByRefObject obj);
	static public void RegisterChannel(IChannel chnl, Boolean ensureSecurity);
	static public void RegisterChannel(IChannel chnl);
	static public IMessage SyncDispatchMessage(IMessage msg);
	static public void UnregisterChannel(IChannel chnl);

	class ReliableChannelBinder`1<TChannel>
	where TChannel : IChannel
	public Boolean Aborting { get; }
	public Boolean Connected { get; }
	public TChannel CurrentChannel { get; }
	public Boolean TolerateFaults { get; }
	public TChannel AbortCurentChannel();
	public IAsyncResult BeginTryGetChannelForInput(Boolean canGetChannel, TimeSpan timeout, AsyncCallback callback, Object state);
	public IAsyncResult BeginTryGetChannelForOutput(TimeSpan timeout, MaskingMode maskingMode, AsyncCallback callback, Object state);
	public IAsyncResult BeginWaitForPendingOperations(TimeSpan timeout, AsyncCallback callback, Object state);
	public Boolean EndTryGetChannel(IAsyncResult result, out TChannel& channel);
	public void EndWaitForPendingOperations(IAsyncResult result);
	public Boolean EnsureChannel();
	public void OnReadEof();
	public void ReturnChannel();
	public Boolean SetChannel(TChannel channel);
	public void StartSynchronizing();
	public TChannel StopSynchronizing(Boolean close);
	public Boolean TryGetChannelForInput(Boolean canGetChannel, TimeSpan timeout, out TChannel& channel);
	public Boolean TryGetChannelForOutput(TimeSpan timeout, MaskingMode maskingMode, out TChannel& channel);
	public void UnblockWaiters();
	public void WaitForPendingOperations(TimeSpan timeout);

	sealed class PeerMessageHelpers
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(IPeerNeighbor neighbor, PeerCloseReason reason, Exception exception, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(IPeerNeighbor neighbor, PeerCloseReason reason, Exception exception);

	public class ClientChannelSinkStack
	: IClientChannelSinkStack, IClientResponseChannelSinkStack
	public virtual void AsyncProcessResponse(ITransportHeaders headers, Stream stream);
	public virtual void DispatchException(Exception e);
	public virtual void DispatchReplyMessage(IMessage msg);
	public virtual Object Pop(IClientChannelSink sink);
	public virtual void Push(IClientChannelSink sink, Object state);

public abstract class CommunicationObject	public abstract class CommunicationObject
: ICommunicationObject	: ICommunicationObject
	protected abstract virtual TimeSpan DefaultCloseTimeout { get; }
	protected abstract virtual TimeSpan DefaultOpenTimeout { get; }
	protected Boolean IsDisposed { get; }
public virtual CommunicationState State { get; }	public virtual CommunicationState State { get; }
	protected Object ThisLock { get; }
public virtual event EventHandler Closed;	public virtual event EventHandler Closed;
public virtual event EventHandler Closing;	public virtual event EventHandler Closing;
public virtual event EventHandler Faulted;	public virtual event EventHandler Faulted;
public virtual event EventHandler Opened;	public virtual event EventHandler Opened;
public virtual event EventHandler Opening;	public virtual event EventHandler Opening;
public virtual void Abort();	public virtual void Abort();
public virtual IAsyncResult BeginClose(AsyncCallback callback, Object state);	public virtual IAsyncResult BeginClose(AsyncCallback callback, Object state);
public virtual IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, Object state);	public virtual IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
public virtual IAsyncResult BeginOpen(AsyncCallback callback, Object state);	public virtual IAsyncResult BeginOpen(AsyncCallback callback, Object state);
public virtual IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, Object state);	public virtual IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, Object state);
public virtual void Close();	public virtual void Close();
public virtual void Close(TimeSpan timeout);	public virtual void Close(TimeSpan timeout);
public virtual void EndClose(IAsyncResult result);	public virtual void EndClose(IAsyncResult result);
public virtual void EndOpen(IAsyncResult result);	public virtual void EndOpen(IAsyncResult result);
	protected void Fault();
	protected virtual Type GetCommunicationObjectType();
	protected abstract virtual void OnAbort();
	protected abstract virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual void OnClose(TimeSpan timeout);
	protected virtual void OnClosed();
	protected virtual void OnClosing();
	protected abstract virtual void OnEndClose(IAsyncResult result);
	protected abstract virtual void OnEndOpen(IAsyncResult result);
	protected virtual void OnFaulted();
	protected abstract virtual void OnOpen(TimeSpan timeout);
	protected virtual void OnOpened();
	protected virtual void OnOpening();
public virtual void Open();	public virtual void Open();
public virtual void Open(TimeSpan timeout);	public virtual void Open(TimeSpan timeout);
	internal protected void ThrowIfDisposed();
	internal protected void ThrowIfDisposedOrImmutable();

	public sealed class CompositeDuplexBindingElement
	: BindingElement, IPolicyExportExtension
	public Uri ClientBaseAddress { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

	public class CompositeDuplexBindingElementImporter
	: IPolicyImportExtension

	public sealed enum CompressionFormat
	: IComparable, IFormattable, IConvertible
	{ None, GZip, Deflate }

	sealed class PeerMaintainerBase`1<TConnectAlgorithms>
	: MulticastDelegate, ICloneable, ISerializable where TConnectAlgorithms : IConnectAlgorithms
	public virtual IAsyncResult BeginInvoke(Exception e, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(Exception e);

public abstract class ConnectionOrientedTransportBindingElement	public abstract class ConnectionOrientedTransportBindingElement
: TransportBindingElement, IDuplexHelper	: TransportBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport
	public TimeSpan ChannelInitializationTimeout { get; set; }
public Int32 ConnectionBufferSize { get; set; }	public Int32 ConnectionBufferSize { get; set; }
	public HostNameComparisonMode HostNameComparisonMode { get; set; }
public Int32 MaxBufferSize { get; set; }	public Int32 MaxBufferSize { get; set; }
	public TimeSpan MaxOutputDelay { get; set; }
	public Int32 MaxPendingAccepts { get; set; }
	public Int32 MaxPendingConnections { get; set; }
	public TransferMode TransferMode { get; set; }
public virtual Boolean CanBuildChannelFactory(BindingContext context);	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeMaxPendingAccepts();

	class ConnectionOrientedTransportChannelListener
	: TransportReplyChannelAcceptor, ICommunicationObject, IChannelAcceptor`1<IReplyChannel>
	protected virtual void OnAbort();
	protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual void OnClose(TimeSpan timeout);
	protected virtual ReplyChannel OnCreateChannel();
	protected virtual void OnEndClose(IAsyncResult result);

	public class ContextBindingElement
	: BindingElement, IPolicyExportExtension, IContextSessionProvider, IWmiInstanceProvider, IContextBindingElement
	public Uri ClientCallbackAddress { get; set; }
	public ContextExchangeMechanism ContextExchangeMechanism { get; set; }
	public Boolean ContextManagementEnabled { get; set; }
	public ProtectionLevel ProtectionLevel { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual void ExportPolicy(MetadataExporter exporter, PolicyConversionContext context);
	public virtual T GetProperty(BindingContext context);

	public class ContextBindingElementImporter
	: IPolicyImportExtension, IWsdlImportExtension
	public virtual void BeforeImport(ServiceDescriptionCollection wsdlDocuments, XmlSchemaSet xmlSchemas, ICollection`1<XmlElement> policy);
	public virtual void ImportContract(WsdlImporter importer, WsdlContractConversionContext context);
	public virtual void ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context);
	public virtual void ImportPolicy(MetadataImporter importer, PolicyConversionContext context);

	public sealed enum ContextExchangeMechanism
	: IComparable, IFormattable, IConvertible
	{ ContextSoapHeader, HttpCookie }

	public class ContextMessageProperty
	: IMessageProperty
	public IDictionary`2<String, String> Context { get; }
	static public String Name { get; }
	public void AddOrReplaceInMessage(Message message);
	public void AddOrReplaceInMessageProperties(MessageProperties properties);
	public virtual IMessageProperty CreateCopy();
	static public Boolean TryCreateFromHttpCookieHeader(String httpCookieHeader, out ContextMessageProperty& context);
	static public Boolean TryGet(Message message, out ContextMessageProperty& contextMessageProperty);
	static public Boolean TryGet(MessageProperties properties, out ContextMessageProperty& contextMessageProperty);

	public abstract class CorrelationCallbackMessageProperty
	: IMessageProperty
	public Boolean IsFullyDefined { get; }
	static public String Name { get; }
	public IEnumerable`1<String> NeededData { get; }
	public void AddData(String name, Func`1<String> value);
	public IAsyncResult BeginFinalizeCorrelation(Message message, TimeSpan timeout, AsyncCallback callback, Object state);
	public abstract virtual IMessageProperty CreateCopy();
	public Message EndFinalizeCorrelation(IAsyncResult result);
	public Message FinalizeCorrelation(Message message, TimeSpan timeout);
	protected abstract virtual IAsyncResult OnBeginFinalizeCorrelation(Message message, TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual Message OnEndFinalizeCorrelation(IAsyncResult result);
	protected abstract virtual Message OnFinalizeCorrelation(Message message, TimeSpan timeout);
	static public Boolean TryGet(Message message, out CorrelationCallbackMessageProperty& property);
	static public Boolean TryGet(MessageProperties properties, out CorrelationCallbackMessageProperty& property);

	public abstract class CorrelationDataDescription

	public abstract virtual Boolean IsDefault { get; }
	public abstract virtual Boolean IsOptional { get; }
	public abstract virtual Boolean KnownBeforeSend { get; }
	public abstract virtual String Name { get; }
	public abstract virtual Boolean ReceiveValue { get; }
	public abstract virtual Boolean SendValue { get; }

	public class CorrelationDataMessageProperty
	: IMessageProperty
	static public String Name { get; }
	public void Add(String name, Func`1<String> dataProvider);
	static public void AddData(Message message, String name, Func`1<String> dataProvider);
	public virtual IMessageProperty CreateCopy();
	public Boolean Remove(String name);
	static public Boolean TryGet(Message message, out CorrelationDataMessageProperty& property);
	static public Boolean TryGet(MessageProperties properties, out CorrelationDataMessageProperty& property);
	public Boolean TryGetValue(String name, out String& value);

	public sealed class CorrelationKey
	: InstanceKey
	public IDictionary`2<String, String> KeyData { get; set; }
	public String KeyString { get; set; }
	public String Name { get; set; }
	public XNamespace Provider { get; set; }
	public XName ScopeName { get; set; }

	public class CorrelationMessageProperty

	public ReadOnlyCollection`1<InstanceKey> AdditionalKeys { get; }
	public InstanceKey CorrelationKey { get; }
	static public String Name { get; }
	static public Boolean TryGet(Message message, out CorrelationMessageProperty& property);
	static public Boolean TryGet(MessageProperties properties, out CorrelationMessageProperty& property);

public class CustomBinding	public class CustomBinding
: Binding, IDefaultCommunicationTimeouts	: Binding, IDefaultCommunicationTimeouts
public BindingElementCollection Elements { get; }	public BindingElementCollection Elements { get; }
public virtual String Scheme { get; }	public virtual String Scheme { get; }
public virtual BindingElementCollection CreateBindingElements();	public virtual BindingElementCollection CreateBindingElements();

	public sealed enum DeliveryFailure
	: IComparable, IFormattable, IConvertible
	{ Unknown, AccessDenied, BadDestinationQueue, BadEncryption, BadSignature, CouldNotEncrypt, HopCountExceeded, NotTransactionalQueue, NotTransactionalMessage, Purged, QueueDeleted, QueueExceedMaximumSize, QueuePurged, ReachQueueTimeout, ReceiveTimeout }

	public sealed enum DeliveryStatus
	: IComparable, IFormattable, IConvertible
	{ InDoubt, NotDelivered }

class CommunicationPool`2+EndpointConnectionPool<TKey, TItem>

public void Abort();
public void AddConnection(TItem connection, TimeSpan timeout);
public void Close(TimeSpan timeout);
public void CloseIdleConnection(TItem connection, TimeSpan timeout);
public Boolean CloseIfEmpty();
public virtual void Prune(List`1<TItem> itemsToClose);
public void ReturnConnection(TItem connection, Boolean connectionIsStillGood, TimeSpan timeout);
public TItem TakeConnection(TimeSpan timeout);

	class CommunicationPool`2<TKey, TItem>

	protected TKey Key { get; }
	protected CommunicationPool`2<TKey, TItem> Parent { get; }
	protected Object ThisLock { get; }
	public void Abort();
	protected virtual void AbortItem(TItem item);
	public void AddConnection(TItem connection, TimeSpan timeout);
	public void Close(TimeSpan timeout);
	public void CloseIdleConnection(TItem connection, TimeSpan timeout);
	public Boolean CloseIfEmpty();
	protected virtual void CloseItem(TItem item, TimeSpan timeout);
	protected virtual void CloseItemAsync(TItem item, TimeSpan timeout);
	protected virtual IdleConnectionPool<TKey, TItem> GetIdleConnectionPool();
	protected virtual void OnConnectionAborted();
	public virtual void Prune(List`1<TItem> itemsToClose);
	public void ReturnConnection(TItem connection, Boolean connectionIsStillGood, TimeSpan timeout);
	public TItem TakeConnection(TimeSpan timeout);

public abstract class FaultConverter	public abstract class FaultConverter

static public FaultConverter GetDefaultFaultConverter(MessageVersion version);	static public FaultConverter GetDefaultFaultConverter(MessageVersion version);
	protected abstract virtual Boolean OnTryCreateException(Message message, MessageFault fault, out Exception& exception);
	protected abstract virtual Boolean OnTryCreateFaultMessage(Exception exception, out Message& message);
public Boolean TryCreateException(Message message, MessageFault fault, out Exception& exception);	public Boolean TryCreateException(Message message, MessageFault fault, out Exception& exception);

public class HttpCookieContainerBindingElement
: BindingElement
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
public virtual BindingElement Clone();
public virtual T GetProperty(BindingContext context);

class HttpChannelFactory+HttpRequestChannel
: RequestChannel, ICommunicationObject, IChannel, IDefaultCommunicationTimeouts, IRequestChannel
public HttpChannelFactory Factory { get; }
public virtual T GetProperty();
public virtual HttpWebRequest GetWebRequest(EndpointAddress to, Uri via, TimeoutHelper& timeoutHelper);

	public class HttpMessageHandlerFactory

	public ReadOnlyCollection`1<Type> HttpMessageHandlers { get; }
	public HttpMessageHandler Create(HttpMessageHandler innerChannel);
	protected virtual HttpMessageHandler OnCreate(HttpMessageHandler innerChannel);

	class HttpChannelFactory`1<TChannel>
	: RequestChannel, ICommunicationObject, IChannel, IDefaultCommunicationTimeouts, IRequestChannel
	protected ChannelParameterCollection ChannelParameters { get; }
	public HttpChannelFactory`1<IRequestChannel> Factory { get; }
	protected IAsyncResult BeginGetWebRequest(EndpointAddress to, Uri via, SecurityTokenContainer clientCertificateToken, TimeoutHelper& timeoutHelper, AsyncCallback callback, Object state);
	public virtual IAsyncResult BeginGetWebRequest(EndpointAddress to, Uri via, TimeoutHelper& timeoutHelper, AsyncCallback callback, Object state);
	protected virtual IAsyncRequest CreateAsyncRequest(Message message, AsyncCallback callback, Object state);
	protected virtual IRequest CreateRequest(Message message);
	public virtual HttpWebRequest EndGetWebRequest(IAsyncResult result);
	public virtual T GetProperty();
	public virtual HttpWebRequest GetWebRequest(EndpointAddress to, Uri via, TimeoutHelper& timeoutHelper);
	protected HttpWebRequest GetWebRequest(EndpointAddress to, Uri via, SecurityTokenContainer clientCertificateToken, TimeoutHelper& timeoutHelper);
	protected virtual void OnAbort();
	protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual void OnClose(TimeSpan timeout);
	protected virtual void OnEndClose(IAsyncResult result);
	protected virtual void OnEndOpen(IAsyncResult result);
	protected virtual void OnOpen(TimeSpan timeout);
	public virtual Boolean WillGetWebRequestCompleteSynchronously();

public sealed class HttpRequestMessageProperty	public sealed class HttpRequestMessageProperty

public WebHeaderCollection Headers { get; }	public WebHeaderCollection Headers { get; }
	public HttpRequestMessage HttpRequestMessage { get; set; }
public String Method { get; set; }	public String Method { get; set; }
static public String Name { get; }	static public String Name { get; }
public String QueryString { get; set; }	public String QueryString { get; set; }
public Boolean SuppressEntityBody { get; set; }	public Boolean SuppressEntityBody { get; set; }

public sealed class HttpResponseMessageProperty	public sealed class HttpResponseMessageProperty

public WebHeaderCollection Headers { get; }	public WebHeaderCollection Headers { get; }
	public HttpResponseMessage HttpResponseMessage { get; set; }
static public String Name { get; }	static public String Name { get; }
public HttpStatusCode StatusCode { get; set; }	public HttpStatusCode StatusCode { get; set; }
public String StatusDescription { get; set; }	public String StatusDescription { get; set; }
	public Boolean SuppressEntityBody { get; set; }

public class HttpsTransportBindingElement	public class HttpsTransportBindingElement
: HttpTransportBindingElement	: HttpTransportBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport, ITransportTokenAssertionProvider
	public Boolean RequireClientCertificate { get; set; }
public virtual String Scheme { get; }	public virtual String Scheme { get; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
public virtual BindingElement Clone();	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

public class HttpTransportBindingElement	public class HttpTransportBindingElement
: TransportBindingElement	: TransportBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport
	public Boolean AllowCookies { get; set; }
	public AuthenticationSchemes AuthenticationScheme { get; set; }
	public Boolean BypassProxyOnLocal { get; set; }
	public Boolean DecompressionEnabled { get; set; }
	public ExtendedProtectionPolicy ExtendedProtectionPolicy { get; set; }
	public HostNameComparisonMode HostNameComparisonMode { get; set; }
	public Boolean KeepAliveEnabled { get; set; }
public Int32 MaxBufferSize { get; set; }	public Int32 MaxBufferSize { get; set; }
	public HttpMessageHandlerFactory MessageHandlerFactory { get; set; }
	public Uri ProxyAddress { get; set; }
	public AuthenticationSchemes ProxyAuthenticationScheme { get; set; }
	public String Realm { get; set; }
public virtual String Scheme { get; }	public virtual String Scheme { get; }
public TransferMode TransferMode { get; set; }	public TransferMode TransferMode { get; set; }
	public Boolean UnsafeConnectionNtlmAuthentication { get; set; }
	public Boolean UseDefaultWebProxy { get; set; }
	public WebSocketSettings WebSocketSettings { get; set; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
public virtual Boolean CanBuildChannelFactory(BindingContext context);	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	static protected Boolean CheckAsynchronousSendEnabled(BindingContext context);
public virtual BindingElement Clone();	public virtual BindingElement Clone();
public virtual T GetProperty(BindingContext context);	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeExtendedProtectionPolicy();

	public abstract interface IAnonymousUriPrefixMatcher

	public abstract virtual void Register(Uri anonymousUriPrefix);

	public abstract interface IBindingDeliveryCapabilities

	public abstract virtual Boolean AssuresOrderedDelivery { get; }
	public abstract virtual Boolean QueuedDelivery { get; }

	public abstract interface IBindingMulticastCapabilities

	public abstract virtual Boolean IsMulticast { get; }

	public abstract interface IBindingRuntimePreferences

	public abstract virtual Boolean ReceiveSynchronously { get; }

public abstract interface IChannel	public abstract interface IChannel
: ICommunicationObject
public abstract virtual T GetProperty();
	public abstract virtual String ChannelName { get; }
	public abstract virtual Int32 ChannelPriority { get; }

	public abstract interface IChannel
	: ICommunicationObject
	public abstract virtual T GetProperty();

	public abstract interface IChannelDataStore

	public abstract virtual String ChannelUris { get; }
	public abstract virtual Object Item { get; set; }

public abstract interface IChannelFactory	public abstract interface IChannelFactory
: ICommunicationObject	: ICommunicationObject
public abstract virtual T GetProperty();	public abstract virtual T GetProperty();

public abstract interface IChannelFactory`1<TChannel>	public abstract interface IChannelFactory`1<TChannel>
: IChannelFactory, ICommunicationObject	: IChannelFactory, ICommunicationObject
public abstract virtual TChannel CreateChannel(EndpointAddress to);	public abstract virtual TChannel CreateChannel(EndpointAddress to);
public abstract virtual TChannel CreateChannel(EndpointAddress to, Uri via);	public abstract virtual TChannel CreateChannel(EndpointAddress to, Uri via);

	public abstract interface IChannelListener
	: ICommunicationObject
	public abstract virtual Uri Uri { get; }
	public abstract virtual IAsyncResult BeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, Object state);
	public abstract virtual Boolean EndWaitForChannel(IAsyncResult result);
	public abstract virtual T GetProperty();
	public abstract virtual Boolean WaitForChannel(TimeSpan timeout);

	public abstract interface IChannelListener`1<TChannel>
	: IChannelListener, ICommunicationObject where TChannel : IChannel
	public abstract virtual TChannel AcceptChannel();
	public abstract virtual TChannel AcceptChannel(TimeSpan timeout);
	public abstract virtual IAsyncResult BeginAcceptChannel(AsyncCallback callback, Object state);
	public abstract virtual IAsyncResult BeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, Object state);
	public abstract virtual TChannel EndAcceptChannel(IAsyncResult result);

	public abstract interface IChannelReceiver
	: IChannel
	public abstract virtual Object ChannelData { get; }
	public abstract virtual String GetUrlsForUri(String objectURI);
	public abstract virtual void StartListening(Object data);
	public abstract virtual void StopListening(Object data);

	public abstract interface IChannelReceiverHook

	public abstract virtual String ChannelScheme { get; }
	public abstract virtual IServerChannelSink ChannelSinkChain { get; }
	public abstract virtual Boolean WantsToListen { get; }
	public abstract virtual void AddHookChannelUri(String channelUri);

	public abstract interface IChannelSender
	: IChannel
	public abstract virtual IMessageSink CreateMessageSink(String url, Object remoteChannelData, out String& objectURI);

	public abstract interface IChannelSinkBase

	public abstract virtual IDictionary Properties { get; }

	public abstract interface IClientChannelSink
	: IChannelSinkBase
	public abstract virtual IClientChannelSink NextChannelSink { get; }
	public abstract virtual void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream);
	public abstract virtual void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, Object state, ITransportHeaders headers, Stream stream);
	public abstract virtual Stream GetRequestStream(IMessage msg, ITransportHeaders headers);
	public abstract virtual void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders& responseHeaders, out Stream& responseStream);

	public abstract interface IClientChannelSinkProvider

	public abstract virtual IClientChannelSinkProvider Next { get; set; }
	public abstract virtual IClientChannelSink CreateSink(IChannelSender channel, String url, Object remoteChannelData);

	public abstract interface IClientChannelSinkStack
	: IClientResponseChannelSinkStack
	public abstract virtual Object Pop(IClientChannelSink sink);
	public abstract virtual void Push(IClientChannelSink sink, Object state);

	public abstract interface IClientFormatterSink
	: IMessageSink, IClientChannelSink, IChannelSinkBase

	public abstract interface IClientFormatterSinkProvider
	: IClientChannelSinkProvider

	public abstract interface IClientResponseChannelSinkStack

	public abstract virtual void AsyncProcessResponse(ITransportHeaders headers, Stream stream);
	public abstract virtual void DispatchException(Exception e);
	public abstract virtual void DispatchReplyMessage(IMessage msg);

	public abstract interface IContextBindingElement

	public abstract interface IContextManager

	public abstract virtual Boolean Enabled { get; set; }
	public abstract virtual IDictionary`2<String, String> GetContext();
	public abstract virtual void SetContext(IDictionary`2<String, String> context);

	public abstract interface ICorrelationDataSource

	public abstract virtual ICollection`1<CorrelationDataDescription> DataSources { get; }

abstract class CommunicationPool`2+IdleConnectionPool<TKey, TItem>

public abstract virtual Int32 Count { get; }
public abstract virtual Boolean Add(TItem item);
public abstract virtual Boolean Return(TItem item);
public abstract virtual TItem Take(out Boolean& closeItem);

class IdlingCommunicationPool`2+IdleTimeoutEndpointConnectionPool<TKey, TItem>
: EndpointConnectionPool<TKey, TItem>
public virtual void Prune(List`1<TItem> itemsToClose);

class IdleTimeoutEndpointConnectionPool+IdleTimeoutIdleConnectionPool<TKey, TItem>
: PoolIdleConnectionPool<TKey, TItem>
public virtual Boolean Add(TItem connection);
public void OnItemClosing(TItem connection);
public void Prune(List`1<TItem> itemsToClose, Boolean calledFromTimer);
public virtual Boolean Return(TItem connection);
public virtual TItem Take(out Boolean& closeItem);

	abstract class CommunicationPool`2<TKey, TItem>

	public abstract virtual Int32 Count { get; }
	public abstract virtual Boolean Add(TItem item);
	public abstract virtual Boolean Return(TItem item);
	public abstract virtual TItem Take(out Boolean& closeItem);

	class IdlingCommunicationPool`2<TKey, TItem>
	: EndpointConnectionPool<TKey, TItem>
	protected virtual void AbortItem(TItem item);
	protected virtual void CloseItem(TItem item, TimeSpan timeout);
	protected virtual void CloseItemAsync(TItem item, TimeSpan timeout);
	protected virtual IdleConnectionPool<TKey, TItem> GetIdleConnectionPool();
	public virtual void Prune(List`1<TItem> itemsToClose);

	class IdleTimeoutEndpointConnectionPool<TKey, TItem>
	: PoolIdleConnectionPool<TKey, TItem>
	public virtual Boolean Add(TItem connection);
	public void OnItemClosing(TItem connection);
	public void Prune(List`1<TItem> itemsToClose, Boolean calledFromTimer);
	public virtual Boolean Return(TItem connection);
	public virtual TItem Take(out Boolean& closeItem);

public abstract interface IDuplexChannel	public abstract interface IDuplexChannel
: IInputChannel, IChannel, ICommunicationObject, IOutputChannel	: IInputChannel, IChannel, ICommunicationObject, IOutputChannel

public abstract interface IDuplexSession	public abstract interface IDuplexSession
: IInputSession, ISession, IOutputSession	: IInputSession, ISession, IOutputSession
public abstract virtual IAsyncResult BeginCloseOutputSession(AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginCloseOutputSession(AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual void CloseOutputSession();	public abstract virtual void CloseOutputSession();
public abstract virtual void CloseOutputSession(TimeSpan timeout);	public abstract virtual void CloseOutputSession(TimeSpan timeout);
public abstract virtual void EndCloseOutputSession(IAsyncResult result);	public abstract virtual void EndCloseOutputSession(IAsyncResult result);

public abstract interface IDuplexSessionChannel	public abstract interface IDuplexSessionChannel
: IDuplexChannel, IInputChannel, IChannel, ICommunicationObject, IOutputChannel, ISessionChannel`1<IDuplexSession>	: IDuplexChannel, IInputChannel, IChannel, ICommunicationObject, IOutputChannel, ISessionChannel`1<IDuplexSession>

public abstract interface IHttpCookieContainerManager	public abstract interface IHttpCookieContainerManager

public abstract virtual CookieContainer CookieContainer { get; set; }	public abstract virtual CookieContainer CookieContainer { get; set; }

public abstract interface IInputChannel	public abstract interface IInputChannel
: IChannel, ICommunicationObject	: IChannel, ICommunicationObject
public abstract virtual EndpointAddress LocalAddress { get; }	public abstract virtual EndpointAddress LocalAddress { get; }
public abstract virtual IAsyncResult BeginReceive(AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginReceive(AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual Message EndReceive(IAsyncResult result);	public abstract virtual Message EndReceive(IAsyncResult result);
public abstract virtual Boolean EndTryReceive(IAsyncResult result, out Message& message);	public abstract virtual Boolean EndTryReceive(IAsyncResult result, out Message& message);
public abstract virtual Boolean EndWaitForMessage(IAsyncResult result);	public abstract virtual Boolean EndWaitForMessage(IAsyncResult result);
public abstract virtual Message Receive();	public abstract virtual Message Receive();
public abstract virtual Message Receive(TimeSpan timeout);	public abstract virtual Message Receive(TimeSpan timeout);
public abstract virtual Boolean TryReceive(TimeSpan timeout, out Message& message);	public abstract virtual Boolean TryReceive(TimeSpan timeout, out Message& message);
public abstract virtual Boolean WaitForMessage(TimeSpan timeout);	public abstract virtual Boolean WaitForMessage(TimeSpan timeout);

public abstract interface IInputSession	public abstract interface IInputSession
: ISession	: ISession

public abstract interface IInputSessionChannel	public abstract interface IInputSessionChannel
: IInputChannel, IChannel, ICommunicationObject, ISessionChannel`1<IInputSession>	: IInputChannel, IChannel, ICommunicationObject, ISessionChannel`1<IInputSession>

public abstract interface IMessageProperty	public abstract interface IMessageProperty

public abstract virtual IMessageProperty CreateCopy();	public abstract virtual IMessageProperty CreateCopy();

	abstract class ReliableChannelBinder`1<TChannel, TBinder>
	: AsyncResult, IAsyncResult where TChannel : IChannel, TBinder : ReliableChannelBinder`1
	protected abstract virtual IAsyncResult BeginInput(TBinder binder, TChannel channel, TimeSpan timeout, AsyncCallback callback, Object state);
	public Boolean End();
	protected abstract virtual Boolean EndInput(TBinder binder, TChannel channel, IAsyncResult result, out Boolean& complete);
	protected Boolean Start();

	class CryptoApiBlob

	public class InvalidChannelBindingException
	: Exception, ISerializable, _Exception

public abstract interface IOutputChannel	public abstract interface IOutputChannel
: IChannel, ICommunicationObject	: IChannel, ICommunicationObject
public abstract virtual EndpointAddress RemoteAddress { get; }	public abstract virtual EndpointAddress RemoteAddress { get; }
public abstract virtual Uri Via { get; }	public abstract virtual Uri Via { get; }
public abstract virtual IAsyncResult BeginSend(Message message, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginSend(Message message, AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual void EndSend(IAsyncResult result);	public abstract virtual void EndSend(IAsyncResult result);
public abstract virtual void Send(Message message);	public abstract virtual void Send(Message message);
public abstract virtual void Send(Message message, TimeSpan timeout);	public abstract virtual void Send(Message message, TimeSpan timeout);

public abstract interface IOutputSession	public abstract interface IOutputSession
: ISession	: ISession

public abstract interface IOutputSessionChannel	public abstract interface IOutputSessionChannel
: IOutputChannel, IChannel, ICommunicationObject, ISessionChannel`1<IOutputSession>	: IOutputChannel, IChannel, ICommunicationObject, ISessionChannel`1<IOutputSession>

	public abstract interface IReceiveContextSettings

	public abstract virtual Boolean Enabled { get; set; }
	public abstract virtual TimeSpan ValidityDuration { get; }

	public abstract interface IReplyChannel
	: IChannel, ICommunicationObject
	public abstract virtual EndpointAddress LocalAddress { get; }
	public abstract virtual IAsyncResult BeginReceiveRequest(AsyncCallback callback, Object state);
	public abstract virtual IAsyncResult BeginReceiveRequest(TimeSpan timeout, AsyncCallback callback, Object state);
	public abstract virtual IAsyncResult BeginTryReceiveRequest(TimeSpan timeout, AsyncCallback callback, Object state);
	public abstract virtual IAsyncResult BeginWaitForRequest(TimeSpan timeout, AsyncCallback callback, Object state);
	public abstract virtual RequestContext EndReceiveRequest(IAsyncResult result);
	public abstract virtual Boolean EndTryReceiveRequest(IAsyncResult result, out RequestContext& context);
	public abstract virtual Boolean EndWaitForRequest(IAsyncResult result);
	public abstract virtual RequestContext ReceiveRequest();
	public abstract virtual RequestContext ReceiveRequest(TimeSpan timeout);
	public abstract virtual Boolean TryReceiveRequest(TimeSpan timeout, out RequestContext& context);
	public abstract virtual Boolean WaitForRequest(TimeSpan timeout);

	public abstract interface IReplySessionChannel
	: IReplyChannel, IChannel, ICommunicationObject, ISessionChannel`1<IInputSession>

public abstract interface IRequestChannel	public abstract interface IRequestChannel
: IChannel, ICommunicationObject	: IChannel, ICommunicationObject
public abstract virtual EndpointAddress RemoteAddress { get; }	public abstract virtual EndpointAddress RemoteAddress { get; }
public abstract virtual Uri Via { get; }	public abstract virtual Uri Via { get; }
public abstract virtual IAsyncResult BeginRequest(Message message, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginRequest(Message message, AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual Message EndRequest(IAsyncResult result);	public abstract virtual Message EndRequest(IAsyncResult result);
public abstract virtual Message Request(Message message);	public abstract virtual Message Request(Message message);
public abstract virtual Message Request(Message message, TimeSpan timeout);	public abstract virtual Message Request(Message message, TimeSpan timeout);

public abstract interface IRequestSessionChannel	public abstract interface IRequestSessionChannel
: IRequestChannel, IChannel, ICommunicationObject, ISessionChannel`1<IOutputSession>	: IRequestChannel, IChannel, ICommunicationObject, ISessionChannel`1<IOutputSession>

	public abstract interface ISecurableChannel

	public abstract virtual Boolean IsSecured { get; set; }

	public abstract interface ISecurityCapabilities

	public abstract virtual ProtectionLevel SupportedRequestProtectionLevel { get; }
	public abstract virtual ProtectionLevel SupportedResponseProtectionLevel { get; }
	public abstract virtual Boolean SupportsClientAuthentication { get; }
	public abstract virtual Boolean SupportsClientWindowsIdentity { get; }
	public abstract virtual Boolean SupportsServerAuthentication { get; }

	public abstract interface IServerChannelSink
	: IChannelSinkBase
	public abstract virtual IServerChannelSink NextChannelSink { get; }
	public abstract virtual void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state, IMessage msg, ITransportHeaders headers, Stream stream);
	public abstract virtual Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state, IMessage msg, ITransportHeaders headers);
	public abstract virtual ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage& responseMsg, out ITransportHeaders& responseHeaders, out Stream& responseStream);

	public abstract interface IServerChannelSinkProvider

	public abstract virtual IServerChannelSinkProvider Next { get; set; }
	public abstract virtual IServerChannelSink CreateSink(IChannelReceiver channel);
	public abstract virtual void GetChannelData(IChannelDataStore channelData);

	public abstract interface IServerChannelSinkStack
	: IServerResponseChannelSinkStack
	public abstract virtual Object Pop(IServerChannelSink sink);
	public abstract virtual void Push(IServerChannelSink sink, Object state);
	public abstract virtual void ServerCallback(IAsyncResult ar);
	public abstract virtual void Store(IServerChannelSink sink, Object state);
	public abstract virtual void StoreAndDispatch(IServerChannelSink sink, Object state);

	public abstract interface IServerFormatterSinkProvider
	: IServerChannelSinkProvider

	public abstract interface IServerResponseChannelSinkStack

	public abstract virtual void AsyncProcessResponse(IMessage msg, ITransportHeaders headers, Stream stream);
	public abstract virtual Stream GetResponseStream(IMessage msg, ITransportHeaders headers);

public abstract interface ISession	public abstract interface ISession

public abstract virtual String Id { get; }	public abstract virtual String Id { get; }

public abstract interface ISessionChannel`1<TSession>	public abstract interface ISessionChannel`1<TSession>
where TSession : ISession	where TSession : ISession
public abstract virtual TSession Session { get; }	public abstract virtual TSession Session { get; }

	public abstract interface ITransactedBindingElement

	public abstract virtual Boolean TransactedReceiveEnabled { get; }

	public abstract interface ITransportHeaders

	public abstract virtual Object Item { get; set; }
	public abstract virtual IEnumerator GetEnumerator();

	public abstract interface ITransportTokenAssertionProvider

	public abstract virtual XmlElement GetTransportTokenAssertion();

	abstract interface ChannelSynchronizer<TChannel>
	where TChannel : IChannel
	public abstract virtual Boolean CanGetChannel { get; }
	public abstract virtual void Close();
	public abstract virtual void Fault();
	public abstract virtual void GetChannel(Boolean onUserThread);
	public abstract virtual void Set(TChannel channel);

public sealed class LocalClientSecuritySettings	public sealed class LocalClientSecuritySettings

	public Boolean CacheCookies { get; set; }
	public Int32 CookieRenewalThresholdPercentage { get; set; }
	public Boolean DetectReplays { get; set; }
	public IdentityVerifier IdentityVerifier { get; set; }
public TimeSpan MaxClockSkew { get; set; }	public TimeSpan MaxClockSkew { get; set; }
	public TimeSpan MaxCookieCachingTime { get; set; }
	public NonceCache NonceCache { get; set; }
	public Boolean ReconnectTransportOnFailure { get; set; }
	public Int32 ReplayCacheSize { get; set; }
public TimeSpan ReplayWindow { get; set; }	public TimeSpan ReplayWindow { get; set; }
	public TimeSpan SessionKeyRenewalInterval { get; set; }
	public TimeSpan SessionKeyRolloverInterval { get; set; }
public TimeSpan TimestampValidityDuration { get; set; }	public TimeSpan TimestampValidityDuration { get; set; }
public LocalClientSecuritySettings Clone();	public LocalClientSecuritySettings Clone();

	public sealed class LocalServiceSecuritySettings

	public Boolean DetectReplays { get; set; }
	public TimeSpan InactivityTimeout { get; set; }
	public TimeSpan IssuedCookieLifetime { get; set; }
	public Int32 MaxCachedCookies { get; set; }
	public TimeSpan MaxClockSkew { get; set; }
	public Int32 MaxPendingSessions { get; set; }
	public Int32 MaxStatefulNegotiations { get; set; }
	public TimeSpan NegotiationTimeout { get; set; }
	public NonceCache NonceCache { get; set; }
	public Boolean ReconnectTransportOnFailure { get; set; }
	public Int32 ReplayCacheSize { get; set; }
	public TimeSpan ReplayWindow { get; set; }
	public TimeSpan SessionKeyRenewalInterval { get; set; }
	public TimeSpan SessionKeyRolloverInterval { get; set; }
	public TimeSpan TimestampValidityDuration { get; set; }
	public LocalServiceSecuritySettings Clone();

	sealed struct UnsafeNativeMethods
	: ValueType

public abstract class Message	public abstract class Message
: IDisposable	: IDisposable
public abstract virtual MessageHeaders Headers { get; }	public abstract virtual MessageHeaders Headers { get; }
	protected Boolean IsDisposed { get; }
public virtual Boolean IsEmpty { get; }	public virtual Boolean IsEmpty { get; }
public virtual Boolean IsFault { get; }	public virtual Boolean IsFault { get; }
public abstract virtual MessageProperties Properties { get; }	public abstract virtual MessageProperties Properties { get; }
public MessageState State { get; }	public MessageState State { get; }
public abstract virtual MessageVersion Version { get; }	public abstract virtual MessageVersion Version { get; }
	public IAsyncResult BeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, Object state);
	public IAsyncResult BeginWriteMessage(XmlDictionaryWriter writer, AsyncCallback callback, Object state);
public void Close();	public void Close();
	public MessageBuffer CreateBufferedCopy(Int32 maxBufferSize);
static public Message CreateMessage(MessageVersion version, String action, Object body);	static public Message CreateMessage(MessageVersion version, String action, Object body);
static public Message CreateMessage(MessageVersion version, String action, Object body, XmlObjectSerializer serializer);	static public Message CreateMessage(MessageVersion version, String action, Object body, XmlObjectSerializer serializer);
static public Message CreateMessage(MessageVersion version, String action, XmlReader body);	static public Message CreateMessage(MessageVersion version, String action, XmlReader body);
static public Message CreateMessage(MessageVersion version, String action, XmlDictionaryReader body);	static public Message CreateMessage(MessageVersion version, String action, XmlDictionaryReader body);
static public Message CreateMessage(MessageVersion version, String action, BodyWriter body);	static public Message CreateMessage(MessageVersion version, String action, BodyWriter body);
static public Message CreateMessage(MessageVersion version, String action);	static public Message CreateMessage(MessageVersion version, String action);
static public Message CreateMessage(XmlReader envelopeReader, Int32 maxSizeOfHeaders, MessageVersion version);	static public Message CreateMessage(XmlReader envelopeReader, Int32 maxSizeOfHeaders, MessageVersion version);
static public Message CreateMessage(XmlDictionaryReader envelopeReader, Int32 maxSizeOfHeaders, MessageVersion version);	static public Message CreateMessage(XmlDictionaryReader envelopeReader, Int32 maxSizeOfHeaders, MessageVersion version);
	static public Message CreateMessage(MessageVersion version, FaultCode faultCode, String reason, String action);
	static public Message CreateMessage(MessageVersion version, FaultCode faultCode, String reason, Object detail, String action);
	static public Message CreateMessage(MessageVersion version, MessageFault fault, String action);
	public void EndWriteBodyContents(IAsyncResult result);
	public void EndWriteMessage(IAsyncResult result);
public T GetBody();	public T GetBody();
public T GetBody(XmlObjectSerializer serializer);	public T GetBody(XmlObjectSerializer serializer);
public String GetBodyAttribute(String localName, String ns);	public String GetBodyAttribute(String localName, String ns);
public XmlDictionaryReader GetReaderAtBodyContents();	public XmlDictionaryReader GetReaderAtBodyContents();
	protected virtual IAsyncResult OnBeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, Object state);
	protected virtual IAsyncResult OnBeginWriteMessage(XmlDictionaryWriter writer, AsyncCallback callback, Object state);
	protected virtual void OnBodyToString(XmlDictionaryWriter writer);
	protected virtual void OnClose();
	protected virtual MessageBuffer OnCreateBufferedCopy(Int32 maxBufferSize);
	protected virtual void OnEndWriteBodyContents(IAsyncResult result);
	protected virtual void OnEndWriteMessage(IAsyncResult result);
	protected virtual T OnGetBody(XmlDictionaryReader reader);
	protected virtual String OnGetBodyAttribute(String localName, String ns);
	protected virtual XmlDictionaryReader OnGetReaderAtBodyContents();
	protected abstract virtual 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);
public virtual String ToString();	public virtual String ToString();
public void WriteBody(XmlWriter writer);	public void WriteBody(XmlWriter writer);
public void WriteBody(XmlDictionaryWriter writer);	public void WriteBody(XmlDictionaryWriter writer);
public void WriteBodyContents(XmlDictionaryWriter writer);	public void WriteBodyContents(XmlDictionaryWriter writer);
public void WriteMessage(XmlWriter writer);	public void WriteMessage(XmlWriter writer);
public void WriteMessage(XmlDictionaryWriter writer);	public void WriteMessage(XmlDictionaryWriter writer);
public void WriteStartBody(XmlWriter writer);	public void WriteStartBody(XmlWriter writer);
public void WriteStartBody(XmlDictionaryWriter writer);	public void WriteStartBody(XmlDictionaryWriter writer);
public void WriteStartEnvelope(XmlDictionaryWriter writer);	public void WriteStartEnvelope(XmlDictionaryWriter writer);

	sealed class PeerNodeImplementation
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(Message message, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(Message message);

public abstract class MessageBuffer	public abstract class MessageBuffer
: IDisposable	: IXPathNavigable, IDisposable
public abstract virtual Int32 BufferSize { get; }	public abstract virtual Int32 BufferSize { get; }
public virtual String MessageContentType { get; }	public virtual String MessageContentType { get; }
public abstract virtual void Close();	public abstract virtual void Close();
public abstract virtual Message CreateMessage();	public abstract virtual Message CreateMessage();
	public virtual XPathNavigator CreateNavigator();
	public XPathNavigator CreateNavigator(Int32 nodeQuota);
	public XPathNavigator CreateNavigator(XmlSpace space);
	public XPathNavigator CreateNavigator(Int32 nodeQuota, XmlSpace space);
public virtual void WriteMessage(Stream stream);	public virtual void WriteMessage(Stream stream);

public abstract class MessageEncoderFactory	public abstract class MessageEncoderFactory

public abstract virtual MessageEncoder Encoder { get; }	public abstract virtual MessageEncoder Encoder { get; }
public abstract virtual MessageVersion MessageVersion { get; }	public abstract virtual MessageVersion MessageVersion { get; }
public virtual MessageEncoder CreateSessionEncoder();	public virtual MessageEncoder CreateSessionEncoder();

public abstract class MessageEncodingBindingElement	public abstract class MessageEncodingBindingElement
: BindingElement	: BindingElement
public abstract virtual MessageVersion MessageVersion { get; set; }	public abstract virtual MessageVersion MessageVersion { get; set; }
public abstract virtual MessageEncoderFactory CreateMessageEncoderFactory();	public abstract virtual MessageEncoderFactory CreateMessageEncoderFactory();
public virtual T GetProperty(BindingContext context);	public virtual T GetProperty(BindingContext context);

	public class MessageEncodingBindingElementImporter
	: IWsdlImportExtension, IPolicyImportExtension

public abstract class MessageFault	public abstract class MessageFault

public virtual String Actor { get; }	public virtual String Actor { get; }
public abstract virtual FaultCode Code { get; }	public abstract virtual FaultCode Code { get; }
public abstract virtual Boolean HasDetail { get; }	public abstract virtual Boolean HasDetail { get; }
	public Boolean IsMustUnderstandFault { get; }
public virtual String Node { get; }	public virtual String Node { get; }
public abstract virtual FaultReason Reason { get; }	public abstract virtual FaultReason Reason { get; }
	static public MessageFault CreateFault(FaultCode code, String reason);
	static public MessageFault CreateFault(FaultCode code, FaultReason reason);
	static public MessageFault CreateFault(FaultCode code, FaultReason reason, Object detail);
	static public MessageFault CreateFault(FaultCode code, FaultReason reason, Object detail, XmlObjectSerializer serializer);
	static public MessageFault CreateFault(FaultCode code, FaultReason reason, Object detail, XmlObjectSerializer serializer, String actor);
	static public MessageFault CreateFault(FaultCode code, FaultReason reason, Object detail, XmlObjectSerializer serializer, String actor, String node);
static public MessageFault CreateFault(Message message, Int32 maxBufferSize);	static public MessageFault CreateFault(Message message, Int32 maxBufferSize);
public T GetDetail();	public T GetDetail();
public T GetDetail(XmlObjectSerializer serializer);	public T GetDetail(XmlObjectSerializer serializer);
public XmlDictionaryReader GetReaderAtDetailContents();	public XmlDictionaryReader GetReaderAtDetailContents();
	protected virtual XmlDictionaryReader OnGetReaderAtDetailContents();
	protected virtual void OnWriteDetail(XmlDictionaryWriter writer, EnvelopeVersion version);
	protected abstract virtual void OnWriteDetailContents(XmlDictionaryWriter writer);
	protected virtual void OnWriteStartDetail(XmlDictionaryWriter writer, EnvelopeVersion version);
	static public Boolean WasHeaderNotUnderstood(MessageHeaders headers, String name, String ns);
	public void WriteTo(XmlWriter writer, EnvelopeVersion version);

public abstract class MessageHeaderInfo	public abstract class MessageHeaderInfo

public abstract virtual String Actor { get; }	public abstract virtual String Actor { get; }
public abstract virtual Boolean IsReferenceParameter { get; }	public abstract virtual Boolean IsReferenceParameter { get; }
public abstract virtual Boolean MustUnderstand { get; }	public abstract virtual Boolean MustUnderstand { get; }
public abstract virtual String Name { get; }	public abstract virtual String Name { get; }
public abstract virtual String Namespace { get; }	public abstract virtual String Namespace { get; }
public abstract virtual Boolean Relay { get; }	public abstract virtual Boolean Relay { get; }

public sealed enum MessageState	public sealed enum MessageState
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Created, Read, Written, Copied, Closed }	{ Created, Read, Written, Copied, Closed }

	sealed enum MsmqQueue
	: IComparable, IFormattable, IConvertible
	{ Unknown, Succeeded, MessageNotFound, MessageLockedUnderTransaction }

	class UnsafeNativeMethods

	sealed class UnsafeNativeMethods
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(Int32 error, IntPtr handle, Int32 timeout, Int32 action, IntPtr props, NativeOverlapped nativeOverlapped, IntPtr cursor, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(Int32 error, IntPtr handle, Int32 timeout, Int32 action, IntPtr props, NativeOverlapped nativeOverlapped, IntPtr cursor);

	public abstract class MsmqBindingElementBase
	: TransportBindingElement, ITransactedBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport
	public Uri CustomDeadLetterQueue { get; set; }
	public DeadLetterQueue DeadLetterQueue { get; set; }
	public Boolean Durable { get; set; }
	public Boolean ExactlyOnce { get; set; }
	public Int32 MaxRetryCycles { get; set; }
	public MsmqTransportSecurity MsmqTransportSecurity { get; set; }
	public Boolean ReceiveContextEnabled { get; set; }
	public ReceiveErrorHandling ReceiveErrorHandling { get; set; }
	public Int32 ReceiveRetryCount { get; set; }
	public TimeSpan RetryCycleDelay { get; set; }
	public TimeSpan TimeToLive { get; set; }
	public virtual Boolean TransactedReceiveEnabled { get; }
	public Boolean UseMsmqTracing { get; set; }
	public Boolean UseSourceJournal { get; set; }
	public TimeSpan ValidityDuration { get; set; }
	public virtual T GetProperty(BindingContext context);

	public sealed class MsmqMessageProperty

	public Int32 AbortCount { get; set; }
	public Nullable`1<DeliveryFailure> DeliveryFailure { get; }
	public Nullable`1<DeliveryStatus> DeliveryStatus { get; }
	public Int32 MoveCount { get; set; }
	static public MsmqMessageProperty Get(Message message);

	abstract class NativeMsmqMessage
	: IDisposable
	protected Int32 Index { get; }
	public virtual Object MaintainedBuffer { get; }
	public virtual Boolean MaintainsBuffer { get; }
	protected MQPROPVARIANT Variants { get; }
	public virtual void Dispose();
	public virtual void Pin();
	public virtual void Unpin();

	public sealed class MsmqTransportBindingElement
	: MsmqBindingElementBase, ITransactedBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport
	public Int32 MaxPoolSize { get; set; }
	public QueueTransferProtocol QueueTransferProtocol { get; set; }
	public virtual String Scheme { get; }
	public Boolean UseActiveDirectory { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();

	public sealed class MtomMessageEncodingBindingElement
	: MessageEncodingBindingElement, IWsdlExportExtension, IPolicyExportExtension
	public Int32 MaxBufferSize { get; set; }
	public Int32 MaxReadPoolSize { get; set; }
	public Int32 MaxWritePoolSize { get; set; }
	public virtual MessageVersion MessageVersion { get; set; }
	public XmlDictionaryReaderQuotas ReaderQuotas { get; }
	public Encoding WriteEncoding { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual MessageEncoderFactory CreateMessageEncoderFactory();
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeMessageVersion();
	public Boolean ShouldSerializeReaderQuotas();
	public Boolean ShouldSerializeWriteEncoding();

	public sealed class NamedPipeConnectionPoolSettings

	public String GroupName { get; set; }
	public TimeSpan IdleTimeout { get; set; }
	public Int32 MaxOutboundConnectionsPerEndpoint { get; set; }

	class NamedPipeConnectionPool
	: IdleTimeoutEndpointConnectionPool<String, IConnection>
	protected virtual void OnConnectionAborted();

	public sealed class NamedPipeSettings

	public ApplicationContainerSettings ApplicationContainerSettings { get; set; }

	public class NamedPipeTransportBindingElement
	: ConnectionOrientedTransportBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport
	public NamedPipeConnectionPoolSettings ConnectionPoolSettings { get; }
	public NamedPipeSettings PipeSettings { get; }
	public virtual String Scheme { get; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

	public sealed class OneWayBindingElement
	: BindingElement, IPolicyExportExtension
	public ChannelPoolSettings ChannelPoolSettings { get; set; }
	public Int32 MaxAcceptedChannels { get; set; }
	public Boolean PacketRoutable { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeChannelPoolSettings();

	public class OneWayBindingElementImporter
	: IPolicyImportExtension

	class PeerSecurityCredentialsManager
	: SecurityTokenManager
	public virtual SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver& outOfBandTokenResolver);
	public virtual SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement);
	public virtual SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version);
	public virtual Boolean Equals(Object other);
	public virtual Int32 GetHashCode();

	class UnsafePnrpNativeMethods
	: DiscoveryBase, IDisposable
	static public CloudInfo GetClouds();

	public sealed class PeerCustomResolverBindingElement
	: PeerResolverBindingElement
	public EndpointAddress Address { get; set; }
	public Binding Binding { get; set; }
	public virtual PeerReferralPolicy ReferralPolicy { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual PeerResolver CreatePeerResolver();
	public virtual T GetProperty(BindingContext context);

	class PeerMessageDispatcher`2<ChannelInterfaceType, TChannel>
	where ChannelInterfaceType : IChannel, TChannel : InputQueueChannel`1
	public void EnqueueAndDispatch(Message message, Action callback);

	public abstract class PeerResolverBindingElement
	: BindingElement
	public abstract virtual PeerReferralPolicy ReferralPolicy { get; set; }
	public abstract virtual PeerResolver CreatePeerResolver();

	class PeerFlooderBase`2<TFloodContract, TLinkContract>
	where TFloodContract : Message
	public void AcquireNoQueue();
	public void ItemDequeued();

	public sealed class PeerTransportBindingElement
	: TransportBindingElement, IWsdlExportExtension, ITransportPolicyImport, IPolicyExportExtension
	public IPAddress ListenIPAddress { get; set; }
	public virtual Int64 MaxReceivedMessageSize { get; set; }
	public Int32 Port { get; set; }
	public virtual String Scheme { get; }
	public PeerSecuritySettings Security { get; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

	public sealed class PnrpPeerResolverBindingElement
	: PeerResolverBindingElement
	public virtual PeerReferralPolicy ReferralPolicy { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual PeerResolver CreatePeerResolver();
	public virtual T GetProperty(BindingContext context);

public class PollingDuplexBindingElement
: BindingElement, IPollingDuplexFactorySettings, IPollingDuplexSettings
public virtual TimeSpan ClientPollTimeout { get; set; }
public virtual PollingDuplexMode DuplexMode { get; set; }
public virtual TimeSpan InactivityTimeout { get; set; }
public virtual Int32 MaxPendingMessagesPerSession { get; set; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
public virtual Boolean CanBuildChannelFactory(BindingContext context);
public virtual BindingElement Clone();
public virtual T GetProperty(BindingContext context);

public sealed enum PollingDuplexMode
: IComparable, IFormattable, IConvertible
{ SingleMessagePerPoll, MultipleMessagesPerPoll }

	sealed class ClientReliableSession
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke();

class EndpointConnectionPool+PoolIdleConnectionPool<TKey, TItem>
: IdleConnectionPool<TKey, TItem>
public virtual Int32 Count { get; }
public virtual Boolean Add(TItem connection);
public virtual Boolean Return(TItem connection);
public virtual TItem Take(out Boolean& closeItem);

	class EndpointConnectionPool<TKey, TItem>
	: IdleConnectionPool<TKey, TItem>
	public virtual Int32 Count { get; }
	public virtual Boolean Add(TItem connection);
	public virtual Boolean Return(TItem connection);
	public virtual TItem Take(out Boolean& closeItem);

	public sealed class PrivacyNoticeBindingElement
	: BindingElement, IPolicyExportExtension
	public Uri Url { get; set; }
	public Int32 Version { get; set; }
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

	public sealed class PrivacyNoticeBindingElementImporter
	: IPolicyImportExtension

	sealed class UtilityExtension
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(IPeerNeighbor peer, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(IPeerNeighbor peer);

	class SingletonInputConnectionStream
	: AsyncResult, IAsyncResult
	static public Int32 End(IAsyncResult result);

	class ChannelWrapper`2<TChannel, TItem>
	: AsyncResult, IAsyncResult where TChannel : IChannel, TItem : IDisposable
	static public TItem End(IAsyncResult result);

	public abstract class ReceiveContext

	public ReceiveContextState State { get; set; }
	protected Object ThisLock { get; }
	public event EventHandler Faulted;
	public virtual void Abandon(TimeSpan timeout);
	public virtual void Abandon(Exception exception, TimeSpan timeout);
	public virtual IAsyncResult BeginAbandon(TimeSpan timeout, AsyncCallback callback, Object state);
	public virtual IAsyncResult BeginAbandon(Exception exception, TimeSpan timeout, AsyncCallback callback, Object state);
	public virtual IAsyncResult BeginComplete(TimeSpan timeout, AsyncCallback callback, Object state);
	public virtual void Complete(TimeSpan timeout);
	public virtual void EndAbandon(IAsyncResult result);
	public virtual void EndComplete(IAsyncResult result);
	internal protected virtual void Fault();
	protected abstract virtual void OnAbandon(TimeSpan timeout);
	protected virtual void OnAbandon(Exception exception, TimeSpan timeout);
	protected abstract virtual IAsyncResult OnBeginAbandon(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual IAsyncResult OnBeginAbandon(Exception exception, TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual IAsyncResult OnBeginComplete(TimeSpan timeout, AsyncCallback callback, Object state);
	protected abstract virtual void OnComplete(TimeSpan timeout);
	protected abstract virtual void OnEndAbandon(IAsyncResult result);
	protected abstract virtual void OnEndComplete(IAsyncResult result);
	protected virtual void OnFaulted();
	static public Boolean TryGet(Message message, out ReceiveContext& property);
	static public Boolean TryGet(MessageProperties properties, out ReceiveContext& property);

	public sealed enum ReceiveContextState
	: IComparable, IFormattable, IConvertible
	{ Received, Completing, Completed, Abandoning, Abandoned, Faulted }

	public class RedirectionDuration

	public String Namespace { get; set; }
	static public RedirectionDuration Permanent { get; }
	static public RedirectionDuration Temporary { get; }
	public String Value { get; set; }
	static public RedirectionDuration Create(String duration, String ns);
	public virtual Boolean Equals(Object obj);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(RedirectionDuration left, RedirectionDuration right);
	static public Boolean op_Inequality(RedirectionDuration left, RedirectionDuration right);
	public virtual String ToString();

	public class RedirectionException
	: CommunicationException, ISerializable, _Exception
	public RedirectionDuration Duration { get; set; }
	public IEnumerable`1<RedirectionLocation> Locations { get; set; }
	public RedirectionScope Scope { get; set; }
	public RedirectionType Type { get; set; }
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);

	public class RedirectionLocation

	public Uri Address { get; set; }

	public class RedirectionScope

	static public RedirectionScope Endpoint { get; }
	static public RedirectionScope Message { get; }
	public String Namespace { get; set; }
	static public RedirectionScope Session { get; }
	public String Value { get; set; }
	static public RedirectionScope Create(String scope, String ns);
	public virtual Boolean Equals(Object obj);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(RedirectionScope left, RedirectionScope right);
	static public Boolean op_Inequality(RedirectionScope left, RedirectionScope right);
	public virtual String ToString();

	public sealed class RedirectionType

	static public RedirectionType Cache { get; }
	public String Namespace { get; set; }
	static public RedirectionType Resource { get; }
	static public RedirectionType UseIntermediary { get; }
	public String Value { get; set; }
	static public RedirectionType Create(String type, String ns);
	public virtual Boolean Equals(Object obj);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(RedirectionType left, RedirectionType right);
	static public Boolean op_Inequality(RedirectionType left, RedirectionType right);
	public virtual String ToString();

	public sealed class ReliableSessionBindingElement
	: BindingElement, IPolicyExportExtension
	public TimeSpan AcknowledgementInterval { get; set; }
	public Boolean FlowControlEnabled { get; set; }
	public TimeSpan InactivityTimeout { get; set; }
	public Int32 MaxPendingChannels { get; set; }
	public Int32 MaxRetryCount { get; set; }
	public Int32 MaxTransferWindowSize { get; set; }
	public Boolean Ordered { get; set; }
	public ReliableMessagingVersion ReliableMessagingVersion { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

	public sealed class ReliableSessionBindingElementImporter
	: IPolicyImportExtension

	public sealed class RemoteEndpointMessageProperty

	public String Address { get; }
	static public String Name { get; }
	public Int32 Port { get; }

public abstract class RequestContext	public abstract class RequestContext
: IDisposable	: IDisposable
public abstract virtual Message RequestMessage { get; }	public abstract virtual Message RequestMessage { get; }
public abstract virtual void Abort();	public abstract virtual void Abort();
public abstract virtual IAsyncResult BeginReply(Message message, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginReply(Message message, AsyncCallback callback, Object state);
public abstract virtual IAsyncResult BeginReply(Message message, TimeSpan timeout, AsyncCallback callback, Object state);	public abstract virtual IAsyncResult BeginReply(Message message, TimeSpan timeout, AsyncCallback callback, Object state);
public abstract virtual void Close();	public abstract virtual void Close();
public abstract virtual void Close(TimeSpan timeout);	public abstract virtual void Close(TimeSpan timeout);
	protected virtual void Dispose(Boolean disposing);
public abstract virtual void EndReply(IAsyncResult result);	public abstract virtual void EndReply(IAsyncResult result);
public abstract virtual void Reply(Message message);	public abstract virtual void Reply(Message message);
public abstract virtual void Reply(Message message, TimeSpan timeout);	public abstract virtual void Reply(Message message, TimeSpan timeout);

	public class RetryException
	: CommunicationException, ISerializable, _Exception

public abstract class SecurityBindingElement	public abstract class SecurityBindingElement
: BindingElement	: BindingElement
	public Boolean AllowInsecureTransport { get; set; }
	public SecurityAlgorithmSuite DefaultAlgorithmSuite { get; set; }
	public Boolean EnableUnsecuredResponse { get; set; }
	public SupportingTokenParameters EndpointSupportingTokenParameters { get; }
public Boolean IncludeTimestamp { get; set; }	public Boolean IncludeTimestamp { get; set; }
	public SecurityKeyEntropyMode KeyEntropyMode { get; set; }
public LocalClientSecuritySettings LocalClientSettings { get; }	public LocalClientSecuritySettings LocalClientSettings { get; }
	public LocalServiceSecuritySettings LocalServiceSettings { get; }
	public MessageSecurityVersion MessageSecurityVersion { get; set; }
	public IDictionary`2<String, SupportingTokenParameters> OperationSupportingTokenParameters { get; }
	public SupportingTokenParameters OptionalEndpointSupportingTokenParameters { get; }
	public IDictionary`2<String, SupportingTokenParameters> OptionalOperationSupportingTokenParameters { get; }
	public Boolean ProtectTokens { get; set; }
	public SecurityHeaderLayout SecurityHeaderLayout { get; set; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	protected abstract virtual IChannelFactory`1<TChannel> BuildChannelFactoryCore(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	protected abstract virtual IChannelListener`1<TChannel> BuildChannelListenerCore(BindingContext context);
public virtual Boolean CanBuildChannelFactory(BindingContext context);	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	static public SymmetricSecurityBindingElement CreateAnonymousForCertificateBindingElement();
	static public TransportSecurityBindingElement CreateCertificateOverTransportBindingElement();
	static public TransportSecurityBindingElement CreateCertificateOverTransportBindingElement(MessageSecurityVersion version);
	static public AsymmetricSecurityBindingElement CreateCertificateSignatureBindingElement();
	static public SymmetricSecurityBindingElement CreateIssuedTokenBindingElement(IssuedSecurityTokenParameters issuedTokenParameters);
	static public SymmetricSecurityBindingElement CreateIssuedTokenForCertificateBindingElement(IssuedSecurityTokenParameters issuedTokenParameters);
	static public SymmetricSecurityBindingElement CreateIssuedTokenForSslBindingElement(IssuedSecurityTokenParameters issuedTokenParameters);
	static public SymmetricSecurityBindingElement CreateIssuedTokenForSslBindingElement(IssuedSecurityTokenParameters issuedTokenParameters, Boolean requireCancellation);
	static public TransportSecurityBindingElement CreateIssuedTokenOverTransportBindingElement(IssuedSecurityTokenParameters issuedTokenParameters);
	static public SymmetricSecurityBindingElement CreateKerberosBindingElement();
	static public TransportSecurityBindingElement CreateKerberosOverTransportBindingElement();
	static public SecurityBindingElement CreateMutualCertificateBindingElement();
	static public SecurityBindingElement CreateMutualCertificateBindingElement(MessageSecurityVersion version);
	static public SecurityBindingElement CreateMutualCertificateBindingElement(MessageSecurityVersion version, Boolean allowSerializedSigningTokenOnReply);
	static public AsymmetricSecurityBindingElement CreateMutualCertificateDuplexBindingElement();
	static public AsymmetricSecurityBindingElement CreateMutualCertificateDuplexBindingElement(MessageSecurityVersion version);
	static public SecurityBindingElement CreateSecureConversationBindingElement(SecurityBindingElement bootstrapSecurity);
	static public SecurityBindingElement CreateSecureConversationBindingElement(SecurityBindingElement bootstrapSecurity, Boolean requireCancellation);
	static public SecurityBindingElement CreateSecureConversationBindingElement(SecurityBindingElement bootstrapSecurity, Boolean requireCancellation, ChannelProtectionRequirements bootstrapProtectionRequirements);
	static public SymmetricSecurityBindingElement CreateSslNegotiationBindingElement(Boolean requireClientCertificate);
	static public SymmetricSecurityBindingElement CreateSslNegotiationBindingElement(Boolean requireClientCertificate, Boolean requireCancellation);
	static public SymmetricSecurityBindingElement CreateSspiNegotiationBindingElement();
	static public SymmetricSecurityBindingElement CreateSspiNegotiationBindingElement(Boolean requireCancellation);
	static public TransportSecurityBindingElement CreateSspiNegotiationOverTransportBindingElement();
	static public TransportSecurityBindingElement CreateSspiNegotiationOverTransportBindingElement(Boolean requireCancellation);
	static public SymmetricSecurityBindingElement CreateUserNameForCertificateBindingElement();
	static public SymmetricSecurityBindingElement CreateUserNameForSslBindingElement();
	static public SymmetricSecurityBindingElement CreateUserNameForSslBindingElement(Boolean requireCancellation);
static public TransportSecurityBindingElement CreateUserNameOverTransportBindingElement();	static public TransportSecurityBindingElement CreateUserNameOverTransportBindingElement();
public virtual T GetProperty(BindingContext context);	public virtual T GetProperty(BindingContext context);
	static protected void SetIssuerBindingContextIfRequired(SecurityTokenParameters parameters, BindingContext issuerBindingContext);
	public virtual void SetKeyDerivation(Boolean requireDerivedKeys);

	public class SecurityBindingElementImporter
	: IPolicyImportExtension
	public Int32 MaxPolicyRedirections { get; }

	public sealed enum SecurityHeaderLayout
	: IComparable, IFormattable, IConvertible
	{ Strict, Lax, LaxTimestampFirst, LaxTimestampLast }

	public class ServerChannelSinkStack
	: IServerChannelSinkStack, IServerResponseChannelSinkStack
	public virtual void AsyncProcessResponse(IMessage msg, ITransportHeaders headers, Stream stream);
	public virtual Stream GetResponseStream(IMessage msg, ITransportHeaders headers);
	public virtual Object Pop(IServerChannelSink sink);
	public virtual void Push(IServerChannelSink sink, Object state);
	public virtual void ServerCallback(IAsyncResult ar);
	public virtual void Store(IServerChannelSink sink, Object state);
	public virtual void StoreAndDispatch(IServerChannelSink sink, Object state);

	public sealed enum ServerProcessing
	: IComparable, IFormattable, IConvertible
	{ Complete, OneWay, Async }

	class SelfSignedCertificate
	: CRYPT_ALGORITHM_IDENTIFIER

	public class SinkProviderData

	public IList Children { get; }
	public String Name { get; }
	public IDictionary Properties { get; }

	class MsmqInputMessage

	public Int32 MaxSize { get; }
	public void Alloc(Int32 requiredSize);
	public Int32 AllocIfAvailable(Int32 desiredSize);

	public class SslStreamSecurityBindingElement
	: StreamUpgradeBindingElement, ITransportTokenAssertionProvider, IPolicyExportExtension
	public IdentityVerifier IdentityVerifier { get; set; }
	public Boolean RequireClientCertificate { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual StreamUpgradeProvider BuildClientStreamUpgradeProvider(BindingContext context);
	public virtual StreamUpgradeProvider BuildServerStreamUpgradeProvider(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public virtual XmlElement GetTransportTokenAssertion();
	public Boolean ShouldSerializeIdentityVerifier();

sealed enum ServerModeDecoder+State
: IComparable, IFormattable, IConvertible
{ ReadingVersionRecord, ReadingMajorVersion, ReadingMinorVersion, ReadingModeRecord, ReadingModeValue, Done }

sealed enum ServerSessionDecoder+State
: IComparable, IFormattable, IConvertible
{ ReadingViaRecord, ReadingViaString, ReadingContentTypeRecord, ReadingContentTypeString, ReadingContentTypeByte, PreUpgradeStart, ReadingUpgradeRecord, ReadingUpgradeString, UpgradeRequest, ReadingPreambleEndRecord, Start, ReadingEnvelopeRecord, ReadingEnvelopeSize, EnvelopeStart, ReadingEnvelopeBytes, EnvelopeEnd, ReadingEndRecord, End }

	public class StandardBindingImporter
	: IWsdlImportExtension

	sealed enum ServerModeDecoder
	: IComparable, IFormattable, IConvertible
	{ ReadingVersionRecord, ReadingMajorVersion, ReadingMinorVersion, ReadingModeRecord, ReadingModeValue, Done }

	sealed enum ServerSessionDecoder
	: IComparable, IFormattable, IConvertible
	{ ReadingViaRecord, ReadingViaString, ReadingContentTypeRecord, ReadingContentTypeString, ReadingContentTypeByte, PreUpgradeStart, ReadingUpgradeRecord, ReadingUpgradeString, UpgradeRequest, ReadingPreambleEndRecord, Start, ReadingEnvelopeRecord, ReadingEnvelopeSize, EnvelopeStart, ReadingEnvelopeBytes, EnvelopeEnd, ReadingEndRecord, End }

	sealed enum SingletonMessageDecoder
	: IComparable, IFormattable, IConvertible
	{ ReadingEnvelopeChunkSize, ChunkStart, ReadingEnvelopeBytes, ChunkEnd, EnvelopeEnd, End }

	sealed enum ServerSingletonDecoder
	: IComparable, IFormattable, IConvertible
	{ ReadingViaRecord, ReadingViaString, ReadingContentTypeRecord, ReadingContentTypeString, ReadingContentTypeByte, PreUpgradeStart, ReadingUpgradeRecord, ReadingUpgradeString, UpgradeRequest, ReadingPreambleEndRecord, Start, ReadingEnvelopeRecord, EnvelopeStart, ReadingEnvelopeChunkSize, ChunkStart, ReadingEnvelopeChunk, ChunkEnd, End }

	sealed enum ServerSingletonSizedDecoder
	: IComparable, IFormattable, IConvertible
	{ ReadingViaRecord, ReadingViaString, ReadingContentTypeRecord, ReadingContentTypeString, ReadingContentTypeByte, Start }

	public abstract class StreamSecurityUpgradeAcceptor
	: StreamUpgradeAcceptor
	public abstract virtual SecurityMessageProperty GetRemoteSecurity();

	public abstract class StreamSecurityUpgradeInitiator
	: StreamUpgradeInitiator
	public abstract virtual SecurityMessageProperty GetRemoteSecurity();

	public abstract class StreamSecurityUpgradeProvider
	: StreamUpgradeProvider, ICommunicationObject
	public abstract virtual EndpointIdentity Identity { get; }

	public abstract class StreamUpgradeAcceptor

	public virtual Stream AcceptUpgrade(Stream stream);
	public abstract virtual IAsyncResult BeginAcceptUpgrade(Stream stream, AsyncCallback callback, Object state);
	public abstract virtual Boolean CanUpgrade(String contentType);
	public abstract virtual Stream EndAcceptUpgrade(IAsyncResult result);

	public abstract class StreamUpgradeBindingElement
	: BindingElement
	public abstract virtual StreamUpgradeProvider BuildClientStreamUpgradeProvider(BindingContext context);
	public abstract virtual StreamUpgradeProvider BuildServerStreamUpgradeProvider(BindingContext context);

	public abstract class StreamUpgradeInitiator

	public abstract virtual IAsyncResult BeginInitiateUpgrade(Stream stream, AsyncCallback callback, Object state);
	public abstract virtual Stream EndInitiateUpgrade(IAsyncResult result);
	public abstract virtual String GetNextUpgrade();
	public abstract virtual Stream InitiateUpgrade(Stream stream);

	public abstract class StreamUpgradeProvider
	: CommunicationObject, ICommunicationObject
	protected virtual TimeSpan DefaultCloseTimeout { get; }
	protected virtual TimeSpan DefaultOpenTimeout { get; }
	public abstract virtual StreamUpgradeAcceptor CreateUpgradeAcceptor();
	public abstract virtual StreamUpgradeInitiator CreateUpgradeInitiator(EndpointAddress remoteAddress, Uri via);
	public virtual T GetProperty();

	public sealed enum SupportedAddressingMode
	: IComparable, IFormattable, IConvertible
	{ Anonymous, NonAnonymous, Mixed }

	public sealed class SymmetricSecurityBindingElement
	: SecurityBindingElement, IPolicyExportExtension
	public MessageProtectionOrder MessageProtectionOrder { get; set; }
	public SecurityTokenParameters ProtectionTokenParameters { get; set; }
	public Boolean RequireSignatureConfirmation { get; set; }
	protected virtual IChannelFactory`1<TChannel> BuildChannelFactoryCore(BindingContext context);
	protected virtual IChannelListener`1<TChannel> BuildChannelListenerCore(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public virtual void SetKeyDerivation(Boolean requireDerivedKeys);
	public virtual String ToString();

public sealed class TcpConnectionPoolSettings	public sealed class TcpConnectionPoolSettings

public String GroupName { get; set; }	public String GroupName { get; set; }
public TimeSpan IdleTimeout { get; set; }	public TimeSpan IdleTimeout { get; set; }
public TimeSpan LeaseTimeout { get; set; }	public TimeSpan LeaseTimeout { get; set; }
public Int32 MaxOutboundConnectionsPerEndpoint { get; set; }	public Int32 MaxOutboundConnectionsPerEndpoint { get; set; }

public class TcpTransportBindingElement	public class TcpTransportBindingElement
: ConnectionOrientedTransportBindingElement, IDuplexHelper	: ConnectionOrientedTransportBindingElement, IWsdlExportExtension, IPolicyExportExtension, ITransportPolicyImport
public TcpConnectionPoolSettings ConnectionPoolSettings { get; }	public TcpConnectionPoolSettings ConnectionPoolSettings { get; }
	public ExtendedProtectionPolicy ExtendedProtectionPolicy { get; set; }
	public Int32 ListenBacklog { get; set; }
	public Boolean PortSharingEnabled { get; set; }
public virtual String Scheme { get; }	public virtual String Scheme { get; }
	public Boolean TeredoEnabled { get; set; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
public virtual BindingElement Clone();	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeExtendedProtectionPolicy();

public sealed class TextMessageEncodingBindingElement	public sealed class TextMessageEncodingBindingElement
: MessageEncodingBindingElement	: MessageEncodingBindingElement, IWsdlExportExtension, IPolicyExportExtension
	public Int32 MaxReadPoolSize { get; set; }
	public Int32 MaxWritePoolSize { get; set; }
public virtual MessageVersion MessageVersion { get; set; }	public virtual MessageVersion MessageVersion { get; set; }
	public XmlDictionaryReaderQuotas ReaderQuotas { get; set; }
public Encoding WriteEncoding { get; set; }	public Encoding WriteEncoding { get; set; }
public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
public virtual BindingElement Clone();	public virtual BindingElement Clone();
public virtual MessageEncoderFactory CreateMessageEncoderFactory();	public virtual MessageEncoderFactory CreateMessageEncoderFactory();
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeReaderQuotas();

	public sealed class TransactionFlowBindingElement
	: BindingElement, IPolicyExportExtension
	public Boolean AllowWildcardAction { get; set; }
	public TransactionProtocol TransactionProtocol { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public Boolean ShouldSerializeTransactionProtocol();

	public sealed class TransactionFlowBindingElementImporter
	: IPolicyImportExtension

	public sealed class TransactionMessageProperty

	public Transaction Transaction { get; }
	static public void Set(Transaction transaction, Message message);

	public sealed enum TransferSession
	: IComparable, IFormattable, IConvertible
	{ None, Ordered, Unordered }

public abstract class TransportBindingElement	public abstract class TransportBindingElement
: BindingElement	: BindingElement
public Boolean ManualAddressing { get; set; }	public virtual Boolean ManualAddressing { get; set; }
	public virtual Int64 MaxBufferPoolSize { get; set; }
public virtual Int64 MaxReceivedMessageSize { get; set; }	public virtual Int64 MaxReceivedMessageSize { get; set; }
public abstract virtual String Scheme { get; }	public abstract virtual String Scheme { get; }
public virtual T GetProperty(BindingContext context);	public virtual T GetProperty(BindingContext context);

	public class TransportBindingElementImporter
	: IWsdlImportExtension, IPolicyImportExtension

	public class TransportHeaders
	: ITransportHeaders
	public virtual Object Item { get; set; }
	public virtual IEnumerator GetEnumerator();

	class TransportReplyChannelAcceptor
	: ReplyChannel, ICommunicationObject, IChannel, IDefaultCommunicationTimeouts, IReplyChannel
	protected virtual void OnAbort();
	protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, Object state);
	protected virtual void OnClose(TimeSpan timeout);
	protected virtual void OnEndClose(IAsyncResult result);
	public Boolean TransferTransportManagers(TransportManagerContainer transportManagerContainer);

public sealed class TransportSecurityBindingElement	public sealed class TransportSecurityBindingElement
: SecurityBindingElement	: SecurityBindingElement, IPolicyExportExtension
	protected virtual IChannelFactory`1<TChannel> BuildChannelFactoryCore(BindingContext context);
	protected virtual IChannelListener`1<TChannel> BuildChannelListenerCore(BindingContext context);
public virtual BindingElement Clone();	public virtual BindingElement Clone();

	sealed class ChannelReliableSession
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke();

	public sealed class UnderstoodHeaders
	: IEnumerable`1<MessageHeaderInfo>, IEnumerable
	public void Add(MessageHeaderInfo headerInfo);
	public Boolean Contains(MessageHeaderInfo headerInfo);
	public virtual IEnumerator`1<MessageHeaderInfo> GetEnumerator();
	public void Remove(MessageHeaderInfo headerInfo);

	public sealed class UseManagedPresentationBindingElement
	: BindingElement, IPolicyExportExtension
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);

	public sealed class UseManagedPresentationBindingElementImporter
	: IPolicyImportExtension

public sealed class WebBodyFormatMessageProperty
: IMessageProperty
public WebContentFormat Format { get; }
public virtual IMessageProperty CreateCopy();

public sealed enum WebContentFormat
: IComparable, IFormattable, IConvertible
{ Default, Xml, Json, Raw }

	public abstract class WebSocketConnectionHandler
	: HttpMessageHandler, IDisposable
	protected virtual HttpResponseMessage AcceptWebSocket(HttpRequestMessage request, CancellationToken cancellationToken);
	protected virtual Boolean AcceptWebSocket(HttpRequestMessage request);
	protected HttpResponseMessage GetUpgradeRequiredResponseMessage(HttpRequestMessage request);
	protected HttpResponseMessage GetWebSocketAcceptedResponseMessage(HttpRequestMessage request);
	protected virtual HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken);
	protected virtual Task`1<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);

	public sealed enum WebSocketConnectionMode
	: IComparable, IFormattable, IConvertible
	{ Allowed, Required, NotAllowed }

	public sealed class WebSocketMessageProperty

	public WebSocketMessageType IncomingMessageType { get; }
	public WebSocketMessageType OutgoingMessageType { get; set; }
	public String SubProtocol { get; }
	public WebSocketContext WebSocketContext { get; }

	class WebSocketTransportDuplexSessionChannel
	: IMessageSource
	public virtual AsyncReceiveResult BeginReceive(TimeSpan timeout, WaitCallback callback, Object state);
	public virtual AsyncReceiveResult BeginWaitForMessage(TimeSpan timeout, WaitCallback callback, Object state);
	public virtual Message EndReceive();
	public virtual Boolean EndWaitForMessage();
	public virtual Message Receive(TimeSpan timeout);
	public virtual Boolean WaitForMessage(TimeSpan timeout);

	public sealed class WebSocketSettings
	: IEquatable`1<WebSocketSettings>
	public WebSocketConnectionMode ConnectionMode { get; set; }
	public Boolean MaskingDisabled { get; set; }
	public Boolean OpenNotificationEnabled { get; set; }
	public TimeSpan PingFrequency { get; set; }
	public Int32 ReceiveBufferSize { get; set; }
	public Int32 SendBufferSize { get; set; }
	public String SubProtocol { get; set; }
	public virtual Boolean Equals(WebSocketSettings other);
	public virtual Boolean Equals(Object obj);
	public virtual Int32 GetHashCode();

	public class WindowsStreamSecurityBindingElement
	: StreamUpgradeBindingElement, ITransportTokenAssertionProvider, IPolicyExportExtension
	public ProtectionLevel ProtectionLevel { get; set; }
	public virtual IChannelFactory`1<TChannel> BuildChannelFactory(BindingContext context);
	public virtual IChannelListener`1<TChannel> BuildChannelListener(BindingContext context);
	public virtual StreamUpgradeProvider BuildClientStreamUpgradeProvider(BindingContext context);
	public virtual StreamUpgradeProvider BuildServerStreamUpgradeProvider(BindingContext context);
	public virtual Boolean CanBuildChannelFactory(BindingContext context);
	public virtual Boolean CanBuildChannelListener(BindingContext context);
	public virtual BindingElement Clone();
	public virtual T GetProperty(BindingContext context);
	public virtual XmlElement GetTransportTokenAssertion();

	public class WrappedOptions

	public Boolean WrappedFlag { get; set; }

	public class XmlSerializerImportOptions

	public String ClrNamespace { get; set; }
	public CodeCompileUnit CodeCompileUnit { get; }
	public CodeDomProvider CodeProvider { get; set; }
	public WebReferenceOptions WebReferenceOptions { get; set; }

public abstract class AddressHeader	public abstract class AddressHeader

public abstract virtual String Name { get; }	public abstract virtual String Name { get; }
public abstract virtual String Namespace { get; }	public abstract virtual String Namespace { get; }
	static public AddressHeader CreateAddressHeader(Object value);
	static public AddressHeader CreateAddressHeader(Object value, XmlObjectSerializer serializer);
static public AddressHeader CreateAddressHeader(String name, String ns, Object value);	static public AddressHeader CreateAddressHeader(String name, String ns, Object value);
static public AddressHeader CreateAddressHeader(String name, String ns, Object value, XmlObjectSerializer serializer);	static public AddressHeader CreateAddressHeader(String name, String ns, Object value, XmlObjectSerializer serializer);
public virtual Boolean Equals(Object obj);	public virtual Boolean Equals(Object obj);
public virtual XmlDictionaryReader GetAddressHeaderReader();	public virtual XmlDictionaryReader GetAddressHeaderReader();
public virtual Int32 GetHashCode();	public virtual Int32 GetHashCode();
public T GetValue();	public T GetValue();
public T GetValue(XmlObjectSerializer serializer);	public T GetValue(XmlObjectSerializer serializer);
	protected abstract virtual void OnWriteAddressHeaderContents(XmlDictionaryWriter writer);
	protected virtual void OnWriteStartAddressHeader(XmlDictionaryWriter writer);
public MessageHeader ToMessageHeader();	public MessageHeader ToMessageHeader();
public void WriteAddressHeader(XmlWriter writer);	public void WriteAddressHeader(XmlWriter writer);
public void WriteAddressHeader(XmlDictionaryWriter writer);	public void WriteAddressHeader(XmlDictionaryWriter writer);
public void WriteAddressHeaderContents(XmlDictionaryWriter writer);	public void WriteAddressHeaderContents(XmlDictionaryWriter writer);
public void WriteStartAddressHeader(XmlDictionaryWriter writer);	public void WriteStartAddressHeader(XmlDictionaryWriter writer);

public abstract class MessageEncoder	public abstract class MessageEncoder

public abstract virtual String ContentType { get; }	public abstract virtual String ContentType { get; }
public abstract virtual String MediaType { get; }	public abstract virtual String MediaType { get; }
public abstract virtual MessageVersion MessageVersion { get; }	public abstract virtual MessageVersion MessageVersion { get; }
	public virtual IAsyncResult BeginWriteMessage(Message message, Stream stream, AsyncCallback callback, Object state);
	public virtual void EndWriteMessage(IAsyncResult result);
public virtual T GetProperty();	public virtual T GetProperty();
public virtual Boolean IsContentTypeSupported(String contentType);	public virtual Boolean IsContentTypeSupported(String contentType);
public Message ReadMessage(Stream stream, Int32 maxSizeOfHeaders);	public Message ReadMessage(Stream stream, Int32 maxSizeOfHeaders);
public abstract virtual Message ReadMessage(Stream stream, Int32 maxSizeOfHeaders, String contentType);	public abstract virtual Message ReadMessage(Stream stream, Int32 maxSizeOfHeaders, String contentType);
public Message ReadMessage(ArraySegment`1<Byte> buffer, BufferManager bufferManager);	public Message ReadMessage(ArraySegment`1<Byte> buffer, BufferManager bufferManager);
public abstract virtual Message ReadMessage(ArraySegment`1<Byte> buffer, BufferManager bufferManager, String contentType);	public abstract virtual Message ReadMessage(ArraySegment`1<Byte> buffer, BufferManager bufferManager, String contentType);
public virtual String ToString();	public virtual String ToString();
public abstract virtual void WriteMessage(Message message, Stream stream);	public abstract virtual void WriteMessage(Message message, Stream stream);
public ArraySegment`1<Byte> WriteMessage(Message message, Int32 maxMessageSize, BufferManager bufferManager);	public ArraySegment`1<Byte> WriteMessage(Message message, Int32 maxMessageSize, BufferManager bufferManager);
public abstract virtual ArraySegment`1<Byte> WriteMessage(Message message, Int32 maxMessageSize, BufferManager bufferManager, Int32 messageOffset);	public abstract virtual ArraySegment`1<Byte> WriteMessage(Message message, Int32 maxMessageSize, BufferManager bufferManager, Int32 messageOffset);

public abstract class MessageHeader	public abstract class MessageHeader
: MessageHeaderInfo	: MessageHeaderInfo
public virtual String Actor { get; }	public virtual String Actor { get; }
public virtual Boolean IsReferenceParameter { get; }	public virtual Boolean IsReferenceParameter { get; }
public virtual Boolean MustUnderstand { get; }	public virtual Boolean MustUnderstand { get; }
public virtual Boolean Relay { get; }	public virtual Boolean Relay { get; }
static public MessageHeader CreateHeader(String name, String ns, Object value);	static public MessageHeader CreateHeader(String name, String ns, Object value);
static public MessageHeader CreateHeader(String name, String ns, Object value, Boolean mustUnderstand);	static public MessageHeader CreateHeader(String name, String ns, Object value, Boolean mustUnderstand);
static public MessageHeader CreateHeader(String name, String ns, Object value, Boolean mustUnderstand, String actor);	static public MessageHeader CreateHeader(String name, String ns, Object value, Boolean mustUnderstand, String actor);
static public MessageHeader CreateHeader(String name, String ns, Object value, Boolean mustUnderstand, String actor, Boolean relay);	static public MessageHeader CreateHeader(String name, String ns, Object value, Boolean mustUnderstand, String actor, Boolean relay);
static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer);	static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer);
static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer, Boolean mustUnderstand);	static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer, Boolean mustUnderstand);
static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer, Boolean mustUnderstand, String actor);	static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer, Boolean mustUnderstand, String actor);
static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer, Boolean mustUnderstand, String actor, Boolean relay);	static public MessageHeader CreateHeader(String name, String ns, Object value, XmlObjectSerializer serializer, Boolean mustUnderstand, String actor, Boolean relay);
public virtual Boolean IsMessageVersionSupported(MessageVersion messageVersion);	public virtual Boolean IsMessageVersionSupported(MessageVersion messageVersion);
	protected abstract virtual void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion);
	protected virtual void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion);
public virtual String ToString();	public virtual String ToString();
public void WriteHeader(XmlWriter writer, MessageVersion messageVersion);	public void WriteHeader(XmlWriter writer, MessageVersion messageVersion);
public void WriteHeader(XmlDictionaryWriter writer, MessageVersion messageVersion);	public void WriteHeader(XmlDictionaryWriter writer, MessageVersion messageVersion);
	protected void WriteHeaderAttributes(XmlDictionaryWriter writer, MessageVersion messageVersion);
public void WriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion);	public void WriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion);
public void WriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion);	public void WriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion);

public sealed class MessageHeaders	public sealed class MessageHeaders
: IEnumerable`1<MessageHeaderInfo>, IEnumerable	: IEnumerable`1<MessageHeaderInfo>, IEnumerable
public String Action { get; set; }	public String Action { get; set; }
public Int32 Count { get; }	public Int32 Count { get; }
public EndpointAddress FaultTo { get; set; }	public EndpointAddress FaultTo { get; set; }
public EndpointAddress From { get; set; }	public EndpointAddress From { get; set; }
public MessageHeaderInfo Item { get; }	public MessageHeaderInfo Item { get; }
public UniqueId MessageId { get; set; }	public UniqueId MessageId { get; set; }
public MessageVersion MessageVersion { get; }	public MessageVersion MessageVersion { get; }
public UniqueId RelatesTo { get; set; }	public UniqueId RelatesTo { get; set; }
public EndpointAddress ReplyTo { get; set; }	public EndpointAddress ReplyTo { get; set; }
public Uri To { get; set; }	public Uri To { get; set; }
	public UnderstoodHeaders UnderstoodHeaders { get; }
public void Add(MessageHeader header);	public void Add(MessageHeader header);
public void Clear();	public void Clear();
public void CopyHeaderFrom(Message message, Int32 headerIndex);	public void CopyHeaderFrom(Message message, Int32 headerIndex);
public void CopyHeaderFrom(MessageHeaders collection, Int32 headerIndex);	public void CopyHeaderFrom(MessageHeaders collection, Int32 headerIndex);
public void CopyHeadersFrom(Message message);	public void CopyHeadersFrom(Message message);
public void CopyHeadersFrom(MessageHeaders collection);	public void CopyHeadersFrom(MessageHeaders collection);
public void CopyTo(MessageHeaderInfo array, Int32 index);	public void CopyTo(MessageHeaderInfo array, Int32 index);
public Int32 FindHeader(String name, String ns);	public Int32 FindHeader(String name, String ns);
public Int32 FindHeader(String name, String ns, String actors);	public Int32 FindHeader(String name, String ns, String actors);
public virtual IEnumerator`1<MessageHeaderInfo> GetEnumerator();	public virtual IEnumerator`1<MessageHeaderInfo> GetEnumerator();
public T GetHeader(String name, String ns);	public T GetHeader(String name, String ns);
public T GetHeader(String name, String ns, String actors);	public T GetHeader(String name, String ns, String actors);
public T GetHeader(String name, String ns, XmlObjectSerializer serializer);	public T GetHeader(String name, String ns, XmlObjectSerializer serializer);
public T GetHeader(Int32 index);	public T GetHeader(Int32 index);
public T GetHeader(Int32 index, XmlObjectSerializer serializer);	public T GetHeader(Int32 index, XmlObjectSerializer serializer);
public XmlDictionaryReader GetReaderAtHeader(Int32 headerIndex);	public XmlDictionaryReader GetReaderAtHeader(Int32 headerIndex);
public Boolean HaveMandatoryHeadersBeenUnderstood();	public Boolean HaveMandatoryHeadersBeenUnderstood();
public Boolean HaveMandatoryHeadersBeenUnderstood(String actors);	public Boolean HaveMandatoryHeadersBeenUnderstood(String actors);
public void Insert(Int32 headerIndex, MessageHeader header);	public void Insert(Int32 headerIndex, MessageHeader header);
public void RemoveAll(String name, String ns);	public void RemoveAll(String name, String ns);
public void RemoveAt(Int32 headerIndex);	public void RemoveAt(Int32 headerIndex);
public void SetAction(XmlDictionaryString action);	public void SetAction(XmlDictionaryString action);
public void WriteHeader(Int32 headerIndex, XmlWriter writer);	public void WriteHeader(Int32 headerIndex, XmlWriter writer);
public void WriteHeader(Int32 headerIndex, XmlDictionaryWriter writer);	public void WriteHeader(Int32 headerIndex, XmlDictionaryWriter writer);
	public void WriteHeaderContents(Int32 headerIndex, XmlDictionaryWriter writer);
public void WriteHeaderContents(Int32 headerIndex, XmlWriter writer);	public void WriteHeaderContents(Int32 headerIndex, XmlWriter writer);
public void WriteHeaderContents(Int32 headerIndex, XmlDictionaryWriter writer);
	public void WriteStartHeader(Int32 headerIndex, XmlDictionaryWriter writer);
public void WriteStartHeader(Int32 headerIndex, XmlWriter writer);	public void WriteStartHeader(Int32 headerIndex, XmlWriter writer);
public void WriteStartHeader(Int32 headerIndex, XmlDictionaryWriter writer);

public sealed class MessageProperties	public sealed class MessageProperties
: IDictionary`2<String, Object>, ICollection`1<KeyValuePair`2<String, Object>>, IEnumerable`1<KeyValuePair`2<String, Object>>, IEnumerable, IDisposable	: IDictionary`2<String, Object>, ICollection`1<KeyValuePair`2<String, Object>>, IEnumerable`1<KeyValuePair`2<String, Object>>, IEnumerable, IDisposable
public Boolean AllowOutputBatching { get; set; }	public Boolean AllowOutputBatching { get; set; }
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public MessageEncoder Encoder { get; set; }	public MessageEncoder Encoder { get; set; }
public Boolean IsFixedSize { get; }	public Boolean IsFixedSize { get; }
public virtual Boolean IsReadOnly { get; }	public virtual Boolean IsReadOnly { get; }
public virtual Object Item { get; set; }	public virtual Object Item { get; set; }
public virtual ICollection`1<String> Keys { get; }	public virtual ICollection`1<String> Keys { get; }
	public SecurityMessageProperty Security { get; set; }
public virtual ICollection`1<Object> Values { get; }	public virtual ICollection`1<Object> Values { get; }
public Uri Via { get; set; }	public Uri Via { get; set; }
public virtual void Add(String name, Object property);	public virtual void Add(String name, Object property);
public virtual void Clear();	public virtual void Clear();
public virtual Boolean ContainsKey(String name);	public virtual Boolean ContainsKey(String name);
public void CopyProperties(MessageProperties properties);	public void CopyProperties(MessageProperties properties);
public virtual void Dispose();	public virtual void Dispose();
public virtual Boolean Remove(String name);	public virtual Boolean Remove(String name);
public virtual Boolean TryGetValue(String name, out Object& value);	public virtual Boolean TryGetValue(String name, out Object& value);

public sealed class MessageVersion	public sealed class MessageVersion

public AddressingVersion Addressing { get; }	public AddressingVersion Addressing { get; }
static public MessageVersion Default { get; }	static public MessageVersion Default { get; }
public EnvelopeVersion Envelope { get; }	public EnvelopeVersion Envelope { get; }
static public MessageVersion None { get; }	static public MessageVersion None { get; }
static public MessageVersion Soap11 { get; }	static public MessageVersion Soap11 { get; }
	static public MessageVersion Soap11WSAddressing10 { get; }
	static public MessageVersion Soap11WSAddressingAugust2004 { get; }
	static public MessageVersion Soap12 { get; }
static public MessageVersion Soap12WSAddressing10 { get; }	static public MessageVersion Soap12WSAddressing10 { get; }
	static public MessageVersion Soap12WSAddressingAugust2004 { get; }
	static public MessageVersion CreateVersion(EnvelopeVersion envelopeVersion, AddressingVersion addressingVersion);
static public MessageVersion CreateVersion(EnvelopeVersion envelopeVersion);	static public MessageVersion CreateVersion(EnvelopeVersion envelopeVersion);
static public MessageVersion CreateVersion(EnvelopeVersion envelopeVersion, AddressingVersion addressingVersion);
public virtual Boolean Equals(Object obj);	public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();	public virtual Int32 GetHashCode();
public virtual String ToString();	public virtual String ToString();