Socket.Send Método

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Comentários

Send envia dados de forma síncrona para o host remoto especificado no Connect método ou Accept e retorna o número de bytes enviados com êxito. Send pode ser usado para protocolos orientados a conexão e sem conexão.

Essa sobrecarga requer um buffer que contém os dados que você deseja enviar. O SocketFlags valor assume como padrão 0, o deslocamento do buffer assume como padrão 0 e o número de bytes para enviar padrões para o tamanho do buffer.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado a conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, use o SendTo método . Se você não usar o SendTo método , precisará chamar Connect antes de cada chamada para Send. Você pode usar SendTo mesmo depois de estabelecer um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado a conexão, Send será bloqueado até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo sem bloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie os bytes no buffer. Também não há garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Comentários

Send envia dados de forma síncrona para o host remoto especificado no Connect método ou Accept e retorna o número de bytes enviados com êxito. Send pode ser usado para protocolos orientados a conexão e sem conexão.

Essa sobrecarga requer um buffer que contém os dados que você deseja enviar. O SocketFlags valor assume como padrão 0, o deslocamento do buffer assume como padrão 0 e o número de bytes para enviar padrões para o tamanho do buffer.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado a conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, use o SendTo método . Se você não usar o SendTo método , precisará chamar Connect antes de cada chamada para Send. Você pode usar SendTo mesmo depois de estabelecer um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado a conexão, Send será bloqueado até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo sem bloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie os bytes no buffer. Também não há garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Exemplos

O exemplo de código a seguir especifica o buffer de dados, um deslocamento, um tamanho e SocketFlags o envio de dados para um conectado 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);
   try
   {
      
      // 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];
    try
    {
        // 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
    Try
        ' 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

Comentários

Send envia dados de forma síncrona para o host remoto especificado no Connect método ou Accept e retorna o número de bytes enviados com êxito. Send pode ser usado para protocolos orientados a conexão e sem conexão.

Nessa sobrecarga, se você especificar o DontRoute sinalizador como o socketflags parâmetro , os dados que você está enviando não serão roteado.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar SendTo. Se você não usar SendTo, precisará chamar Connect antes de cada chamada para Send. Não há problema em usar SendTo mesmo depois de estabelecer um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Você também deve ter certeza de que o tamanho não excede o tamanho máximo do pacote do provedor de serviços subjacente. Se isso acontecer, o datagrama não será enviado e Send gerará um SocketException.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que o número solicitado de bytes seja enviado, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo de não desbloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes solicitados. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie o número solicitado de bytes. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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);

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Comentários

Essa sobrecarga requer pelo menos um buffer que contenha os dados que você deseja enviar. O SocketFlags valor usa como padrão 0. Se você especificar o DontRoute sinalizador como o socketFlags parâmetro , os dados que você está enviando não serão roteado.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar o SendTo método . Se você não usar o SendTo método , precisará chamar Connect antes de cada chamada para Send. Você pode usar SendTo mesmo depois de ter estabelecido um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo sem bloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie os bytes no buffer. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Exemplos

O exemplo de código a seguir especifica o buffer de dados, um deslocamento, um tamanho e SocketFlags o envio de dados para um conectado 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);
   try
   {
      
      // 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];
    try
    {
        // 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
    Try
        ' 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

Comentários

Send envia dados de forma síncrona para o host remoto especificado no Connect método ou Accept e retorna o número de bytes enviados com êxito. Send pode ser usado para protocolos orientados a conexão e sem conexão.

Nessa sobrecarga, se você especificar o DontRoute sinalizador como o socketflags parâmetro , os dados que você está enviando não serão roteado.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar SendTo. Se você não usar SendTo, precisará chamar Connect antes de cada chamada para Send. Não há problema em usar SendTo mesmo depois de estabelecer um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Você também deve ter certeza de que o tamanho não excede o tamanho máximo do pacote do provedor de serviços subjacente. Se isso acontecer, o datagrama não será enviado e Send gerará um SocketException.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que o número solicitado de bytes seja enviado, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo de não desbloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes solicitados. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie o número solicitado de bytes. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Exemplos

O exemplo de código a seguir envia os dados encontrados no buffer e especifica None para SocketFlags.

// 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);
   try
   {
      // 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];
    try
    {
        // 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
    Try
        ' 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

Comentários

Send envia dados de forma síncrona para o host remoto estabelecido no Connect método ou Accept e retorna o número de bytes enviados com êxito. Send pode ser usado para protocolos orientados a conexão e sem conexão.

Essa sobrecarga requer um buffer que contém os dados que você deseja enviar, o número de bytes que você deseja enviar e uma combinação bit a bit de qualquer SocketFlags. Se você especificar o DontRoute sinalizador como o socketflags parâmetro , os dados que você está enviando não serão roteado.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar o SendTo método . Se você não usar o SendTo método , precisará chamar o Connect método antes de cada chamada para o Send método . Você pode usar SendTo mesmo depois de estabelecer um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Com um protocolo orientado a conexão, Send será bloqueado até que o número solicitado de bytes seja enviado, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo de não desbloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes solicitados. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie o número solicitado de bytes. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Comentários

Send pode ser usado para protocolos orientados a conexão e sem conexão.

Essa sobrecarga requer pelo menos um buffer que contenha os dados que você deseja enviar.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar o SendTo método . Se você não usar o SendTo método , precisará chamar Connect antes de cada chamada para Send. Você pode usar SendTo mesmo depois de ter estabelecido um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo de não desbloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie os bytes no buffer. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Comentários

Essa sobrecarga requer pelo menos um buffer que contenha os dados que você deseja enviar. O SocketFlags valor usa como padrão 0. Se você especificar o DontRoute sinalizador como o socketFlags parâmetro , os dados que você está enviando não serão roteado.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar o SendTo método . Se você não usar o SendTo método , precisará chamar Connect antes de cada chamada para Send. Você pode usar SendTo mesmo depois de ter estabelecido um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo sem bloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie os bytes no buffer. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Exemplos

O exemplo de código a seguir demonstra o envio de dados em um conectado Socket.

// 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);
   try
   {
      // 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];
    try
    {
        // 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
    Try
        ' 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

Comentários

Send envia dados de forma síncrona para o host remoto estabelecido no Connect método ou Accept e retorna o número de bytes enviados com êxito. O Send método pode ser usado para protocolos orientados à conexão e sem conexão.

Essa sobrecarga requer um buffer que contém os dados que você deseja enviar e uma combinação bit a bit de SocketFlags. O deslocamento de buffer é padrão para 0 e o número de bytes para enviar padrões para o tamanho do buffer. Se você especificar o DontRoute sinalizador como o valor do socketflags parâmetro, os dados que você está enviando não serão roteado.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar o SendTo método . Se você não usar o SendTo método , precisará chamar o Connect método antes de cada chamada para Send. Você pode usar SendTo mesmo depois de ter estabelecido um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo de não desbloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie o número solicitado de bytes. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

public:
 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

Parâmetros

Retornos

O número de bytes enviados para o Socket.

Exceções

Exemplos

O exemplo de código a seguir demonstra o envio de dados em um conectado Socket.

// 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);
   try
   {
      // 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];
    try
    {
        // 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
    Try
        ' 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

Comentários

Send envia dados de forma síncrona para o host remoto especificado no Connect método ou Accept e retorna o número de bytes enviados com êxito. Send pode ser usado para protocolos orientados a conexão e sem conexão.

Essa sobrecarga requer um buffer que contém os dados que você deseja enviar. O SocketFlags valor usa como padrão 0, o deslocamento de buffer é padrão para 0 e o número de bytes para enviar padrões para o tamanho do buffer.

Se você estiver usando um protocolo sem conexão, deverá chamar Connect antes de chamar esse método ou Send gerará um SocketException. Se você estiver usando um protocolo orientado à conexão, deverá usar Connect para estabelecer uma conexão de host remoto ou usar Accept para aceitar uma conexão de entrada.

Se você estiver usando um protocolo sem conexão e planeja enviar dados para vários hosts diferentes, deverá usar o SendTo método . Se você não usar o SendTo método , precisará chamar Connect antes de cada chamada para Send. Você pode usar SendTo mesmo depois de ter estabelecido um host remoto padrão com Connect. Você também pode alterar o host remoto padrão antes de chamar Send fazendo outra chamada para Connect.

Se você estiver usando um protocolo orientado à conexão, Send bloqueará até que todos os bytes no buffer sejam enviados, a menos que um tempo limite tenha sido definido usando Socket.SendTimeout. Se o valor de tempo limite tiver sido excedido, a Send chamada gerará um SocketException. No modo de não desbloqueio, Send pode ser concluído com êxito, mesmo que ele envie menos do que o número de bytes no buffer. É responsabilidade do aplicativo controlar o número de bytes enviados e repetir a operação até que o aplicativo envie os bytes no buffer. Também não há nenhuma garantia de que os dados enviados serão exibidos na rede imediatamente. Para aumentar a eficiência da rede, o sistema subjacente pode atrasar a transmissão até que uma quantidade significativa de dados de saída seja coletada. Uma conclusão bem-sucedida do Send método significa que o sistema subjacente teve espaço para armazenar seus dados em buffer para um envio de rede.

Confira também

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)