Silverlight 5

WinRT

public sealed enum AddressFamily	public sealed enum AddressFamily
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Unknown, Unspecified, InterNetwork, InterNetworkV6 }	{ Unknown, Unspecified, Unix, InterNetwork, ImpLink, Pup, Chaos, NS, Ipx, Iso, Osi, Ecma, DataKit, Ccitt, Sna, DecNet, DataLink, Lat, HyperChannel, AppleTalk, NetBios, VoiceView, FireFox, Banyan, Atm, InterNetworkV6, Cluster, Ieee12844, Irda, NetworkDesigners, Max }

	public sealed enum IOControlCode
	: IComparable, IFormattable, IConvertible
	{ AsyncIO, NonBlockingIO, DataToRead, OobDataRead, AssociateHandle, EnableCircularQueuing, Flush, GetBroadcastAddress, GetExtensionFunctionPointer, GetQos, GetGroupQos, MultipointLoopback, MulticastScope, SetQos, SetGroupQos, TranslateHandle, RoutingInterfaceQuery, RoutingInterfaceChange, AddressListQuery, AddressListChange, QueryTargetPnpHandle, NamespaceChange, AddressListSort, ReceiveAll, ReceiveAllMulticast, ReceiveAllIgmpMulticast, KeepAliveValues, AbsorbRouterAlert, UnicastInterface, LimitBroadcasts, BindToInterface, MulticastInterface, AddMulticastGroupOnInterface, DeleteMulticastGroupFromInterface }

	public sealed struct IPPacketInformation
	: ValueType
	public IPAddress Address { get; }
	public Int32 Interface { get; }
	public virtual Boolean Equals(Object comparand);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
	static public Boolean op_Inequality(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);

	public sealed enum IPProtectionLevel
	: IComparable, IFormattable, IConvertible
	{ Unspecified, Unrestricted, EdgeRestricted, Restricted }

	public class IPv6MulticastOption
	public IPAddress Group { get; set; }
	public Int64 InterfaceIndex { get; set; }

	public class LingerOption
	public Boolean Enabled { get; set; }
	public Int32 LingerTime { get; set; }

	public class MulticastOption
	public IPAddress Group { get; set; }
	public Int32 InterfaceIndex { get; set; }
	public IPAddress LocalAddress { get; set; }

	public class NetworkStream
	: Stream, IDisposable
	public virtual Boolean CanRead { get; }
	public virtual Boolean CanSeek { get; }
	public virtual Boolean CanTimeout { get; }
	public virtual Boolean CanWrite { get; }
	public virtual Boolean DataAvailable { get; }
	public virtual Int64 Length { get; }
	public virtual Int64 Position { get; set; }
	protected Boolean Readable { get; set; }
	public virtual Int32 ReadTimeout { get; set; }
	protected Socket Socket { get; }
	protected Boolean Writeable { get; set; }
	public virtual Int32 WriteTimeout { get; set; }
	public virtual IAsyncResult BeginRead(Byte buffer, Int32 offset, Int32 size, AsyncCallback callback, Object state);
	public virtual IAsyncResult BeginWrite(Byte buffer, Int32 offset, Int32 size, AsyncCallback callback, Object state);
	public void Close(Int32 timeout);
	protected virtual void Dispose(Boolean disposing);
	public virtual Int32 EndRead(IAsyncResult asyncResult);
	public virtual void EndWrite(IAsyncResult asyncResult);
	protected virtual void Finalize();
	public virtual void Flush();
	public virtual Int32 Read(out Byte buffer, Int32 offset, Int32 size);
	public virtual Int64 Seek(Int64 offset, SeekOrigin origin);
	public virtual void SetLength(Int64 value);
	public virtual void Write(Byte buffer, Int32 offset, Int32 size);

	public sealed enum ProtocolFamily
	: IComparable, IFormattable, IConvertible
	{ Unknown, Unspecified, Unix, InterNetwork, ImpLink, Pup, Chaos, NS, Ipx, Iso, Osi, Ecma, DataKit, Ccitt, Sna, DecNet, DataLink, Lat, HyperChannel, AppleTalk, NetBios, VoiceView, FireFox, Banyan, Atm, InterNetworkV6, Cluster, Ieee12844, Irda, NetworkDesigners, Max }

public sealed enum ProtocolType	public sealed enum ProtocolType
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Tcp, Udp, Unspecified, Unknown }	{ IP, IPv6HopByHopOptions, Icmp, Igmp, Ggp, IPv4, Tcp, Pup, Udp, Idp, IPv6, IPv6RoutingHeader, IPv6FragmentHeader, IPSecEncapsulatingSecurityPayload, IPSecAuthenticationHeader, IcmpV6, IPv6NoNextHeader, IPv6DestinationOptions, ND, Raw, Unspecified, Ipx, Spx, SpxII, Unknown }

	public sealed enum SelectMode
	: IComparable, IFormattable, IConvertible
	{ SelectRead, SelectWrite, SelectError }

	public class SendPacketsElement
	public Byte Buffer { get; }
	public Int32 Count { get; }
	public Boolean EndOfPacket { get; }
	public String FilePath { get; }
	public Int32 Offset { get; }

public class Socket	public class Socket
: IDisposable	: IDisposable
public AddressFamily AddressFamily { get; }	public AddressFamily AddressFamily { get; }
	public Int32 Available { get; }
	public Boolean Blocking { get; set; }
public Boolean Connected { get; }	public Boolean Connected { get; }
	public Boolean DontFragment { get; set; }
	public Boolean DualMode { get; set; }
	public Boolean EnableBroadcast { get; set; }
	public Boolean ExclusiveAddressUse { get; set; }
	public IntPtr Handle { get; }
	public Boolean IsBound { get; }
	public LingerOption LingerState { get; set; }
	public EndPoint LocalEndPoint { get; }
	public Boolean MulticastLoopback { get; set; }
public Boolean NoDelay { get; set; }	public Boolean NoDelay { get; set; }
static public Boolean OSSupportsIPv4 { get; }	static public Boolean OSSupportsIPv4 { get; }
static public Boolean OSSupportsIPv6 { get; }	static public Boolean OSSupportsIPv6 { get; }
public ProtocolType ProtocolType { get; }	public ProtocolType ProtocolType { get; }
public Int32 ReceiveBufferSize { get; set; }	public Int32 ReceiveBufferSize { get; set; }
	public Int32 ReceiveTimeout { get; set; }
public EndPoint RemoteEndPoint { get; }	public EndPoint RemoteEndPoint { get; }
public Int32 SendBufferSize { get; set; }	public Int32 SendBufferSize { get; set; }
	public Int32 SendTimeout { get; set; }
	public SocketType SocketType { get; }
	static public Boolean SupportsIPv4 { get; }
	static public Boolean SupportsIPv6 { get; }
public Int16 Ttl { get; set; }	public Int16 Ttl { get; set; }
	public Boolean UseOnlyOverlappedIO { get; set; }
	public Socket Accept();
	public Boolean AcceptAsync(SocketAsyncEventArgs e);
	public IAsyncResult BeginAccept(AsyncCallback callback, Object state);
	public IAsyncResult BeginAccept(Int32 receiveSize, AsyncCallback callback, Object state);
	public IAsyncResult BeginAccept(Socket acceptSocket, Int32 receiveSize, AsyncCallback callback, Object state);
	public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, Object state);
	public IAsyncResult BeginConnect(String host, Int32 port, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginConnect(IPAddress address, Int32 port, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginConnect(IPAddress addresses, Int32 port, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginDisconnect(Boolean reuseSocket, AsyncCallback callback, Object state);
	public IAsyncResult BeginReceive(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, AsyncCallback callback, Object state);
	public IAsyncResult BeginReceive(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, out SocketError& errorCode, AsyncCallback callback, Object state);
	public IAsyncResult BeginReceive(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags, AsyncCallback callback, Object state);
	public IAsyncResult BeginReceive(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags, out SocketError& errorCode, AsyncCallback callback, Object state);
	public IAsyncResult BeginReceiveFrom(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, EndPoint& remoteEP, AsyncCallback callback, Object state);
	public IAsyncResult BeginReceiveMessageFrom(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, EndPoint& remoteEP, AsyncCallback callback, Object state);
	public IAsyncResult BeginSend(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, AsyncCallback callback, Object state);
	public IAsyncResult BeginSend(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, out SocketError& errorCode, AsyncCallback callback, Object state);
	public IAsyncResult BeginSend(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags, AsyncCallback callback, Object state);
	public IAsyncResult BeginSend(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags, out SocketError& errorCode, AsyncCallback callback, Object state);
	public IAsyncResult BeginSendFile(String fileName, AsyncCallback callback, Object state);
	public IAsyncResult BeginSendFile(String fileName, Byte preBuffer, Byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, Object state);
	public IAsyncResult BeginSendTo(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, EndPoint remoteEP, AsyncCallback callback, Object state);
	public void Bind(EndPoint localEP);
static public void CancelConnectAsync(SocketAsyncEventArgs e);	static public void CancelConnectAsync(SocketAsyncEventArgs e);
public void Close();	public void Close();
public void Close(Int32 timeout);	public void Close(Int32 timeout);
	public void Connect(EndPoint remoteEP);
	public void Connect(IPAddress address, Int32 port);
	public void Connect(String host, Int32 port);
	public void Connect(IPAddress addresses, Int32 port);
	public Boolean ConnectAsync(SocketAsyncEventArgs e);
static public Boolean ConnectAsync(SocketType socketType, ProtocolType protocolType, SocketAsyncEventArgs e);	static public Boolean ConnectAsync(SocketType socketType, ProtocolType protocolType, SocketAsyncEventArgs e);
public Boolean ConnectAsync(SocketAsyncEventArgs e);
	public void Disconnect(Boolean reuseSocket);
	public Boolean DisconnectAsync(SocketAsyncEventArgs e);
	protected virtual void Dispose(Boolean disposing);
public virtual void Dispose();	public virtual void Dispose();
	public SocketInformation DuplicateAndClose(Int32 targetProcessId);
	public Socket EndAccept(IAsyncResult asyncResult);
	public Socket EndAccept(out Byte& buffer, IAsyncResult asyncResult);
	public Socket EndAccept(out Byte& buffer, out Int32& bytesTransferred, IAsyncResult asyncResult);
	public void EndConnect(IAsyncResult asyncResult);
	public void EndDisconnect(IAsyncResult asyncResult);
	public Int32 EndReceive(IAsyncResult asyncResult);
	public Int32 EndReceive(IAsyncResult asyncResult, out SocketError& errorCode);
	public Int32 EndReceiveFrom(IAsyncResult asyncResult, EndPoint& endPoint);
	public Int32 EndReceiveMessageFrom(IAsyncResult asyncResult, SocketFlags& socketFlags, EndPoint& endPoint, out IPPacketInformation& ipPacketInformation);
	public Int32 EndSend(IAsyncResult asyncResult);
	public Int32 EndSend(IAsyncResult asyncResult, out SocketError& errorCode);
	public void EndSendFile(IAsyncResult asyncResult);
	public Int32 EndSendTo(IAsyncResult asyncResult);
	protected virtual void Finalize();
	public Object GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName);
	public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, Byte optionValue);
	public Byte GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, Int32 optionLength);
	public Int32 IOControl(Int32 ioControlCode, Byte optionInValue, Byte[] optionOutValue);
	public Int32 IOControl(IOControlCode ioControlCode, Byte optionInValue, Byte[] optionOutValue);
	public void Listen(Int32 backlog);
	public Boolean Poll(Int32 microSeconds, SelectMode mode);
	public Int32 Receive(Byte buffer, Int32 size, SocketFlags socketFlags);
	public Int32 Receive(Byte buffer, SocketFlags socketFlags);
	public Int32 Receive(Byte buffer);
	public Int32 Receive(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags);
	public Int32 Receive(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, out SocketError& errorCode);
	public Int32 Receive(IList`1<ArraySegment`1<Byte>> buffers);
	public Int32 Receive(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags);
	public Int32 Receive(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags, out SocketError& errorCode);
public Boolean ReceiveAsync(SocketAsyncEventArgs e);	public Boolean ReceiveAsync(SocketAsyncEventArgs e);
	public Int32 ReceiveFrom(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, EndPoint& remoteEP);
	public Int32 ReceiveFrom(Byte buffer, Int32 size, SocketFlags socketFlags, EndPoint& remoteEP);
	public Int32 ReceiveFrom(Byte buffer, SocketFlags socketFlags, EndPoint& remoteEP);
	public Int32 ReceiveFrom(Byte buffer, EndPoint& remoteEP);
public Boolean ReceiveFromAsync(SocketAsyncEventArgs e);	public Boolean ReceiveFromAsync(SocketAsyncEventArgs e);
	public Int32 ReceiveMessageFrom(Byte buffer, Int32 offset, Int32 size, SocketFlags& socketFlags, EndPoint& remoteEP, out IPPacketInformation& ipPacketInformation);
	public Boolean ReceiveMessageFromAsync(SocketAsyncEventArgs e);
	static public void Select(IList checkRead, IList checkWrite, IList checkError, Int32 microSeconds);
	public Int32 Send(Byte buffer, Int32 size, SocketFlags socketFlags);
	public Int32 Send(Byte buffer, SocketFlags socketFlags);
	public Int32 Send(Byte buffer);
	public Int32 Send(IList`1<ArraySegment`1<Byte>> buffers);
	public Int32 Send(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags);
	public Int32 Send(IList`1<ArraySegment`1<Byte>> buffers, SocketFlags socketFlags, out SocketError& errorCode);
	public Int32 Send(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags);
	public Int32 Send(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, out SocketError& errorCode);
public Boolean SendAsync(SocketAsyncEventArgs e);	public Boolean SendAsync(SocketAsyncEventArgs e);
	public void SendFile(String fileName);
	public void SendFile(String fileName, Byte preBuffer, Byte[] postBuffer, TransmitFileOptions flags);
	public Boolean SendPacketsAsync(SocketAsyncEventArgs e);
	public Int32 SendTo(Byte buffer, Int32 offset, Int32 size, SocketFlags socketFlags, EndPoint remoteEP);
	public Int32 SendTo(Byte buffer, Int32 size, SocketFlags socketFlags, EndPoint remoteEP);
	public Int32 SendTo(Byte buffer, SocketFlags socketFlags, EndPoint remoteEP);
	public Int32 SendTo(Byte buffer, EndPoint remoteEP);
public Boolean SendToAsync(SocketAsyncEventArgs e);	public Boolean SendToAsync(SocketAsyncEventArgs e);
	public void SetIPProtectionLevel(IPProtectionLevel level);
	public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, Int32 optionValue);
	public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, Byte optionValue);
	public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, Boolean optionValue);
	public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, Object optionValue);
public void Shutdown(SocketShutdown how);	public void Shutdown(SocketShutdown how);

public class SocketAsyncEventArgs	public class SocketAsyncEventArgs
: EventArgs, IDisposable	: EventArgs, IDisposable
	public Socket AcceptSocket { get; set; }
public Byte Buffer { get; }	public Byte Buffer { get; }
public IList`1<ArraySegment`1<Byte>> BufferList { get; set; }	public IList`1<ArraySegment`1<Byte>> BufferList { get; set; }
public Int32 BytesTransferred { get; }	public Int32 BytesTransferred { get; }
public Exception ConnectByNameError { get; }	public Exception ConnectByNameError { get; }
public Socket ConnectSocket { get; }	public Socket ConnectSocket { get; }
public Int32 Count { get; }	public Int32 Count { get; }
	public Boolean DisconnectReuseSocket { get; set; }
public SocketAsyncOperation LastOperation { get; }	public SocketAsyncOperation LastOperation { get; }
public Int32 Offset { get; }	public Int32 Offset { get; }
	public IPPacketInformation ReceiveMessageFromPacketInfo { get; }
public EndPoint RemoteEndPoint { get; set; }	public EndPoint RemoteEndPoint { get; set; }
public SocketClientAccessPolicyProtocol SocketClientAccessPolicyProtocol { get; set; }
	public SendPacketsElement SendPacketsElements { get; set; }
	public TransmitFileOptions SendPacketsFlags { get; set; }
	public Int32 SendPacketsSendSize { get; set; }
public SocketError SocketError { get; set; }	public SocketError SocketError { get; set; }
	public SocketFlags SocketFlags { get; set; }
public Object UserToken { get; set; }	public Object UserToken { get; set; }
public event EventHandler`1<SocketAsyncEventArgs> Completed;	public event EventHandler`1<SocketAsyncEventArgs> Completed;
public virtual void Dispose();	public virtual void Dispose();
	protected virtual void Finalize();
	protected virtual void OnCompleted(SocketAsyncEventArgs e);
	public void SetBuffer(Int32 offset, Int32 count);
public void SetBuffer(Byte buffer, Int32 offset, Int32 count);	public void SetBuffer(Byte buffer, Int32 offset, Int32 count);
public void SetBuffer(Int32 offset, Int32 count);

public sealed enum SocketAsyncOperation	public sealed enum SocketAsyncOperation
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ None, Connect, Receive, Send }	{ None, Accept, Connect, Disconnect, Receive, ReceiveFrom, ReceiveMessageFrom, Send, SendPackets, SendTo }

public sealed enum SocketClientAccessPolicyProtocol
: IComparable, IFormattable, IConvertible
{ Tcp, Http }

public sealed enum SocketError	public sealed enum SocketError
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Success, SocketError, Interrupted, AccessDenied, Fault, InvalidArgument, TooManyOpenSockets, WouldBlock, InProgress, AlreadyInProgress, NotSocket, DestinationAddressRequired, MessageSize, ProtocolType, ProtocolOption, ProtocolNotSupported, SocketNotSupported, OperationNotSupported, ProtocolFamilyNotSupported, AddressFamilyNotSupported, AddressAlreadyInUse, AddressNotAvailable, NetworkDown, NetworkUnreachable, NetworkReset, ConnectionAborted, ConnectionReset, NoBufferSpaceAvailable, IsConnected, NotConnected, Shutdown, TimedOut, ConnectionRefused, HostDown, HostUnreachable, ProcessLimit, SystemNotReady, VersionNotSupported, NotInitialized, Disconnecting, TypeNotFound, HostNotFound, TryAgain, NoRecovery, NoData, IOPending, OperationAborted }	{ Success, SocketError, Interrupted, AccessDenied, Fault, InvalidArgument, TooManyOpenSockets, WouldBlock, InProgress, AlreadyInProgress, NotSocket, DestinationAddressRequired, MessageSize, ProtocolType, ProtocolOption, ProtocolNotSupported, SocketNotSupported, OperationNotSupported, ProtocolFamilyNotSupported, AddressFamilyNotSupported, AddressAlreadyInUse, AddressNotAvailable, NetworkDown, NetworkUnreachable, NetworkReset, ConnectionAborted, ConnectionReset, NoBufferSpaceAvailable, IsConnected, NotConnected, Shutdown, TimedOut, ConnectionRefused, HostDown, HostUnreachable, ProcessLimit, SystemNotReady, VersionNotSupported, NotInitialized, Disconnecting, TypeNotFound, HostNotFound, TryAgain, NoRecovery, NoData, IOPending, OperationAborted }

public class SocketException	public class SocketException
: Exception, _Exception	: Win32Exception, ISerializable, _Exception
public Int32 ErrorCode { get; }	public virtual Int32 ErrorCode { get; }
	public virtual String Message { get; }
public SocketError SocketErrorCode { get; }	public SocketError SocketErrorCode { get; }

sealed class ISocketPolicyManager+SocketPolicyCheckCallback
: MulticastDelegate, ICloneable
public virtual IAsyncResult BeginInvoke(SocketPolicyAsyncResult result, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(SocketPolicyAsyncResult result);

	public sealed enum SocketFlags
	: IComparable, IFormattable, IConvertible
	{ None, OutOfBand, Peek, DontRoute, MaxIOVectorLength, Truncated, ControlDataTruncated, Broadcast, Multicast, Partial }

	public sealed struct SocketInformation
	: ValueType
	public SocketInformationOptions Options { get; set; }
	public Byte ProtocolInformation { get; set; }

	public sealed enum SocketInformationOptions
	: IComparable, IFormattable, IConvertible
	{ NonBlocking, Connected, Listening, UseOnlyOverlappedIO }

	public sealed enum SocketOptionLevel
	: IComparable, IFormattable, IConvertible
	{ Socket, IP, IPv6, Tcp, Udp }

	public sealed enum SocketOptionName
	: IComparable, IFormattable, IConvertible
	{ Debug, AcceptConnection, ReuseAddress, KeepAlive, DontRoute, Broadcast, UseLoopback, Linger, OutOfBandInline, DontLinger, ExclusiveAddressUse, SendBuffer, ReceiveBuffer, SendLowWater, ReceiveLowWater, SendTimeout, ReceiveTimeout, Error, Type, MaxConnections, IPOptions, HeaderIncluded, TypeOfService, IpTimeToLive, MulticastInterface, MulticastTimeToLive, MulticastLoopback, AddMembership, DropMembership, DontFragment, AddSourceMembership, DropSourceMembership, BlockSource, UnblockSource, PacketInformation, HopLimit, IPProtectionLevel, IPv6Only, NoDelay, BsdUrgent, Expedited, NoChecksum, ChecksumCoverage, UpdateAcceptContext, UpdateConnectContext }

public sealed enum SocketShutdown	public sealed enum SocketShutdown
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Receive, Send, Both }	{ Receive, Send, Both }

public sealed enum SocketType	public sealed enum SocketType
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Stream, Dgram, Unknown }	{ Stream, Dgram, Raw, Rdm, Seqpacket, Unknown }

	public class TcpClient
	: IDisposable
	protected Boolean Active { get; set; }
	public Int32 Available { get; }
	public Socket Client { get; set; }
	public Boolean Connected { get; }
	public Boolean ExclusiveAddressUse { get; set; }
	public LingerOption LingerState { get; set; }
	public Boolean NoDelay { get; set; }
	public Int32 ReceiveBufferSize { get; set; }
	public Int32 ReceiveTimeout { get; set; }
	public Int32 SendBufferSize { get; set; }
	public Int32 SendTimeout { get; set; }
	public IAsyncResult BeginConnect(String host, Int32 port, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginConnect(IPAddress address, Int32 port, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginConnect(IPAddress addresses, Int32 port, AsyncCallback requestCallback, Object state);
	public void Close();
	public void Connect(String hostname, Int32 port);
	public void Connect(IPAddress address, Int32 port);
	public void Connect(IPEndPoint remoteEP);
	public void Connect(IPAddress ipAddresses, Int32 port);
	public Task ConnectAsync(IPAddress address, Int32 port);
	public Task ConnectAsync(String host, Int32 port);
	public Task ConnectAsync(IPAddress addresses, Int32 port);
	protected virtual void Dispose(Boolean disposing);
	public void EndConnect(IAsyncResult asyncResult);
	protected virtual void Finalize();
	public NetworkStream GetStream();

	public class TcpListener
	protected Boolean Active { get; }
	public Boolean ExclusiveAddressUse { get; set; }
	public EndPoint LocalEndpoint { get; }
	public Socket Server { get; }
	public Socket AcceptSocket();
	public Task`1<Socket> AcceptSocketAsync();
	public TcpClient AcceptTcpClient();
	public Task`1<TcpClient> AcceptTcpClientAsync();
	public void AllowNatTraversal(Boolean allowed);
	public IAsyncResult BeginAcceptSocket(AsyncCallback callback, Object state);
	public IAsyncResult BeginAcceptTcpClient(AsyncCallback callback, Object state);
	static public TcpListener Create(Int32 port);
	public Socket EndAcceptSocket(IAsyncResult asyncResult);
	public TcpClient EndAcceptTcpClient(IAsyncResult asyncResult);
	public Boolean Pending();
	public void Start();
	public void Start(Int32 backlog);
	public void Stop();

	public sealed enum TransmitFileOptions
	: IComparable, IFormattable, IConvertible
	{ UseDefaultWorkerThread, Disconnect, ReuseSocket, WriteBehind, UseSystemThread, UseKernelApc }

public class UdpAnySourceMulticastClient
: IDisposable
public Boolean MulticastLoopback { get; set; }
public Int32 ReceiveBufferSize { get; set; }
public Int32 SendBufferSize { get; set; }
public IAsyncResult BeginJoinGroup(AsyncCallback callback, Object state);
public IAsyncResult BeginReceiveFromGroup(Byte buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state);
public IAsyncResult BeginSendTo(Byte buffer, Int32 offset, Int32 count, IPEndPoint remoteEndPoint, AsyncCallback callback, Object state);
public IAsyncResult BeginSendToGroup(Byte buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state);
public void BlockSource(IPAddress sourceAddress);
public virtual void Dispose();
public void EndJoinGroup(IAsyncResult result);
public Int32 EndReceiveFromGroup(IAsyncResult result, out IPEndPoint& source);
public void EndSendTo(IAsyncResult result);
public void EndSendToGroup(IAsyncResult result);
public void UnblockSource(IPAddress sourceAddress);

public class UdpSingleSourceMulticastClient
: IDisposable
public Int32 ReceiveBufferSize { get; set; }
public Int32 SendBufferSize { get; set; }
public IAsyncResult BeginJoinGroup(AsyncCallback callback, Object state);
public IAsyncResult BeginReceiveFromSource(Byte buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state);
public IAsyncResult BeginSendToSource(Byte buffer, Int32 offset, Int32 count, Int32 remotePort, AsyncCallback callback, Object state);
public virtual void Dispose();
public void EndJoinGroup(IAsyncResult result);
public Int32 EndReceiveFromSource(IAsyncResult result, out Int32& sourcePort);
public void EndSendToSource(IAsyncResult result);

	public class UdpClient
	: IDisposable
	protected Boolean Active { get; set; }
	public Int32 Available { get; }
	public Socket Client { get; set; }
	public Boolean DontFragment { get; set; }
	public Boolean EnableBroadcast { get; set; }
	public Boolean ExclusiveAddressUse { get; set; }
	public Boolean MulticastLoopback { get; set; }
	public Int16 Ttl { get; set; }
	public void AllowNatTraversal(Boolean allowed);
	public IAsyncResult BeginReceive(AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginSend(Byte datagram, Int32 bytes, IPEndPoint endPoint, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginSend(Byte datagram, Int32 bytes, String hostname, Int32 port, AsyncCallback requestCallback, Object state);
	public IAsyncResult BeginSend(Byte datagram, Int32 bytes, AsyncCallback requestCallback, Object state);
	public void Close();
	public void Connect(String hostname, Int32 port);
	public void Connect(IPAddress addr, Int32 port);
	public void Connect(IPEndPoint endPoint);
	protected virtual void Dispose(Boolean disposing);
	public void DropMulticastGroup(IPAddress multicastAddr);
	public void DropMulticastGroup(IPAddress multicastAddr, Int32 ifindex);
	public Byte EndReceive(IAsyncResult asyncResult, IPEndPoint& remoteEP);
	public Int32 EndSend(IAsyncResult asyncResult);
	public void JoinMulticastGroup(IPAddress multicastAddr);
	public void JoinMulticastGroup(IPAddress multicastAddr, IPAddress localAddress);
	public void JoinMulticastGroup(Int32 ifindex, IPAddress multicastAddr);
	public void JoinMulticastGroup(IPAddress multicastAddr, Int32 timeToLive);
	public Byte Receive(IPEndPoint& remoteEP);
	public Task`1<UdpReceiveResult> ReceiveAsync();
	public Int32 Send(Byte dgram, Int32 bytes, IPEndPoint endPoint);
	public Int32 Send(Byte dgram, Int32 bytes, String hostname, Int32 port);
	public Int32 Send(Byte dgram, Int32 bytes);
	public Task`1<Int32> SendAsync(Byte datagram, Int32 bytes);
	public Task`1<Int32> SendAsync(Byte datagram, Int32 bytes, IPEndPoint endPoint);
	public Task`1<Int32> SendAsync(Byte datagram, Int32 bytes, String hostname, Int32 port);

	public sealed struct UdpReceiveResult
	: ValueType, IEquatable`1<UdpReceiveResult>
	public Byte Buffer { get; }
	public IPEndPoint RemoteEndPoint { get; }
	public virtual Boolean Equals(Object obj);
	public virtual Boolean Equals(UdpReceiveResult other);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(UdpReceiveResult left, UdpReceiveResult right);
	static public Boolean op_Inequality(UdpReceiveResult left, UdpReceiveResult right);