Socket 类

定义

实现 Berkeley 套接字接口。

public ref class Socket : IDisposable
public class Socket : IDisposable
type Socket = class
    interface IDisposable
Public Class Socket
Implements IDisposable
继承
Socket
实现

示例

以下示例演示如何 Socket 使用 类将数据发送到 HTTP 服务器,并将 ASCII 响应打印到标准输出。 此示例阻止调用线程,直到收到整个页面。

private static void SendHttpRequest(Uri? uri = null, int port = 80)
{
    uri ??= new Uri("http://example.com");

    // Construct a minimalistic HTTP/1.1 request
    byte[] requestBytes = Encoding.ASCII.GetBytes(@$"GET {uri.AbsoluteUri} HTTP/1.0
Host: {uri.Host}
Connection: Close

");

    // Create and connect a dual-stack socket
    using Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
    socket.Connect(uri.Host, port);

    // Send the request.
    // For the tiny amount of data in this example, the first call to Send() will likely deliver the buffer completely,
    // however this is not guaranteed to happen for larger real-life buffers.
    // The best practice is to iterate until all the data is sent.
    int bytesSent = 0;
    while (bytesSent < requestBytes.Length)
    {
        bytesSent += socket.Send(requestBytes, bytesSent, requestBytes.Length - bytesSent, SocketFlags.None);
    }

    // Do minimalistic buffering assuming ASCII response
    byte[] responseBytes = new byte[256];
    char[] responseChars = new char[256];

    while (true)
    {
        int bytesReceived = socket.Receive(responseBytes);

        // Receiving 0 bytes means EOF has been reached
        if (bytesReceived == 0) break;

        // Convert byteCount bytes to ASCII characters using the 'responseChars' buffer as destination
        int charCount = Encoding.ASCII.GetChars(responseBytes, 0, bytesReceived, responseChars, 0);

        // Print the contents of the 'responseChars' buffer to Console.Out
        Console.Out.Write(responseChars, 0, charCount);
    }
}

下一个示例演示相同的 HTTP GET 方案,使用基于任务的异步 API,同时将 转发 CancellationToken 到异步方法,使整个操作可取消。

提示

Socket不采用 CancellationToken 的异步方法通常返回 Task,该方法在堆上分配。 可取消重载始终 ValueTask返回 ;使用它们有助于减少高性能代码中的分配。

private static async Task SendHttpRequestAsync(Uri? uri = null, int port = 80, CancellationToken cancellationToken = default)
{
    uri ??= new Uri("http://example.com");

    // Construct a minimalistic HTTP/1.1 request
    byte[] requestBytes = Encoding.ASCII.GetBytes(@$"GET {uri.AbsoluteUri} HTTP/1.1
Host: {uri.Host}
Connection: Close

");

    // Create and connect a dual-stack socket
    using Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
    await socket.ConnectAsync(uri.Host, port, cancellationToken);

    // Send the request.
    // For the tiny amount of data in this example, the first call to SendAsync() will likely deliver the buffer completely,
    // however this is not guaranteed to happen for larger real-life buffers.
    // The best practice is to iterate until all the data is sent.
    int bytesSent = 0;
    while (bytesSent < requestBytes.Length)
    {
        bytesSent += await socket.SendAsync(requestBytes.AsMemory(bytesSent), SocketFlags.None);
    }

    // Do minimalistic buffering assuming ASCII response
    byte[] responseBytes = new byte[256];
    char[] responseChars = new char[256];

    while (true)
    {
        int bytesReceived = await socket.ReceiveAsync(responseBytes, SocketFlags.None, cancellationToken);

        // Receiving 0 bytes means EOF has been reached
        if (bytesReceived == 0) break;

        // Convert byteCount bytes to ASCII characters using the 'responseChars' buffer as destination
        int charCount = Encoding.ASCII.GetChars(responseBytes, 0, bytesReceived, responseChars, 0);

        // Print the contents of the 'responseChars' buffer to Console.Out
        await Console.Out.WriteAsync(responseChars.AsMemory(0, charCount), cancellationToken);
    }
}

注解

有关此 API 的详细信息,请参阅 套接字的补充 API 备注

构造函数

Socket(AddressFamily, SocketType, ProtocolType)

使用指定的地址族、套接字类型和协议初始化 Socket 类的新实例。

Socket(SafeSocketHandle)

为指定的套接字句柄初始化 Socket 类的新实例。

Socket(SocketInformation)

使用 Socket 返回的指定的值初始化 DuplicateAndClose(Int32) 类的新实例。

Socket(SocketType, ProtocolType)

使用指定的地址族、套接字类型和协议初始化 Socket 类的新实例。 如果操作系统支持 IPv6,则此构造函数将创建双模式套接字;否则,它将创建 IPv4 套接字。

属性

AddressFamily

获取 Socket 的地址族。

Available

获取已经从网络接收且可供读取的数据量。

Blocking

获取或设置一个值,该值指示 Socket 是否处于阻止模式。

Connected

获取一个值,该值指示 Socket 是在上次 Send 还是 Receive 操作时连接到远程主机。

DontFragment

获取或设置一个值,该值指定 Socket 是否允许将 Internet 协议 (IP) 数据报分段。

DualMode

获取或设置一个值, Socket 该值指定 是否是同时用于 IPv4 和 IPv6 的双模式套接字。

EnableBroadcast

获取或设置一个 Boolean 值,该值指定 是否可以 Socket 发送广播数据包。

ExclusiveAddressUse

获取或设置 Boolean 值,该值指定 Socket 是否仅允许一个进程绑定到端口。

Handle

获取 Socket 的操作系统句柄。

IsBound

获取一个值,该值指示 Socket 是否绑定到特定本地端口。

LingerState

获取或设置一个值,该值指定 Socket 在尝试发送所有挂起数据时是否延迟关闭套接字。

LocalEndPoint

获取本地终结点。

MulticastLoopback

获取或设置一个值,该值指定传出的多路广播数据包是否传递到发送应用程序。

NoDelay

获取或设置 Boolean 值,该值指定流 Socket 是否正在使用 Nagle 算法。

OSSupportsIPv4

指示基础操作系统和网络适配器是否支持 Internet 协议第 4 版 (IPv4)。

OSSupportsIPv6

指示基础操作系统和网络适配器是否支持 Internet 协议第 6 版 (IPv6)。

OSSupportsUnixDomainSockets

指示基础操作系统是否支持 Unix 域套接字。

ProtocolType

获取 Socket 的协议类型。

ReceiveBufferSize

获取或设置一个值,它指定 Socket 接收缓冲区的大小。

ReceiveTimeout

获取或设置一个值,该值指定之后同步 Receive 调用将超时的时间长度。

RemoteEndPoint

获取远程终结点。

SafeHandle

获取一个 SafeSocketHandle,它表示当前 Socket 对象封装的套接字句柄。

SendBufferSize

获取或设置一个值,该值指定 Socket 发送缓冲区的大小。

SendTimeout

获取或设置一个值,该值指定之后同步 Send 调用将超时的时间长度。

SocketType

获取 Socket 的类型。

SupportsIPv4
已过时.
已过时.
已过时.

获取一个值,该值指示在当前主机上 IPv4 支持是否可用并且已启用。

SupportsIPv6
已过时.
已过时.
已过时.

获取一个值,该值指示 Framework 对某些已过时的 Dns 成员是否支持 IPv6。

Ttl

获取或设置一个值,指定 Socket 发送的 Internet 协议 (IP) 数据包的生存时间 (TTL) 值。

UseOnlyOverlappedIO
已过时.

获取或设置一个值,该值指定套接字是否应仅使用重叠 I/O 模式。 在 .NET 5+ ((包括 .NET Core 版本) )上,值始终 false为 。

方法

Accept()

为新建连接创建新的 Socket

AcceptAsync()

接受传入连接。

AcceptAsync(CancellationToken)

接受传入连接。

AcceptAsync(Socket)

接受传入连接。

AcceptAsync(Socket, CancellationToken)

接受传入连接。

AcceptAsync(SocketAsyncEventArgs)

开始一个异步操作来接受一个传入的连接尝试。

BeginAccept(AsyncCallback, Object)

开始一个异步操作来接受一个传入的连接尝试。

BeginAccept(Int32, AsyncCallback, Object)

开始异步操作以接受传入的连接尝试并接收客户端应用程序发送的第一个数据块。

BeginAccept(Socket, Int32, AsyncCallback, Object)

开始异步操作以接受从指定套接字传入的连接尝试并接收客户端应用程序发送的第一个数据块。

BeginConnect(EndPoint, AsyncCallback, Object)

开始一个对远程主机连接的异步请求。

BeginConnect(IPAddress, Int32, AsyncCallback, Object)

开始一个对远程主机连接的异步请求。 主机由 IPAddress 和端口号指定。

BeginConnect(IPAddress[], Int32, AsyncCallback, Object)

开始一个对远程主机连接的异步请求。 主机由 IPAddress 数组和端口号指定。

BeginConnect(String, Int32, AsyncCallback, Object)

开始一个对远程主机连接的异步请求。 主机由主机名和端口号指定。

BeginDisconnect(Boolean, AsyncCallback, Object)

开始异步请求从远程终结点断开连接。

BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)

开始从连接的 Socket 中异步接收数据。

BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)

开始从连接的 Socket 中异步接收数据。

BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)

开始从连接的 Socket 中异步接收数据。

BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)

开始从连接的 Socket 中异步接收数据。

BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)

开始从指定网络设备中异步接收数据。

BeginReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)

开始使用指定的 SocketFlags 将指定字节数的数据异步接收到数据缓冲区的指定位置,然后存储终结点和数据包信息。

BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)

将数据异步发送到连接的 Socket

BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)

将数据异步发送到连接的 Socket

BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)

将数据异步发送到连接的 Socket

BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)

将数据异步发送到连接的 Socket

BeginSendFile(String, AsyncCallback, Object)

使用 Socket 标志,将文件 fileName 发送到连接的 UseDefaultWorkerThread 对象。

BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object)

将文件和数据缓冲区异步发送到连接的 Socket 对象。

BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)

以异步方式将数据发送到特定远程主机。

Bind(EndPoint)

使 Socket 与一个本地终结点相关联。

CancelConnectAsync(SocketAsyncEventArgs)

取消一个对远程主机连接的异步请求。

Close()

关闭 Socket 连接并释放所有关联的资源。

Close(Int32)

关闭 Socket 连接并释放所有与指定超时关联的资源,以允许要发送的数据排队。

Connect(EndPoint)

与远程主机建立连接。

Connect(IPAddress, Int32)

与远程主机建立连接。 主机由 IP 地址和端口号指定。

Connect(IPAddress[], Int32)

与远程主机建立连接。 主机由 IP 地址数组和端口号指定。

Connect(String, Int32)

与远程主机建立连接。 主机由主机名和端口号指定。

ConnectAsync(EndPoint)

与远程主机建立连接。

ConnectAsync(EndPoint, CancellationToken)

与远程主机建立连接。

ConnectAsync(IPAddress, Int32)

与远程主机建立连接。

ConnectAsync(IPAddress, Int32, CancellationToken)

与远程主机建立连接。

ConnectAsync(IPAddress[], Int32)

与远程主机建立连接。

ConnectAsync(IPAddress[], Int32, CancellationToken)

与远程主机建立连接。

ConnectAsync(SocketAsyncEventArgs)

开始一个对远程主机连接的异步请求。

ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs)

开始一个对远程主机连接的异步请求。

ConnectAsync(String, Int32)

与远程主机建立连接。

ConnectAsync(String, Int32, CancellationToken)

与远程主机建立连接。

Disconnect(Boolean)

关闭套接字连接并允许重用套接字。

DisconnectAsync(Boolean, CancellationToken)

断开已连接套接字与远程主机的连接。

DisconnectAsync(SocketAsyncEventArgs)

开始异步请求从远程终结点断开连接。

Dispose()

释放 Socket 类的当前实例所使用的所有资源。

Dispose(Boolean)

释放由 Socket 使用的非托管资源,并可根据需要释放托管资源。

DuplicateAndClose(Int32)

重复目标进程的套接字引用,并关闭此进程的套接字。

EndAccept(Byte[], IAsyncResult)

异步接受传入的连接尝试,并创建新的 Socket 对象来处理远程主机通信。 此方法返回包含所传输的初始数据的缓冲区。

EndAccept(Byte[], Int32, IAsyncResult)

异步接受传入的连接尝试,并创建新的 Socket 对象来处理远程主机通信。 此方法返回一个缓冲区,其中包含初始数据和传输的字节数。

EndAccept(IAsyncResult)

异步接受传入的连接尝试,并创建新的 Socket 来处理远程主机通信。

EndConnect(IAsyncResult)

结束挂起的异步连接请求。

EndDisconnect(IAsyncResult)

结束挂起的异步断开连接请求。

EndReceive(IAsyncResult)

结束挂起的异步读取。

EndReceive(IAsyncResult, SocketError)

结束挂起的异步读取。

EndReceiveFrom(IAsyncResult, EndPoint)

结束挂起的、从特定终结点进行异步读取。

EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation)

结束挂起的、从特定终结点进行异步读取。 此方法还显示有关数据包而不是 EndReceiveFrom(IAsyncResult, EndPoint) 的更多信息。

EndSend(IAsyncResult)

结束挂起的异步发送。

EndSend(IAsyncResult, SocketError)

结束挂起的异步发送。

EndSendFile(IAsyncResult)

结束文件的挂起异步发送。

EndSendTo(IAsyncResult)

结束挂起的、向指定位置进行的异步发送。

Equals(Object)

确定指定对象是否等于当前对象。

(继承自 Object)
Finalize()

释放 Socket 类使用的资源。

GetHashCode()

返回 Socket 实例的哈希值。

GetHashCode()

作为默认哈希函数。

(继承自 Object)
GetRawSocketOption(Int32, Int32, Span<Byte>)

使用特定于平台的级别和名称标识符获取套接字选项值。

GetSocketOption(SocketOptionLevel, SocketOptionName)

返回指定的 Socket 选项的值,表示为一个对象。

GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

返回指定的 Socket 选项设置,表示为字节数组。

GetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

返回数组中指定的 Socket 选项的值。

GetType()

获取当前实例的 Type

(继承自 Object)
IOControl(Int32, Byte[], Byte[])

使用数字控制代码,为 Socket 设置低级操作模式。

IOControl(IOControlCode, Byte[], Byte[])

使用 Socket 枚举指定控制代码,为 IOControlCode 设置低级操作模式。

Listen()

Socket 置于侦听状态。

Listen(Int32)

Socket 置于侦听状态。

MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 Object)
Poll(Int32, SelectMode)

确定 Socket 的状态。

Poll(TimeSpan, SelectMode)

确定 Socket 的状态。

Receive(Byte[])

从绑定的 Socket 套接字接收数据,将数据存入接收缓冲区。

Receive(Byte[], Int32, Int32, SocketFlags)

使用指定的 Socket,从绑定的 SocketFlags 接收指定的字节数,存入接收缓冲区的指定偏移量位置。

Receive(Byte[], Int32, Int32, SocketFlags, SocketError)

使用指定的 Socket,从绑定的 SocketFlags 接收数据,将数据存入接收缓冲区。

Receive(Byte[], Int32, SocketFlags)

使用指定的 Socket,从绑定的 SocketFlags 接收指定字节数的数据,并将数据存入接收缓冲区。

Receive(Byte[], SocketFlags)

使用指定的 Socket,从绑定的 SocketFlags 接收数据,将数据存入接收缓冲区。

Receive(IList<ArraySegment<Byte>>)

从绑定的 Socket 接收数据,将数据存入接收缓冲区列表中。

Receive(IList<ArraySegment<Byte>>, SocketFlags)

使用指定的 Socket,从绑定的 SocketFlags 接收数据,将数据存入接收缓冲区列表中。

Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

使用指定的 Socket,从绑定的 SocketFlags 接收数据,将数据存入接收缓冲区列表中。

Receive(Span<Byte>)

从绑定的 Socket 套接字接收数据,将数据存入接收缓冲区。

Receive(Span<Byte>, SocketFlags)

使用指定的 Socket,从绑定的 SocketFlags 接收数据,将数据存入接收缓冲区。

Receive(Span<Byte>, SocketFlags, SocketError)

使用指定的 Socket,从绑定的 SocketFlags 接收数据,将数据存入接收缓冲区。

ReceiveAsync(ArraySegment<Byte>)

接收连接的套接字发出的数据。

ReceiveAsync(ArraySegment<Byte>, SocketFlags)

接收连接的套接字发出的数据。

ReceiveAsync(IList<ArraySegment<Byte>>)

接收连接的套接字发出的数据。

ReceiveAsync(IList<ArraySegment<Byte>>, SocketFlags)

接收连接的套接字发出的数据。

ReceiveAsync(Memory<Byte>, CancellationToken)

接收连接的套接字发出的数据。

ReceiveAsync(Memory<Byte>, SocketFlags, CancellationToken)

接收连接的套接字发出的数据。

ReceiveAsync(SocketAsyncEventArgs)

开始一个异步请求以便从连接的 Socket 对象中接收数据。

ReceiveFrom(Byte[], EndPoint)

将数据报接收到数据缓冲区并存储终结点。

ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)

使用指定的 SocketFlags 将指定的数据字节数接收到数据缓冲区的指定位置,并存储终结点。

ReceiveFrom(Byte[], Int32, SocketFlags, EndPoint)

使用指定的 SocketFlags 将指定的字节数接收到数据缓冲区并存储终结点。

ReceiveFrom(Byte[], SocketFlags, EndPoint)

使用指定的 SocketFlags 将数据报接收到数据缓冲区并存储终结点。

ReceiveFrom(Span<Byte>, EndPoint)

将数据报接收到数据缓冲区并存储终结点。

ReceiveFrom(Span<Byte>, SocketFlags, EndPoint)

使用指定的 SocketFlags 将数据报接收到数据缓冲区并存储终结点。

ReceiveFrom(Span<Byte>, SocketFlags, SocketAddress)

使用指定的 SocketFlags 将数据报接收到数据缓冲区并存储终结点。

ReceiveFromAsync(ArraySegment<Byte>, EndPoint)

接收数据并返回发送主机的终结点。

ReceiveFromAsync(ArraySegment<Byte>, SocketFlags, EndPoint)

接收数据并返回发送主机的终结点。

ReceiveFromAsync(Memory<Byte>, EndPoint, CancellationToken)

接收数据并返回发送主机的终结点。

ReceiveFromAsync(Memory<Byte>, SocketFlags, EndPoint, CancellationToken)

接收数据并返回发送主机的终结点。

ReceiveFromAsync(Memory<Byte>, SocketFlags, SocketAddress, CancellationToken)

使用指定的 SocketFlags 将数据报接收到数据缓冲区并存储终结点。

ReceiveFromAsync(SocketAsyncEventArgs)

开始从指定网络设备中异步接收数据。

ReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, IPPacketInformation)

使用指定的 SocketFlags 将指定字节数的数据接收到指定的数据缓冲区位置,并存储终结点和数据包信息。

ReceiveMessageFrom(Span<Byte>, SocketFlags, EndPoint, IPPacketInformation)

使用指定的 socketFlags 将指定字节数的数据接收到指定的数据缓冲区位置,并存储终结点和数据包信息。

ReceiveMessageFromAsync(ArraySegment<Byte>, EndPoint)

接收数据并返回有关邮件发件人的其他信息。

ReceiveMessageFromAsync(ArraySegment<Byte>, SocketFlags, EndPoint)

接收数据并返回有关邮件发件人的其他信息。

ReceiveMessageFromAsync(Memory<Byte>, EndPoint, CancellationToken)

接收数据并返回有关邮件发件人的其他信息。

ReceiveMessageFromAsync(Memory<Byte>, SocketFlags, EndPoint, CancellationToken)

接收数据并返回有关邮件发件人的其他信息。

ReceiveMessageFromAsync(SocketAsyncEventArgs)

开始使用指定的 SocketFlags 将指定字节数的数据异步接收到数据缓冲区的指定位置,并存储终结点和数据包信息。

Select(IList, IList, IList, Int32)

确定一个或多个套接字的状态。

Select(IList, IList, IList, TimeSpan)

确定一个或多个套接字的状态。

Send(Byte[])

将数据发送到连接的 Socket

Send(Byte[], Int32, Int32, SocketFlags)

从指定偏移量开始,使用指定 SocketFlags,将指定的数据字节数发送到已连接的 Socket

Send(Byte[], Int32, Int32, SocketFlags, SocketError)

从指定偏移量开始,使用指定 SocketFlags,将指定的数据字节数发送到已连接的 Socket

Send(Byte[], Int32, SocketFlags)

使用指定的 Socket,将指定字节数的数据发送到已连接的 SocketFlags

Send(Byte[], SocketFlags)

使用指定的 Socket 将数据发送到连接的 SocketFlags

Send(IList<ArraySegment<Byte>>)

将列表中的一组缓冲区发送到连接的 Socket

Send(IList<ArraySegment<Byte>>, SocketFlags)

使用指定的 Socket,将列表中的一组缓冲区发送到连接的 SocketFlags

Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

使用指定的 Socket,将列表中的一组缓冲区发送到连接的 SocketFlags

Send(ReadOnlySpan<Byte>)

将数据发送到连接的 Socket

Send(ReadOnlySpan<Byte>, SocketFlags)

使用指定的 Socket 将数据发送到连接的 SocketFlags

Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)

使用指定的 Socket 将数据发送到连接的 SocketFlags

SendAsync(ArraySegment<Byte>)

在连接的套接字上发送数据。

SendAsync(ArraySegment<Byte>, SocketFlags)

在连接的套接字上发送数据。

SendAsync(IList<ArraySegment<Byte>>)

在连接的套接字上发送数据。

SendAsync(IList<ArraySegment<Byte>>, SocketFlags)

在连接的套接字上发送数据。

SendAsync(ReadOnlyMemory<Byte>, CancellationToken)

在连接的套接字上发送数据。

SendAsync(ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)

在连接的套接字上发送数据。

SendAsync(SocketAsyncEventArgs)

将数据异步发送到连接的 Socket 对象。

SendFile(String)

使用 Socket 传输标志,将文件 fileName 发送到连接的 UseDefaultWorkerThread 对象。

SendFile(String, Byte[], Byte[], TransmitFileOptions)

通过指定的 TransmitFileOptions 值,将文件 fileName 和数据缓冲区发送到连接的 Socket 对象。

SendFile(String, ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, TransmitFileOptions)

通过指定的 TransmitFileOptions 值,将文件 fileName 和数据缓冲区发送到连接的 Socket 对象。

SendFileAsync(String, CancellationToken)

将文件 fileName 发送到连接的 Socket 对象。

SendFileAsync(String, ReadOnlyMemory<Byte>, ReadOnlyMemory<Byte>, TransmitFileOptions, CancellationToken)

通过指定的 TransmitFileOptions 值,将文件 fileName 和数据缓冲区发送到连接的 Socket 对象。

SendPacketsAsync(SocketAsyncEventArgs)

将文件集合或者内存中的数据缓冲区以异步方法发送给连接的 Socket 对象。

SendTo(Byte[], EndPoint)

将数据发送到指定的终结点。

SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)

使用指定的 SocketFlags,将指定字节数的数据发送到指定终结点(从缓冲区中的指定位置开始)。

SendTo(Byte[], Int32, SocketFlags, EndPoint)

使用指定的 SocketFlags,将指定字节数的数据发送到指定的终结点。

SendTo(Byte[], SocketFlags, EndPoint)

使用指定的 SocketFlags,将数据发送到特定的终结点。

SendTo(ReadOnlySpan<Byte>, EndPoint)

将数据发送到指定的终结点。

SendTo(ReadOnlySpan<Byte>, SocketFlags, EndPoint)

使用指定的 SocketFlags,将数据发送到特定的终结点。

SendTo(ReadOnlySpan<Byte>, SocketFlags, SocketAddress)

使用指定的 SocketFlags,将数据发送到特定的终结点。

SendToAsync(ArraySegment<Byte>, EndPoint)

将数据发送到指定的远程主机。

SendToAsync(ArraySegment<Byte>, SocketFlags, EndPoint)

将数据发送到指定的远程主机。

SendToAsync(ReadOnlyMemory<Byte>, EndPoint, CancellationToken)

将数据发送到指定的远程主机。

SendToAsync(ReadOnlyMemory<Byte>, SocketFlags, EndPoint, CancellationToken)

将数据发送到指定的远程主机。

SendToAsync(ReadOnlyMemory<Byte>, SocketFlags, SocketAddress, CancellationToken)

使用指定的 SocketFlags,将数据发送到特定的终结点。

SendToAsync(SocketAsyncEventArgs)

以异步方式将数据发送到特定远程主机。

SetIPProtectionLevel(IPProtectionLevel)

设置套接字上的 IP 保护级别。

SetRawSocketOption(Int32, Int32, ReadOnlySpan<Byte>)

使用特定于平台的级别和名称标识符设置套接字选项值。

SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean)

将指定的 Socket 选项设置为指定的 Boolean 值。

SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

将指定的 Socket 选项设置为指定的值,表示为字节数组。

SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

将指定的 Socket 选项设置为指定的整数值。

SetSocketOption(SocketOptionLevel, SocketOptionName, Object)

将指定的 Socket 选项设置为指定值,表示为对象。

Shutdown(SocketShutdown)

禁用某 Socket 上的发送和接收。

ToString()

返回表示当前对象的字符串。

(继承自 Object)

显式接口实现

IDisposable.Dispose()

此 API 支持产品基础结构,不能在代码中直接使用。

释放由 Socket 使用的所有资源。

扩展方法

AcceptAsync(Socket)

执行异步操作,接受套接字上的传入连接尝试。

AcceptAsync(Socket, Socket)

执行异步操作,接受套接字上的传入连接尝试。

ConnectAsync(Socket, EndPoint)

与远程主机建立连接。

ConnectAsync(Socket, EndPoint, CancellationToken)

与远程主机建立连接。

ConnectAsync(Socket, IPAddress, Int32)

与远程主机建立连接。 主机由 IP 地址和端口号指定。

ConnectAsync(Socket, IPAddress, Int32, CancellationToken)

建立与远程主机的连接,该连接由 IP 地址和端口号指定。

ConnectAsync(Socket, IPAddress[], Int32)

与远程主机建立连接。 主机由 IP 地址数组和端口号指定。

ConnectAsync(Socket, IPAddress[], Int32, CancellationToken)

建立与远程主机的连接,该连接由 IP 地址数组和端口号指定。

ConnectAsync(Socket, String, Int32)

与远程主机建立连接。 主机由主机名和端口号指定。

ConnectAsync(Socket, String, Int32, CancellationToken)

建立与远程主机的连接,该连接由主机名和端口号指定。

ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags)

接收连接的套接字发出的数据。

ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)

接收连接的套接字发出的数据。

ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken)

接收连接的套接字发出的数据。

ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)

接收来自指定网络设备的数据。

ReceiveMessageFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)

使用指定的 SocketFlags 将指定字节数的数据接收到指定的数据缓冲区位置,并存储终结点和数据包信息。

SendAsync(Socket, ArraySegment<Byte>, SocketFlags)

将数据发送到连接的套接字。

SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)

将数据发送到连接的套接字。

SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)

将数据发送到连接的套接字。

SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)

以异步方式将数据发送到特定远程主机。

适用于

线程安全性

在实例上 Socket 同时执行发送和接收操作是安全的,但不建议同时发出多个发送或多个接收调用。 根据基础平台实现,这可能会导致大型或多缓冲区发送或接收出现意外的数据交错。

另请参阅