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 到异步方法,使整个操作可取消。

Tip

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

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

获取或设置一个值,该值指示 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
已过时.
已过时.
已过时.

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

Ttl

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

UseOnlyOverlappedIO
已过时.

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

方法

名称 说明
Accept()

Socket为新建的连接创建新连接。

AcceptAsync()

接受传入连接。

AcceptAsync(CancellationToken)

接受传入连接。

AcceptAsync(Socket, CancellationToken)

接受传入连接。

AcceptAsync(Socket)

接受传入连接。

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)

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

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

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

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

将数据异步发送到特定的远程主机。

Bind(EndPoint)

将 a Socket 与本地终结点关联。

CancelConnectAsync(SocketAsyncEventArgs)

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

Close()

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

Close(Int32)

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

Connect(EndPoint)

建立与远程主机的连接。

Connect(IPAddress, Int32)

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

Connect(IPAddress[], Int32)

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

Connect(String, Int32)

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

ConnectAsync(EndPoint, CancellationToken)

建立与远程主机的连接。

ConnectAsync(EndPoint)

建立与远程主机的连接。

ConnectAsync(IPAddress, Int32, CancellationToken)

建立与远程主机的连接。

ConnectAsync(IPAddress, Int32)

建立与远程主机的连接。

ConnectAsync(IPAddress[], Int32, CancellationToken)

建立与远程主机的连接。

ConnectAsync(IPAddress[], Int32)

建立与远程主机的连接。

ConnectAsync(SocketAsyncEventArgs)

开始对远程主机建立连接的异步请求。

ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs, ConnectAlgorithm)

实现 Berkeley 套接字接口。

ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs)

开始对远程主机建立连接的异步请求。

ConnectAsync(String, Int32, CancellationToken)

建立与远程主机的连接。

ConnectAsync(String, Int32)

建立与远程主机的连接。

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, SocketError)

结束挂起的异步读取。

EndReceive(IAsyncResult)

结束挂起的异步读取。

EndReceiveFrom(IAsyncResult, EndPoint)

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

EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation)

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

EndSend(IAsyncResult, SocketError)

结束挂起的异步发送。

EndSend(IAsyncResult)

结束挂起的异步发送。

EndSendFile(IAsyncResult)

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

EndSendTo(IAsyncResult)

结束向特定位置发送挂起的异步发送。

Equals(Object)

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

(继承自 Object)
Finalize()

释放类使用 Socket 的资源。

GetHashCode()

返回实例的 Socket 哈希值。

GetHashCode()

用作默认哈希函数。

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

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

GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

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

GetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

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

GetSocketOption(SocketOptionLevel, SocketOptionName)

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

GetType()

获取当前实例的 Type

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

为使用数值控制代码设置低级别操作模式 Socket

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

设置使用枚举指定控制代码的SocketIOControlCode低级别操作模式。

Listen()

将某个 Socket 位置置于侦听状态。

Listen(Int32)

将某个 Socket 位置置于侦听状态。

MemberwiseClone()

创建当前 Object的浅表副本。

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

确定 . 的状态 Socket

Poll(TimeSpan, SelectMode)

确定 . 的状态 Socket

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

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

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

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

Receive(Byte[], Int32, SocketFlags)

使用指定的Socket值接收绑定SocketFlags到接收缓冲区的指定字节数。

Receive(Byte[], SocketFlags)

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

Receive(Byte[])

从绑定 Socket 接收缓冲区接收数据。

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

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

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

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

Receive(IList<ArraySegment<Byte>>)

从绑定 Socket 接收缓冲区列表中接收数据。

Receive(Span<Byte>, SocketFlags, SocketError)

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

Receive(Span<Byte>, SocketFlags)

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

Receive(Span<Byte>)

从绑定 Socket 接收缓冲区接收数据。

ReceiveAsync(ArraySegment<Byte>, SocketFlags)

从连接的套接字接收数据。

ReceiveAsync(ArraySegment<Byte>)

从连接的套接字接收数据。

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

从连接的套接字接收数据。

ReceiveAsync(IList<ArraySegment<Byte>>)

从连接的套接字接收数据。

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[], Int32, Int32, SocketFlags, SocketError)

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

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

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

Send(Byte[], Int32, SocketFlags)

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

Send(Byte[], SocketFlags)

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

Send(Byte[])

将数据发送到连接的 Socket

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

使用指定的Socket缓冲区将列表中的缓冲区集发送到连接的SocketFlags缓冲区。

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

使用指定的Socket缓冲区将列表中的缓冲区集发送到连接的SocketFlags缓冲区。

Send(IList<ArraySegment<Byte>>)

将列表中的缓冲区集发送到连接的 Socket缓冲区。

Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)

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

Send(ReadOnlySpan<Byte>, SocketFlags)

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

Send(ReadOnlySpan<Byte>)

将数据发送到连接的 Socket

SendAsync(ArraySegment<Byte>, SocketFlags)

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

SendAsync(ArraySegment<Byte>)

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

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

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

SendAsync(IList<ArraySegment<Byte>>)

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

SendAsync(ReadOnlyMemory<Byte>, CancellationToken)

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

SendAsync(ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)

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

SendAsync(SocketAsyncEventArgs)

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

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

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

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

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

SendFile(String)

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

SendFileAsync(String, CancellationToken)

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

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

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

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, Socket)

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

AcceptAsync(Socket)

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

ConnectAsync(Socket, EndPoint, CancellationToken)

建立与远程主机的连接。

ConnectAsync(Socket, EndPoint)

建立与远程主机的连接。

ConnectAsync(Socket, IPAddress, Int32, CancellationToken)

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

ConnectAsync(Socket, IPAddress, Int32)

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

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

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

ConnectAsync(Socket, IPAddress[], Int32)

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

ConnectAsync(Socket, String, Int32, CancellationToken)

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

ConnectAsync(Socket, String, Int32)

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

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

另请参阅