Socket.Send Método

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Comentarios

Send Envía datos de forma sincrónica al host remoto especificado en el Connect método o Accept y devuelve el número de bytes enviados correctamente. Send se puede usar para protocolos orientados a la conexión y sin conexión.

Esta sobrecarga requiere un búfer que contenga los datos que desea enviar. El SocketFlags valor predeterminado es 0, el desplazamiento del búfer tiene como valor predeterminado 0 y el número de bytes para enviar valores predeterminados al tamaño del búfer.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar Connect a antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe los bytes en el búfer. Tampoco hay ninguna garantía de que los datos que envíe aparezcan en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación. Para obtener más información, vea Seguimiento de red en .NET Framework.

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Comentarios

Send Envía datos de forma sincrónica al host remoto especificado en el Connect método o Accept y devuelve el número de bytes enviados correctamente. Send se puede usar para protocolos orientados a la conexión y sin conexión.

Esta sobrecarga requiere un búfer que contenga los datos que desea enviar. El SocketFlags valor predeterminado es 0, el desplazamiento del búfer tiene como valor predeterminado 0 y el número de bytes para enviar valores predeterminados al tamaño del búfer.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar Connect a antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe los bytes en el búfer. Tampoco hay ninguna garantía de que los datos que envíe aparezcan en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación. Para obtener más información, vea Seguimiento de red en .NET Framework.

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Ejemplos

En el ejemplo de código siguiente se especifica el búfer de datos, un desplazamiento, un tamaño y SocketFlags para enviar datos a un 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

Comentarios

Send Envía datos de forma sincrónica al host remoto especificado en el Connect método o Accept y devuelve el número de bytes enviados correctamente. Send se puede usar para protocolos sin conexión y orientados a la conexión.

En esta sobrecarga, si especifica la DontRoute marca como socketflags parámetro, los datos que envía no se enrutarán.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send generará un SocketException. Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar SendTo. Si no usa SendTo, tendrá que llamar Connect antes de cada llamada a Send. Está bien usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

También debe asegurarse de que el tamaño no supera el tamaño máximo del paquete del proveedor de servicios subyacente. Si lo hace, el datagrama no se enviará y Send generará un SocketException.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíe el número solicitado de bytes, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá un SocketException. En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes que solicita. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y reintentar la operación hasta que la aplicación envíe el número solicitado de bytes. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Comentarios

Esta sobrecarga requiere al menos un búfer que contenga los datos que desea enviar. El SocketFlags valor predeterminado es 0. Si especifica la DontRoute marca como socketFlags parámetro , los datos que va a enviar no se enrutarán.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send generará un SocketException. Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar Connect a antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá un SocketException. En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y reintentar la operación hasta que la aplicación envíe los bytes en el búfer. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Ejemplos

En el ejemplo de código siguiente se especifica el búfer de datos, un desplazamiento, un tamaño y SocketFlags para enviar datos a un objeto 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

Comentarios

Send Envía datos de forma sincrónica al host remoto especificado en el Connect método o Accept y devuelve el número de bytes enviados correctamente. Send se puede usar para protocolos sin conexión y orientados a la conexión.

En esta sobrecarga, si especifica la DontRoute marca como socketflags parámetro, los datos que envía no se enrutarán.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send generará un SocketException. Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar SendTo. Si no usa SendTo, tendrá que llamar Connect antes de cada llamada a Send. Está bien usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

También debe asegurarse de que el tamaño no supera el tamaño máximo del paquete del proveedor de servicios subyacente. Si lo hace, el datagrama no se enviará y Send generará un SocketException.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíe el número solicitado de bytes, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá un SocketException. En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes que solicita. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y reintentar la operación hasta que la aplicación envíe el número solicitado de bytes. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Ejemplos

En el ejemplo de código siguiente se envían los datos encontrados en el búfer y se 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

Comentarios

Send Envía datos sincrónicamente al host remoto establecido en el Connect método o Accept y devuelve el número de bytes enviados correctamente. Send se puede usar para protocolos orientados a la conexión y sin conexión.

Esta sobrecarga requiere un búfer que contenga los datos que desea enviar, el número de bytes que desea enviar y una combinación bit a bit de cualquier SocketFlags. Si especifica la DontRoute marca como parámetro socketflags , los datos que envía no se enrutarán.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si cambia el SendTo método, tendrá que llamar al Connect método antes de cada llamada al Send método . Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Con un protocolo orientado a la conexión, Send se bloqueará hasta que se envíe el número solicitado de bytes, a menos que se haya establecido un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes que solicita. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe el número de bytes solicitado. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación. Para obtener más información, vea Seguimiento de red en .NET Framework.

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Comentarios

Send se puede usar para protocolos orientados a la conexión y sin conexión.

Esta sobrecarga requiere al menos un búfer que contenga los datos que desea enviar.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar Connect a antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe los bytes en el búfer. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Comentarios

Esta sobrecarga requiere al menos un búfer que contenga los datos que desea enviar. El SocketFlags valor predeterminado es 0. Si especifica la DontRoute marca como parámetro socketFlags , los datos que envía no se enrutarán.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar Connect a antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe los bytes en el búfer. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Ejemplos

En el ejemplo de código siguiente se muestra cómo enviar datos en un 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

Comentarios

Send Envía datos sincrónicamente al host remoto establecido en el Connect método o Accept y devuelve el número de bytes enviados correctamente. El Send método se puede usar tanto para protocolos orientados a la conexión como para los sin conexión.

Esta sobrecarga requiere un búfer que contenga los datos que desea enviar y una combinación bit a bit de SocketFlags. El desplazamiento del búfer tiene como valor predeterminado 0 y el número de bytes que se van a enviar valores predeterminados al tamaño del búfer. Si especifica la DontRoute marca como valor de socketflags parámetro, los datos que envía no se enrutarán.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar al Connect método antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe el número de bytes solicitado. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Consulte también

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

Source:

Socket.cs

Source:

Socket.cs

Source:

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

Devoluciones

Número de bytes enviados a Socket.

Excepciones

Ejemplos

En el ejemplo de código siguiente se muestra cómo enviar datos en un 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

Comentarios

Send Envía datos de forma sincrónica al host remoto especificado en el Connect método o Accept y devuelve el número de bytes enviados correctamente. Send se puede usar para protocolos orientados a la conexión y sin conexión.

Esta sobrecarga requiere un búfer que contenga los datos que desea enviar. El SocketFlags valor predeterminado es 0, el desplazamiento del búfer tiene como valor predeterminado 0 y el número de bytes para enviar valores predeterminados al tamaño del búfer.

Si usa un protocolo sin conexión, debe llamar Connect a antes de llamar a este método o Send producirá una SocketExceptionexcepción . Si usa un protocolo orientado a la conexión, debe usar Connect para establecer una conexión de host remota o usar Accept para aceptar una conexión entrante.

Si usa un protocolo sin conexión y tiene previsto enviar datos a varios hosts diferentes, debe usar el SendTo método . Si no usa el SendTo método , tendrá que llamar Connect a antes de cada llamada a Send. Puede usar SendTo incluso después de haber establecido un host remoto predeterminado con Connect. También puede cambiar el host remoto predeterminado antes de llamar Send mediante otra llamada a Connect.

Si usa un protocolo orientado a la conexión, Send se bloqueará hasta que se envíen todos los bytes del búfer, a menos que se establezca un tiempo de espera mediante Socket.SendTimeout. Si se superó el valor de tiempo de espera, la Send llamada producirá una SocketExceptionexcepción . En el modo de no bloqueo, Send puede completarse correctamente incluso si envía menos del número de bytes en el búfer. Es responsabilidad de la aplicación realizar un seguimiento del número de bytes enviados y volver a intentar la operación hasta que la aplicación envíe los bytes en el búfer. Tampoco hay ninguna garantía de que los datos que envíe aparecerán en la red inmediatamente. Para aumentar la eficiencia de la red, el sistema subyacente puede retrasar la transmisión hasta que se recopile una cantidad significativa de datos salientes. Una finalización correcta del Send método significa que el sistema subyacente ha tenido espacio para almacenar en búfer los datos de un envío de red.

Consulte también

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