533 lines
23 KiB
Markdown
533 lines
23 KiB
Markdown
# System.Net.Sockets
|
|
|
|
``` diff
|
|
+namespace System.Net.Sockets {
|
|
+ public enum AddressFamily {
|
|
+ AppleTalk = 16,
|
|
+ Atm = 22,
|
|
+ Banyan = 21,
|
|
+ Ccitt = 10,
|
|
+ Chaos = 5,
|
|
+ Cluster = 24,
|
|
+ DataKit = 9,
|
|
+ DataLink = 13,
|
|
+ DecNet = 12,
|
|
+ Ecma = 8,
|
|
+ FireFox = 19,
|
|
+ HyperChannel = 15,
|
|
+ Ieee12844 = 25,
|
|
+ ImpLink = 3,
|
|
+ InterNetwork = 2,
|
|
+ InterNetworkV6 = 23,
|
|
+ Ipx = 6,
|
|
+ Irda = 26,
|
|
+ Iso = 7,
|
|
+ Lat = 14,
|
|
+ NetBios = 17,
|
|
+ NetworkDesigners = 28,
|
|
+ NS = 6,
|
|
+ Osi = 7,
|
|
+ Pup = 4,
|
|
+ Sna = 11,
|
|
+ Unix = 1,
|
|
+ Unknown = -1,
|
|
+ Unspecified = 0,
|
|
+ VoiceView = 18,
|
|
+ }
|
|
+ public enum IOControlCode : long {
|
|
+ AbsorbRouterAlert = (long)2550136837,
|
|
+ AddMulticastGroupOnInterface = (long)2550136842,
|
|
+ AddressListChange = (long)671088663,
|
|
+ AddressListQuery = (long)1207959574,
|
|
+ AddressListSort = (long)3355443225,
|
|
+ AssociateHandle = (long)2281701377,
|
|
+ AsyncIO = (long)2147772029,
|
|
+ BindToInterface = (long)2550136840,
|
|
+ DataToRead = (long)1074030207,
|
|
+ DeleteMulticastGroupFromInterface = (long)2550136843,
|
|
+ EnableCircularQueuing = (long)671088642,
|
|
+ Flush = (long)671088644,
|
|
+ GetBroadcastAddress = (long)1207959557,
|
|
+ GetExtensionFunctionPointer = (long)3355443206,
|
|
+ GetGroupQos = (long)3355443208,
|
|
+ GetQos = (long)3355443207,
|
|
+ KeepAliveValues = (long)2550136836,
|
|
+ LimitBroadcasts = (long)2550136839,
|
|
+ MulticastInterface = (long)2550136841,
|
|
+ MulticastScope = (long)2281701386,
|
|
+ MultipointLoopback = (long)2281701385,
|
|
+ NamespaceChange = (long)2281701401,
|
|
+ NonBlockingIO = (long)2147772030,
|
|
+ OobDataRead = (long)1074033415,
|
|
+ QueryTargetPnpHandle = (long)1207959576,
|
|
+ ReceiveAll = (long)2550136833,
|
|
+ ReceiveAllIgmpMulticast = (long)2550136835,
|
|
+ ReceiveAllMulticast = (long)2550136834,
|
|
+ RoutingInterfaceChange = (long)2281701397,
|
|
+ RoutingInterfaceQuery = (long)3355443220,
|
|
+ SetGroupQos = (long)2281701388,
|
|
+ SetQos = (long)2281701387,
|
|
+ TranslateHandle = (long)3355443213,
|
|
+ UnicastInterface = (long)2550136838,
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct IPPacketInformation {
|
|
+ public IPAddress Address { get; }
|
|
+ public int Interface { get; }
|
|
+ public override bool Equals(object comparand);
|
|
+ public override int GetHashCode();
|
|
+ public static bool operator ==(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
|
|
+ public static bool operator !=(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
|
|
+ }
|
|
+ public enum IPProtectionLevel {
|
|
+ EdgeRestricted = 20,
|
|
+ Restricted = 30,
|
|
+ Unrestricted = 10,
|
|
+ Unspecified = -1,
|
|
+ }
|
|
+ public class IPv6MulticastOption {
|
|
+ public IPv6MulticastOption(IPAddress group);
|
|
+ public IPv6MulticastOption(IPAddress group, long ifindex);
|
|
+ public IPAddress Group { get; set; }
|
|
+ public long InterfaceIndex { get; set; }
|
|
+ }
|
|
+ public class LingerOption {
|
|
+ public LingerOption(bool enable, int seconds);
|
|
+ public bool Enabled { get; set; }
|
|
+ public int LingerTime { get; set; }
|
|
+ }
|
|
+ public class MulticastOption {
|
|
+ public MulticastOption(IPAddress group);
|
|
+ public MulticastOption(IPAddress group, int interfaceIndex);
|
|
+ public MulticastOption(IPAddress group, IPAddress mcint);
|
|
+ public IPAddress Group { get; set; }
|
|
+ public int InterfaceIndex { get; set; }
|
|
+ public IPAddress LocalAddress { get; set; }
|
|
+ }
|
|
+ public class NetworkStream : Stream {
|
|
+ public NetworkStream(Socket socket);
|
|
+ public NetworkStream(Socket socket, bool ownsSocket);
|
|
+ public override bool CanRead { get; }
|
|
+ public override bool CanSeek { get; }
|
|
+ public override bool CanTimeout { get; }
|
|
+ public override bool CanWrite { get; }
|
|
+ public virtual bool DataAvailable { get; }
|
|
+ public override long Length { get; }
|
|
+ public override long Position { get; set; }
|
|
+ public override int ReadTimeout { get; set; }
|
|
+ public override int WriteTimeout { get; set; }
|
|
+ protected override void Dispose(bool disposing);
|
|
+ ~NetworkStream();
|
|
+ public override void Flush();
|
|
+ public override Task FlushAsync(CancellationToken cancellationToken);
|
|
+ public override int Read(byte[] buffer, int offset, int size);
|
|
+ public override Task<int> ReadAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken);
|
|
+ public override long Seek(long offset, SeekOrigin origin);
|
|
+ public override void SetLength(long value);
|
|
+ public override void Write(byte[] buffer, int offset, int size);
|
|
+ public override Task WriteAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken);
|
|
+ }
|
|
+ public enum ProtocolType {
|
|
+ Ggp = 3,
|
|
+ Icmp = 1,
|
|
+ IcmpV6 = 58,
|
|
+ Idp = 22,
|
|
+ Igmp = 2,
|
|
+ IP = 0,
|
|
+ IPSecAuthenticationHeader = 51,
|
|
+ IPSecEncapsulatingSecurityPayload = 50,
|
|
+ IPv4 = 4,
|
|
+ IPv6 = 41,
|
|
+ IPv6DestinationOptions = 60,
|
|
+ IPv6FragmentHeader = 44,
|
|
+ IPv6HopByHopOptions = 0,
|
|
+ IPv6NoNextHeader = 59,
|
|
+ IPv6RoutingHeader = 43,
|
|
+ Ipx = 1000,
|
|
+ ND = 77,
|
|
+ Pup = 12,
|
|
+ Raw = 255,
|
|
+ Spx = 1256,
|
|
+ SpxII = 1257,
|
|
+ Tcp = 6,
|
|
+ Udp = 17,
|
|
+ Unknown = -1,
|
|
+ Unspecified = 0,
|
|
+ }
|
|
+ public enum SelectMode {
|
|
+ SelectError = 2,
|
|
+ SelectRead = 0,
|
|
+ SelectWrite = 1,
|
|
+ }
|
|
+ public class SendPacketsElement {
|
|
+ public SendPacketsElement(byte[] buffer);
|
|
+ public SendPacketsElement(byte[] buffer, int offset, int count);
|
|
+ public SendPacketsElement(byte[] buffer, int offset, int count, bool endOfPacket);
|
|
+ public SendPacketsElement(string filepath);
|
|
+ public SendPacketsElement(string filepath, int offset, int count);
|
|
+ public SendPacketsElement(string filepath, int offset, int count, bool endOfPacket);
|
|
+ public byte[] Buffer { get; }
|
|
+ public int Count { get; }
|
|
+ public bool EndOfPacket { get; }
|
|
+ public string FilePath { get; }
|
|
+ public int Offset { get; }
|
|
+ }
|
|
+ public class Socket : IDisposable {
|
|
+ public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType);
|
|
+ public Socket(SocketType socketType, ProtocolType protocolType);
|
|
+ public AddressFamily AddressFamily { get; }
|
|
+ public int Available { get; }
|
|
+ public bool Blocking { get; set; }
|
|
+ public bool Connected { get; }
|
|
+ public bool DontFragment { get; set; }
|
|
+ public bool DualMode { get; set; }
|
|
+ public bool EnableBroadcast { get; set; }
|
|
+ public bool ExclusiveAddressUse { get; set; }
|
|
+ public bool IsBound { get; }
|
|
+ public LingerOption LingerState { get; set; }
|
|
+ public EndPoint LocalEndPoint { get; }
|
|
+ public bool MulticastLoopback { get; set; }
|
|
+ public bool NoDelay { get; set; }
|
|
+ public static bool OSSupportsIPv4 { get; }
|
|
+ public static bool OSSupportsIPv6 { get; }
|
|
+ public ProtocolType ProtocolType { get; }
|
|
+ public int ReceiveBufferSize { get; set; }
|
|
+ public int ReceiveTimeout { get; set; }
|
|
+ public EndPoint RemoteEndPoint { get; }
|
|
+ public int SendBufferSize { get; set; }
|
|
+ public int SendTimeout { get; set; }
|
|
+ public SocketType SocketType { get; }
|
|
+ public short Ttl { get; set; }
|
|
+ public Socket Accept();
|
|
+ public bool AcceptAsync(SocketAsyncEventArgs e);
|
|
+ public void Bind(EndPoint localEP);
|
|
+ public static void CancelConnectAsync(SocketAsyncEventArgs e);
|
|
+ public void Connect(EndPoint remoteEP);
|
|
+ public void Connect(IPAddress address, int port);
|
|
+ public void Connect(IPAddress[] addresses, int port);
|
|
+ public void Connect(string host, int port);
|
|
+ public bool ConnectAsync(SocketAsyncEventArgs e);
|
|
+ public static bool ConnectAsync(SocketType socketType, ProtocolType protocolType, SocketAsyncEventArgs e);
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ ~Socket();
|
|
+ public object GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName);
|
|
+ public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
|
|
+ public byte[] GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionLength);
|
|
+ public int IOControl(int ioControlCode, byte[] optionInValue, byte[] optionOutValue);
|
|
+ public int IOControl(IOControlCode ioControlCode, byte[] optionInValue, byte[] optionOutValue);
|
|
+ public void Listen(int backlog);
|
|
+ public bool Poll(int microSeconds, SelectMode mode);
|
|
+ public int Receive(byte[] buffer);
|
|
+ public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags);
|
|
+ public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode);
|
|
+ public int Receive(byte[] buffer, int size, SocketFlags socketFlags);
|
|
+ public int Receive(byte[] buffer, SocketFlags socketFlags);
|
|
+ public int Receive(IList<ArraySegment<byte>> buffers);
|
|
+ public int Receive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
|
|
+ public int Receive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out SocketError errorCode);
|
|
+ public bool ReceiveAsync(SocketAsyncEventArgs e);
|
|
+ public int ReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
|
|
+ public int ReceiveFrom(byte[] buffer, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
|
|
+ public int ReceiveFrom(byte[] buffer, ref EndPoint remoteEP);
|
|
+ public int ReceiveFrom(byte[] buffer, SocketFlags socketFlags, ref EndPoint remoteEP);
|
|
+ public bool ReceiveFromAsync(SocketAsyncEventArgs e);
|
|
+ public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation);
|
|
+ public bool ReceiveMessageFromAsync(SocketAsyncEventArgs e);
|
|
+ public static void Select(IList checkRead, IList checkWrite, IList checkError, int microSeconds);
|
|
+ public int Send(byte[] buffer);
|
|
+ public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags);
|
|
+ public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode);
|
|
+ public int Send(byte[] buffer, int size, SocketFlags socketFlags);
|
|
+ public int Send(byte[] buffer, SocketFlags socketFlags);
|
|
+ public int Send(IList<ArraySegment<byte>> buffers);
|
|
+ public int Send(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
|
|
+ public int Send(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out SocketError errorCode);
|
|
+ public bool SendAsync(SocketAsyncEventArgs e);
|
|
+ public bool SendPacketsAsync(SocketAsyncEventArgs e);
|
|
+ public int SendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP);
|
|
+ public int SendTo(byte[] buffer, int size, SocketFlags socketFlags, EndPoint remoteEP);
|
|
+ public int SendTo(byte[] buffer, EndPoint remoteEP);
|
|
+ public int SendTo(byte[] buffer, SocketFlags socketFlags, EndPoint remoteEP);
|
|
+ public bool SendToAsync(SocketAsyncEventArgs e);
|
|
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, bool optionValue);
|
|
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
|
|
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue);
|
|
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue);
|
|
+ public void Shutdown(SocketShutdown how);
|
|
+ }
|
|
+ public class SocketAsyncEventArgs : EventArgs, IDisposable {
|
|
+ public SocketAsyncEventArgs();
|
|
+ public Socket AcceptSocket { get; set; }
|
|
+ public byte[] Buffer { get; }
|
|
+ public IList<ArraySegment<byte>> BufferList { get; set; }
|
|
+ public int BytesTransferred { get; }
|
|
+ public Exception ConnectByNameError { get; }
|
|
+ public Socket ConnectSocket { get; }
|
|
+ public int Count { get; }
|
|
+ public SocketAsyncOperation LastOperation { get; }
|
|
+ public int Offset { get; }
|
|
+ public IPPacketInformation ReceiveMessageFromPacketInfo { get; }
|
|
+ public EndPoint RemoteEndPoint { get; set; }
|
|
+ public SendPacketsElement[] SendPacketsElements { get; set; }
|
|
+ public int SendPacketsSendSize { get; set; }
|
|
+ public SocketError SocketError { get; set; }
|
|
+ public SocketFlags SocketFlags { get; set; }
|
|
+ public object UserToken { get; set; }
|
|
+ public event EventHandler<SocketAsyncEventArgs> Completed;
|
|
+ public void Dispose();
|
|
+ ~SocketAsyncEventArgs();
|
|
+ protected virtual void OnCompleted(SocketAsyncEventArgs e);
|
|
+ public void SetBuffer(byte[] buffer, int offset, int count);
|
|
+ public void SetBuffer(int offset, int count);
|
|
+ }
|
|
+ public enum SocketAsyncOperation {
|
|
+ Accept = 1,
|
|
+ Connect = 2,
|
|
+ Disconnect = 3,
|
|
+ None = 0,
|
|
+ Receive = 4,
|
|
+ ReceiveFrom = 5,
|
|
+ ReceiveMessageFrom = 6,
|
|
+ Send = 7,
|
|
+ SendPackets = 8,
|
|
+ SendTo = 9,
|
|
+ }
|
|
+ public enum SocketError {
|
|
+ AccessDenied = 10013,
|
|
+ AddressAlreadyInUse = 10048,
|
|
+ AddressFamilyNotSupported = 10047,
|
|
+ AddressNotAvailable = 10049,
|
|
+ AlreadyInProgress = 10037,
|
|
+ ConnectionAborted = 10053,
|
|
+ ConnectionRefused = 10061,
|
|
+ ConnectionReset = 10054,
|
|
+ DestinationAddressRequired = 10039,
|
|
+ Disconnecting = 10101,
|
|
+ Fault = 10014,
|
|
+ HostDown = 10064,
|
|
+ HostNotFound = 11001,
|
|
+ HostUnreachable = 10065,
|
|
+ InProgress = 10036,
|
|
+ Interrupted = 10004,
|
|
+ InvalidArgument = 10022,
|
|
+ IOPending = 997,
|
|
+ IsConnected = 10056,
|
|
+ MessageSize = 10040,
|
|
+ NetworkDown = 10050,
|
|
+ NetworkReset = 10052,
|
|
+ NetworkUnreachable = 10051,
|
|
+ NoBufferSpaceAvailable = 10055,
|
|
+ NoData = 11004,
|
|
+ NoRecovery = 11003,
|
|
+ NotConnected = 10057,
|
|
+ NotInitialized = 10093,
|
|
+ NotSocket = 10038,
|
|
+ OperationAborted = 995,
|
|
+ OperationNotSupported = 10045,
|
|
+ ProcessLimit = 10067,
|
|
+ ProtocolFamilyNotSupported = 10046,
|
|
+ ProtocolNotSupported = 10043,
|
|
+ ProtocolOption = 10042,
|
|
+ ProtocolType = 10041,
|
|
+ Shutdown = 10058,
|
|
+ SocketError = -1,
|
|
+ SocketNotSupported = 10044,
|
|
+ Success = 0,
|
|
+ SystemNotReady = 10091,
|
|
+ TimedOut = 10060,
|
|
+ TooManyOpenSockets = 10024,
|
|
+ TryAgain = 11002,
|
|
+ TypeNotFound = 10109,
|
|
+ VersionNotSupported = 10092,
|
|
+ WouldBlock = 10035,
|
|
+ }
|
|
+ public class SocketException : Exception {
|
|
+ public SocketException();
|
|
+ public SocketException(int errorCode);
|
|
+ public override string Message { get; }
|
|
+ public SocketError SocketErrorCode { get; }
|
|
+ }
|
|
+ public enum SocketFlags {
|
|
+ Broadcast = 1024,
|
|
+ ControlDataTruncated = 512,
|
|
+ DontRoute = 4,
|
|
+ Multicast = 2048,
|
|
+ None = 0,
|
|
+ OutOfBand = 1,
|
|
+ Partial = 32768,
|
|
+ Peek = 2,
|
|
+ Truncated = 256,
|
|
+ }
|
|
+ public enum SocketOptionLevel {
|
|
+ IP = 0,
|
|
+ IPv6 = 41,
|
|
+ Socket = 65535,
|
|
+ Tcp = 6,
|
|
+ Udp = 17,
|
|
+ }
|
|
+ public enum SocketOptionName {
|
|
+ AcceptConnection = 2,
|
|
+ AddMembership = 12,
|
|
+ AddSourceMembership = 15,
|
|
+ BlockSource = 17,
|
|
+ Broadcast = 32,
|
|
+ BsdUrgent = 2,
|
|
+ ChecksumCoverage = 20,
|
|
+ Debug = 1,
|
|
+ DontFragment = 14,
|
|
+ DontLinger = -129,
|
|
+ DontRoute = 16,
|
|
+ DropMembership = 13,
|
|
+ DropSourceMembership = 16,
|
|
+ Error = 4103,
|
|
+ ExclusiveAddressUse = -5,
|
|
+ Expedited = 2,
|
|
+ HeaderIncluded = 2,
|
|
+ HopLimit = 21,
|
|
+ IPOptions = 1,
|
|
+ IPProtectionLevel = 23,
|
|
+ IpTimeToLive = 4,
|
|
+ IPv6Only = 27,
|
|
+ KeepAlive = 8,
|
|
+ Linger = 128,
|
|
+ MaxConnections = 2147483647,
|
|
+ MulticastInterface = 9,
|
|
+ MulticastLoopback = 11,
|
|
+ MulticastTimeToLive = 10,
|
|
+ NoChecksum = 1,
|
|
+ NoDelay = 1,
|
|
+ OutOfBandInline = 256,
|
|
+ PacketInformation = 19,
|
|
+ ReceiveBuffer = 4098,
|
|
+ ReceiveLowWater = 4100,
|
|
+ ReceiveTimeout = 4102,
|
|
+ ReuseAddress = 4,
|
|
+ ReuseUnicastPort = 12295,
|
|
+ SendBuffer = 4097,
|
|
+ SendLowWater = 4099,
|
|
+ SendTimeout = 4101,
|
|
+ Type = 4104,
|
|
+ TypeOfService = 3,
|
|
+ UnblockSource = 18,
|
|
+ UpdateAcceptContext = 28683,
|
|
+ UpdateConnectContext = 28688,
|
|
+ UseLoopback = 64,
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct SocketReceiveFromResult {
|
|
+ public int ReceivedBytes;
|
|
+ public EndPoint RemoteEndPoint;
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct SocketReceiveMessageFromResult {
|
|
+ public int ReceivedBytes;
|
|
+ public EndPoint RemoteEndPoint;
|
|
+ public IPPacketInformation PacketInformation;
|
|
+ public SocketFlags SocketFlags;
|
|
+ }
|
|
+ public enum SocketShutdown {
|
|
+ Both = 2,
|
|
+ Receive = 0,
|
|
+ Send = 1,
|
|
+ }
|
|
+ public static class SocketTaskExtensions {
|
|
+ public static Task<Socket> AcceptAsync(this Socket socket);
|
|
+ public static Task<Socket> AcceptAsync(this Socket socket, Socket acceptSocket);
|
|
+ public static Task ConnectAsync(this Socket socket, EndPoint remoteEP);
|
|
+ public static Task ConnectAsync(this Socket socket, IPAddress address, int port);
|
|
+ public static Task ConnectAsync(this Socket socket, IPAddress[] addresses, int port);
|
|
+ public static Task ConnectAsync(this Socket socket, string host, int port);
|
|
+ public static Task<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
|
|
+ public static Task<int> ReceiveAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
|
|
+ public static Task<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
|
|
+ public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
|
|
+ public static Task<int> SendAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
|
|
+ public static Task<int> SendAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
|
|
+ public static Task<int> SendToAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);
|
|
+ }
|
|
+ public enum SocketType {
|
|
+ Dgram = 2,
|
|
+ Raw = 3,
|
|
+ Rdm = 4,
|
|
+ Seqpacket = 5,
|
|
+ Stream = 1,
|
|
+ Unknown = -1,
|
|
+ }
|
|
+ public class TcpClient : IDisposable {
|
|
+ public TcpClient();
|
|
+ public TcpClient(AddressFamily family);
|
|
+ protected bool Active { get; set; }
|
|
+ public int Available { get; }
|
|
+ public Socket Client { get; set; }
|
|
+ public bool Connected { get; }
|
|
+ public bool ExclusiveAddressUse { get; set; }
|
|
+ public LingerOption LingerState { get; set; }
|
|
+ public bool NoDelay { get; set; }
|
|
+ public int ReceiveBufferSize { get; set; }
|
|
+ public int ReceiveTimeout { get; set; }
|
|
+ public int SendBufferSize { get; set; }
|
|
+ public int SendTimeout { get; set; }
|
|
+ public Task ConnectAsync(IPAddress address, int port);
|
|
+ public Task ConnectAsync(IPAddress[] addresses, int port);
|
|
+ public Task ConnectAsync(string host, int port);
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ ~TcpClient();
|
|
+ public NetworkStream GetStream();
|
|
+ }
|
|
+ public class TcpListener {
|
|
+ public TcpListener(IPAddress localaddr, int port);
|
|
+ public TcpListener(IPEndPoint localEP);
|
|
+ protected bool Active { get; }
|
|
+ public bool ExclusiveAddressUse { get; set; }
|
|
+ public EndPoint LocalEndpoint { get; }
|
|
+ public Socket Server { get; }
|
|
+ public Task<Socket> AcceptSocketAsync();
|
|
+ public Task<TcpClient> AcceptTcpClientAsync();
|
|
+ public bool Pending();
|
|
+ public void Start();
|
|
+ public void Start(int backlog);
|
|
+ public void Stop();
|
|
+ }
|
|
+ public class UdpClient : IDisposable {
|
|
+ public UdpClient();
|
|
+ public UdpClient(int port);
|
|
+ public UdpClient(int port, AddressFamily family);
|
|
+ public UdpClient(IPEndPoint localEP);
|
|
+ public UdpClient(AddressFamily family);
|
|
+ protected bool Active { get; set; }
|
|
+ public int Available { get; }
|
|
+ public Socket Client { get; set; }
|
|
+ public bool DontFragment { get; set; }
|
|
+ public bool EnableBroadcast { get; set; }
|
|
+ public bool ExclusiveAddressUse { get; set; }
|
|
+ public bool MulticastLoopback { get; set; }
|
|
+ public short Ttl { get; set; }
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ public void DropMulticastGroup(IPAddress multicastAddr);
|
|
+ public void DropMulticastGroup(IPAddress multicastAddr, int ifindex);
|
|
+ public void JoinMulticastGroup(int ifindex, IPAddress multicastAddr);
|
|
+ public void JoinMulticastGroup(IPAddress multicastAddr);
|
|
+ public void JoinMulticastGroup(IPAddress multicastAddr, int timeToLive);
|
|
+ public void JoinMulticastGroup(IPAddress multicastAddr, IPAddress localAddress);
|
|
+ public Task<UdpReceiveResult> ReceiveAsync();
|
|
+ public Task<int> SendAsync(byte[] datagram, int bytes, IPEndPoint endPoint);
|
|
+ public Task<int> SendAsync(byte[] datagram, int bytes, string hostname, int port);
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct UdpReceiveResult : IEquatable<UdpReceiveResult> {
|
|
+ public UdpReceiveResult(byte[] buffer, IPEndPoint remoteEndPoint);
|
|
+ public byte[] Buffer { get; }
|
|
+ public IPEndPoint RemoteEndPoint { get; }
|
|
+ public bool Equals(UdpReceiveResult other);
|
|
+ public override bool Equals(object obj);
|
|
+ public override int GetHashCode();
|
|
+ public static bool operator ==(UdpReceiveResult left, UdpReceiveResult right);
|
|
+ public static bool operator !=(UdpReceiveResult left, UdpReceiveResult right);
|
|
+ }
|
|
+}
|
|
```
|
|
|