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 中的网络跟踪
                 
                 。