public:
int Send(ReadOnlySpan<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);
public int Send (ReadOnlySpan<byte> buffer, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);
member this.Send : ReadOnlySpan<byte> * System.Net.Sockets.SocketFlags * SocketError -> int
Public Function Send (buffer As ReadOnlySpan(Of Byte), socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer
Send
将数据同步发送到 或
Accept
方法中指定的
Connect
远程主机,并返回成功发送的字节数。
Send
可用于面向连接的协议和无连接的协议。
此重载需要包含要发送的数据的缓冲区。 该值
SocketFlags
默认为 0,缓冲区偏移量默认为 0,要发送的字节数默认为缓冲区的大小。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用
Send
之前调用
Connect
。 即使已使用
Connect
建立默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是对 进行另一次调用
Connect
。
如果使用面向连接的协议,将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超出超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数少于缓冲区中的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序在缓冲区中发送字节。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。 方法的
Send
成功完成意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,了解错误的详细说明。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
成功完成发送并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字已置于非阻止模式,否则发送将阻止。
public:
int Send(ReadOnlySpan<System::Byte> buffer);
public int Send (ReadOnlySpan<byte> buffer);
member this.Send : ReadOnlySpan<byte> -> int
Public Function Send (buffer As ReadOnlySpan(Of Byte)) As Integer
Send
将数据同步发送到 或
Accept
方法中指定的
Connect
远程主机,并返回成功发送的字节数。
Send
可用于面向连接的协议和无连接的协议。
此重载需要包含要发送的数据的缓冲区。 该值
SocketFlags
默认为 0,缓冲区偏移量默认为 0,要发送的字节数默认为缓冲区的大小。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用
Send
之前调用
Connect
。 即使已使用
Connect
建立默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是对 进行另一次调用
Connect
。
如果使用面向连接的协议,将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超出超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数少于缓冲区中的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序在缓冲区中发送字节。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。 方法的
Send
成功完成意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,了解错误的详细说明。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
成功完成发送并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字已置于非阻止模式,否则发送将阻止。
public:
int Send(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);
public int Send (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);
member this.Send : byte[] * int * int * System.Net.Sockets.SocketFlags * SocketError -> int
Public Function Send (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer
下面的代码示例指定数据缓冲区、偏移量、大小以及
SocketFlags
用于将数据发送到连接的
Socket
。
// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
int SendReceiveTest4( Socket^ server )
array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
array<Byte>^ bytes = gcnew array<Byte>(256);
// Blocks until send returns.
int byteCount = server->Send( msg, 0, msg->Length, SocketFlags::None );
Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
// Get reply from the server.
byteCount = server->Receive( bytes, 0, server->Available,
SocketFlags::None );
if ( byteCount > 0 )
Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
catch ( SocketException^ e )
Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
return (e->ErrorCode);
return 0;
// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
public static int SendReceiveTest4(Socket server)
byte[] msg = Encoding.UTF8.GetBytes("This is a test");
byte[] bytes = new byte[256];
// Blocks until send returns.
int byteCount = server.Send(msg, 0, msg.Length, SocketFlags.None);
Console.WriteLine("Sent {0} bytes.", byteCount);
// Get reply from the server.
byteCount = server.Receive(bytes, 0, bytes.Length, SocketFlags.None);
if (byteCount > 0)
Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, byteCount));
catch (SocketException e)
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
return (e.ErrorCode);
return 0;
' Displays sending with a connected socket
' using the overload that takes a buffer, offset, message size, and socket flags.
Public Shared Function SendReceiveTest4(ByVal server As Socket) As Integer
Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
Dim bytes(255) As Byte
' Blocks until send returns.
Dim byteCount As Integer = server.Send(msg, 0, msg.Length, SocketFlags.None)
Console.WriteLine("Sent {0} bytes.", byteCount)
' Get reply from the server.
byteCount = server.Receive(bytes, 0, server.Available, SocketFlags.None)
If byteCount > 0 Then
Console.WriteLine(Encoding.UTF8.GetString(bytes))
End If
Catch e As SocketException
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
Return e.ErrorCode
End Try
Return 0
End Function 'SendReceiveTest4
Send
将数据同步发送到 或
Accept
方法中指定的
Connect
远程主机,并返回成功发送的字节数。
Send
可用于面向连接的协议和无连接的协议。
在此重载中
DontRoute
,如果将 标志指定为
socketflags
参数,则不会路由要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
。 如果不使用
SendTo
,则必须在每次调用 之前调用
Connect
Send
。
SendTo
即使已使用
Connect
建立了默认远程主机,也可以使用 。 还可以在调用
Send
之前更改默认远程主机,方法是对 进行另一次调用
Connect
。
还必须确保大小不超过基础服务提供程序的最大数据包大小。 如果存在,则不会发送数据报,并且
Send
会引发
SocketException
。
如果使用面向连接的协议,将阻止,
Send
直到发送请求的字节数,除非使用
Socket.SendTimeout
设置了超时。 如果超出超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数少于请求的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序发送请求的字节数。 也不保证发送的数据会立即出现在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。 方法的
Send
成功完成意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,了解错误的详细说明。
成功完成发送并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字已置于非阻止模式,否则发送将阻止。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
public:
int Send(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);
public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);
[System.CLSCompliant(false)]
public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);
member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags * SocketError -> int
[<System.CLSCompliant(false)>]
member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags * SocketError -> int
Public Function Send (buffers As IList(Of ArraySegment(Of Byte)), socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer
此重载需要至少一个包含要发送的数据的缓冲区。 该值
SocketFlags
默认为 0。 如果将 标志指定
DontRoute
为
socketFlags
参数,则不会路由要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用 之前调用
Connect
Send
。 即使已使用
Connect
建立默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是对 进行另一次调用
Connect
。
如果使用面向连接的协议,将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超出超时值,调用
Send
将引发
SocketException
。 在非阻塞模式下,
Send
即使发送的字节数小于缓冲区中的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序在缓冲区中发送字节。 也不保证发送的数据会立即出现在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。 方法的
Send
成功完成意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,了解错误的详细说明。
成功完成发送并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字已置于非阻止模式,否则发送将阻止。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
public:
int Send(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags);
public int Send (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags);
member this.Send : byte[] * int * int * System.Net.Sockets.SocketFlags -> int
Public Function Send (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags) As Integer
下面的代码示例指定数据缓冲区、偏移量、大小以及
SocketFlags
用于将数据发送到连接的
Socket
。
// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
int SendReceiveTest4( Socket^ server )
array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
array<Byte>^ bytes = gcnew array<Byte>(256);
// Blocks until send returns.
int byteCount = server->Send( msg, 0, msg->Length, SocketFlags::None );
Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
// Get reply from the server.
byteCount = server->Receive( bytes, 0, server->Available,
SocketFlags::None );
if ( byteCount > 0 )
Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
catch ( SocketException^ e )
Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
return (e->ErrorCode);
return 0;
// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
public static int SendReceiveTest4(Socket server)
byte[] msg = Encoding.UTF8.GetBytes("This is a test");
byte[] bytes = new byte[256];
// Blocks until send returns.
int byteCount = server.Send(msg, 0, msg.Length, SocketFlags.None);
Console.WriteLine("Sent {0} bytes.", byteCount);
// Get reply from the server.
byteCount = server.Receive(bytes, 0, bytes.Length, SocketFlags.None);
if (byteCount > 0)
Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, byteCount));
catch (SocketException e)
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
return (e.ErrorCode);
return 0;
' Displays sending with a connected socket
' using the overload that takes a buffer, offset, message size, and socket flags.
Public Shared Function SendReceiveTest4(ByVal server As Socket) As Integer
Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
Dim bytes(255) As Byte
' Blocks until send returns.
Dim byteCount As Integer = server.Send(msg, 0, msg.Length, SocketFlags.None)
Console.WriteLine("Sent {0} bytes.", byteCount)
' Get reply from the server.
byteCount = server.Receive(bytes, 0, server.Available, SocketFlags.None)
If byteCount > 0 Then
Console.WriteLine(Encoding.UTF8.GetString(bytes))
End If
Catch e As SocketException
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
Return e.ErrorCode
End Try
Return 0
End Function 'SendReceiveTest4
Send
将数据同步发送到 或
Accept
方法中指定的
Connect
远程主机,并返回成功发送的字节数。
Send
可用于面向连接的协议和无连接的协议。
在此重载中
DontRoute
,如果将 标志指定为
socketflags
参数,则不会路由要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
。 如果不使用
SendTo
,则必须在每次调用 之前调用
Connect
Send
。
SendTo
即使已使用
Connect
建立了默认远程主机,也可以使用 。 还可以在调用
Send
之前更改默认远程主机,方法是对 进行另一次调用
Connect
。
还必须确保大小不超过基础服务提供程序的最大数据包大小。 如果存在,则不会发送数据报,并且
Send
会引发
SocketException
。
如果使用面向连接的协议,将阻止,
Send
直到发送请求的字节数,除非使用
Socket.SendTimeout
设置了超时。 如果超出超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数少于所请求的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序发送请求的字节数。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。
Send
成功完成方法意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,获取错误的详细说明。
发送的成功完成并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字处于非阻止模式,否则发送将阻塞。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
public:
int Send(cli::array <System::Byte> ^ buffer, int size, System::Net::Sockets::SocketFlags socketFlags);
public int Send (byte[] buffer, int size, System.Net.Sockets.SocketFlags socketFlags);
member this.Send : byte[] * int * System.Net.Sockets.SocketFlags -> int
Public Function Send (buffer As Byte(), size As Integer, socketFlags As SocketFlags) As Integer
// Displays sending with a connected socket
// using the overload that takes a buffer, message size, and socket flags.
int SendReceiveTest3( Socket^ server )
array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
array<Byte>^ bytes = gcnew array<Byte>(256);
// Blocks until send returns.
int i = server->Send( msg, msg->Length, SocketFlags::None );
Console::WriteLine( "Sent {0} bytes.", i.ToString() );
// Get reply from the server.
int byteCount = server->Receive( bytes, server->Available,
SocketFlags::None );
if ( byteCount > 0 )
Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
catch ( SocketException^ e )
Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
return (e->ErrorCode);
return 0;
// Displays sending with a connected socket
// using the overload that takes a buffer, message size, and socket flags.
public static int SendReceiveTest3(Socket server)
byte[] msg = Encoding.UTF8.GetBytes("This is a test");
byte[] bytes = new byte[256];
// Blocks until send returns.
int i = server.Send(msg, msg.Length, SocketFlags.None);
Console.WriteLine("Sent {0} bytes.", i);
// Get reply from the server.
int byteCount = server.Receive(bytes, bytes.Length, SocketFlags.None);
if (byteCount > 0)
Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, byteCount));
catch (SocketException e)
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
return (e.ErrorCode);
return 0;
' Displays sending with a connected socket
' using the overload that takes a buffer, message size, and socket flags.
Public Shared Function SendReceiveTest3(ByVal server As Socket) As Integer
Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
Dim bytes(255) As Byte
' Blocks until send returns.
Dim i As Integer = server.Send(msg, msg.Length, SocketFlags.None)
Console.WriteLine("Sent {0} bytes.", i)
' Get reply from the server.
Dim byteCount As Integer = server.Receive(bytes, server.Available, SocketFlags.None)
If byteCount > 0 Then
Console.WriteLine(Encoding.UTF8.GetString(bytes))
End If
Catch e As SocketException
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
Return e.ErrorCode
End Try
Return 0
End Function 'SendReceiveTest3
Send
将数据同步发送到在 或
Accept
方法中
Connect
建立的远程主机,并返回成功发送的字节数。
Send
可用于面向连接的协议和无连接的协议。
此重载需要一个缓冲区,其中包含要发送的数据、要发送的字节数以及任何
SocketFlags
的按位组合。 如果将 标志指定
DontRoute
为
socketflags
参数,则不会路由要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用
Connect
方法之前调用
Send
方法。 即使已使用
Connect
建立了默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前通过对 进行另一次调用
Connect
来更改默认远程主机。
对于面向连接的协议,
Send
将阻止,直到发送请求的字节数,除非使用
Socket.SendTimeout
设置了超时。 如果超过超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数少于所请求的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序发送请求的字节数。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。
Send
成功完成方法意味着基础系统有空间来缓冲网络发送的数据。
必须确保大小不超过基础服务提供程序的最大数据包大小。 如果存在,则不会发送数据报,并将
Send
引发
SocketException
。 如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,获取错误的详细说明。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
发送的成功完成并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字处于非阻止模式,否则发送将阻塞。
public:
int Send(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers);
public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers);
member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> -> int
Public Function Send (buffers As IList(Of ArraySegment(Of Byte))) As Integer
Send
可用于面向连接的协议和无连接的协议。
此重载至少需要一个缓冲区,其中包含要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用 之前调用
Connect
Send
。 即使已使用
Connect
建立了默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是再次调用
Connect
。
如果使用面向连接的协议, 将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超过超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数小于缓冲区中的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序在缓冲区中发送字节。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。
Send
成功完成方法意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,获取错误的详细说明。
发送的成功完成并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字处于非阻止模式,否则发送将阻塞。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
public:
int Send(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers, System::Net::Sockets::SocketFlags socketFlags);
public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags);
member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags -> int
Public Function Send (buffers As IList(Of ArraySegment(Of Byte)), socketFlags As SocketFlags) As Integer
此重载至少需要一个缓冲区,其中包含要发送的数据。 该值
SocketFlags
默认为 0。 如果将 标志指定
DontRoute
为
socketFlags
参数,则不会路由要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用 之前调用
Connect
Send
。 即使已使用
Connect
建立了默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是再次调用
Connect
。
如果使用面向连接的协议, 将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超过超时值,调用
Send
将引发
SocketException
。 在非阻塞模式下,即使发送的字节数小于缓冲区中的字节数,
Send
也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序在缓冲区中发送字节。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。
Send
成功完成方法意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,获取错误的详细说明。
发送的成功完成并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字处于非阻止模式,否则发送将阻塞。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
public:
int Send(cli::array <System::Byte> ^ buffer, System::Net::Sockets::SocketFlags socketFlags);
public int Send (byte[] buffer, System.Net.Sockets.SocketFlags socketFlags);
member this.Send : byte[] * System.Net.Sockets.SocketFlags -> int
Public Function Send (buffer As Byte(), socketFlags As SocketFlags) As Integer
// Displays sending with a connected socket
// using the overload that takes a buffer and socket flags.
int SendReceiveTest2( Socket^ server )
array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
array<Byte>^ bytes = gcnew array<Byte>(256);
// Blocks until send returns.
int byteCount = server->Send( msg, SocketFlags::None );
Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
// Get reply from the server.
byteCount = server->Receive( bytes, SocketFlags::None );
if ( byteCount > 0 )
Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
catch ( SocketException^ e )
Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
return (e->ErrorCode);
return 0;
// Displays sending with a connected socket
// using the overload that takes a buffer and socket flags.
public static int SendReceiveTest2(Socket server)
byte[] msg = Encoding.UTF8.GetBytes("This is a test");
byte[] bytes = new byte[256];
// Blocks until send returns.
int byteCount = server.Send(msg, SocketFlags.None);
Console.WriteLine("Sent {0} bytes.", byteCount);
// Get reply from the server.
byteCount = server.Receive(bytes, SocketFlags.None);
if (byteCount > 0)
Console.WriteLine(Encoding.UTF8.GetString(bytes));
catch (SocketException e)
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
return (e.ErrorCode);
return 0;
' Displays sending with a connected socket
' using the overload that takes a buffer and socket flags.
Public Shared Function SendReceiveTest2(ByVal server As Socket) As Integer
Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
Dim bytes(255) As Byte
' Blocks until send returns.
Dim byteCount As Integer = server.Send(msg, SocketFlags.None)
Console.WriteLine("Sent {0} bytes.", byteCount)
' Get reply from the server.
byteCount = server.Receive(bytes, SocketFlags.None)
If byteCount > 0 Then
Console.WriteLine(Encoding.UTF8.GetString(bytes))
End If
Catch e As SocketException
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
Return e.ErrorCode
End Try
Return 0
End Function 'SendReceiveTest2
Send
将数据同步发送到在 或
Accept
方法中
Connect
建立的远程主机,并返回成功发送的字节数。 方法
Send
可用于面向连接的协议和无连接协议。
此重载需要一个缓冲区,其中包含要发送的数据以及 的
SocketFlags
按位组合。 缓冲区偏移量默认为 0,要发送的字节数默认为缓冲区的大小。 如果将标志指定
DontRoute
为
socketflags
参数值,则不会路由要发送的数据。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用
Connect
之前调用
Send
方法。 即使已使用
Connect
建立了默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是再次调用
Connect
。
如果使用面向连接的协议, 将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超过超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数小于缓冲区中的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序发送请求的字节数。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。
Send
成功完成方法意味着基础系统有空间来缓冲网络发送的数据。
必须确保缓冲区的大小不超过基础服务提供程序的最大数据包大小。 如果已发送,则不会发送数据报,并将
Send
引发
SocketException
。 如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,获取错误的详细说明。
发送的成功完成并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字处于非阻止模式,否则发送将阻塞。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。
public:
int Send(ReadOnlySpan<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags);
public int Send (ReadOnlySpan<byte> buffer, System.Net.Sockets.SocketFlags socketFlags);
member this.Send : ReadOnlySpan<byte> * System.Net.Sockets.SocketFlags -> int
Public Function Send (buffer As ReadOnlySpan(Of Byte), socketFlags As SocketFlags) As Integer
int Send(cli::array <System::Byte> ^ buffer);
public int Send (byte[] buffer);
member this.Send : byte[] -> int
Public Function Send (buffer As Byte()) As Integer
// Displays sending with a connected socket
// using the overload that takes a buffer.
int SendReceiveTest1( Socket^ server )
array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
array<Byte>^ bytes = gcnew array<Byte>(256);
// Blocks until send returns.
int byteCount = server->Send( msg );
Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
// Get reply from the server.
byteCount = server->Receive( bytes );
if ( byteCount > 0 )
Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
catch ( SocketException^ e )
Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
return ( e->ErrorCode );
return 0;
// Displays sending with a connected socket
// using the overload that takes a buffer.
public static int SendReceiveTest1(Socket server)
byte[] msg = Encoding.UTF8.GetBytes("This is a test");
byte[] bytes = new byte[256];
// Blocks until send returns.
int i = server.Send(msg);
Console.WriteLine("Sent {0} bytes.", i);
// Get reply from the server.
i = server.Receive(bytes);
Console.WriteLine(Encoding.UTF8.GetString(bytes));
catch (SocketException e)
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
return (e.ErrorCode);
return 0;
' Displays sending with a connected socket
' using the overload that takes a buffer.
Public Shared Function SendReceiveTest1(ByVal server As Socket) As Integer
Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
Dim bytes(255) As Byte
' Blocks until send returns.
Dim i As Integer = server.Send(msg)
Console.WriteLine("Sent {0} bytes.", i)
' Get reply from the server.
i = server.Receive(bytes)
Console.WriteLine(Encoding.UTF8.GetString(bytes))
Catch e As SocketException
Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
Return e.ErrorCode
End Try
Return 0
End Function 'SendReceiveTest1
Send
将数据同步发送到 或
Accept
方法中指定的
Connect
远程主机,并返回成功发送的字节数。
Send
可用于面向连接的协议和无连接的协议。
此重载需要包含要发送的数据的缓冲区。 值
SocketFlags
默认值为 0,缓冲区偏移量默认为 0,要发送的字节数默认为缓冲区的大小。
如果使用无连接协议,则必须在调用此方法之前调用
Connect
,否则
Send
将引发
SocketException
。 如果使用面向连接的协议,则必须使用
Connect
建立远程主机连接,或使用
Accept
接受传入连接。
如果使用无连接协议并计划将数据发送到多个不同的主机,则应使用
SendTo
方法。 如果不使用
SendTo
方法,则必须在每次调用 之前调用
Connect
Send
。 即使已使用
Connect
建立了默认远程主机,也可以使用
SendTo
。 还可以在调用
Send
之前更改默认远程主机,方法是再次调用
Connect
。
如果使用面向连接的协议, 将阻止,
Send
直到发送缓冲区中的所有字节,除非使用
Socket.SendTimeout
设置了超时。 如果超过超时值,调用
Send
将引发
SocketException
。 在非阻止模式下,
Send
即使发送的字节数小于缓冲区中的字节数,也可能成功完成。 应用程序负责跟踪发送的字节数,并重试操作,直到应用程序在缓冲区中发送字节。 也不保证发送的数据会立即显示在网络上。 为了提高网络效率,基础系统可能会延迟传输,直到收集大量传出数据。
Send
成功完成方法意味着基础系统有空间来缓冲网络发送的数据。
如果收到 ,
SocketException
请使用
SocketException.ErrorCode
属性获取特定的错误代码。 获取此代码后,请参阅
Windows 套接字版本 2 API 错误代码
文档,获取错误的详细说明。
发送的成功完成并不表示数据已成功传递。 如果传输系统中没有可用于保存要传输的数据的缓冲区空间,除非套接字处于非阻止模式,否则发送将阻塞。
当你在应用程序中启用网络跟踪后,此成员将输出跟踪信息。 有关详细信息,请参阅
.NET Framework 中的网络跟踪
。