Socket.Send Méthode

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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Remarques

Send envoie de manière synchrone des données à l’hôte distant spécifié dans la Connect méthode ou Accept et retourne le nombre d’octets correctement envoyés. Send peut être utilisé pour les protocoles orientés connexion et sans connexion.

Cette surcharge nécessite une mémoire tampon qui contient les données que vous souhaitez envoyer. La SocketFlags valeur par défaut est 0, le décalage de la mémoire tampon est égal par défaut à 0 et le nombre d’octets à envoyer par défaut à la taille de la mémoire tampon.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode, ou Send lève un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode , vous devez appeler Connect avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send se bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer correctement même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il est de la responsabilité de votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie les octets dans la mémoire tampon. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

Ce membre génère des informations de traçage lorsque vous activez le traçage réseau dans votre application. Pour plus d’informations, consultez Suivi réseau dans .NET Framework.

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Remarques

Send envoie de manière synchrone des données à l’hôte distant spécifié dans la Connect méthode ou Accept et retourne le nombre d’octets correctement envoyés. Send peut être utilisé pour les protocoles orientés connexion et sans connexion.

Cette surcharge nécessite une mémoire tampon qui contient les données que vous souhaitez envoyer. La SocketFlags valeur par défaut est 0, le décalage de la mémoire tampon est égal par défaut à 0 et le nombre d’octets à envoyer par défaut à la taille de la mémoire tampon.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode, ou Send lève un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode , vous devez appeler Connect avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send se bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer correctement même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il est de la responsabilité de votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie les octets dans la mémoire tampon. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

Ce membre génère des informations de traçage lorsque vous activez le traçage réseau dans votre application. Pour plus d’informations, consultez Suivi réseau dans .NET Framework.

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Exemples

L’exemple de code suivant spécifie la mémoire tampon de données, un décalage, une taille et SocketFlags pour l’envoi de données à un connecté 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

Remarques

Send envoie de manière synchrone des données à l’hôte distant spécifié dans la Connect méthode ou Accept et retourne le nombre d’octets correctement envoyés. Send peut être utilisé pour les protocoles orientés connexion et sans connexion.

Dans cette surcharge, si vous spécifiez l’indicateur DontRoute comme socketflags paramètre, les données que vous envoyez ne seront pas routées.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode ou Send lever un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser SendTo. Si vous n’utilisez SendTopas , vous devrez appeler Connect avant chaque appel à Send. Il est possible d’utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Vous devez également vous assurer que la taille ne dépasse pas la taille maximale des paquets du fournisseur de services sous-jacent. Si c’est le cas, le datagramme ne sera pas envoyé et Send lèvera un SocketException.

Si vous utilisez un protocole orienté connexion, Send se bloque jusqu’à ce que le nombre d’octets demandé soit envoyé, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer avec succès même s’il envoie moins que le nombre d’octets que vous demandez. Il incombe à votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie le nombre d’octets demandé. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Remarques

Cette surcharge nécessite au moins une mémoire tampon qui contient les données que vous souhaitez envoyer. La SocketFlags valeur par défaut est 0. Si vous spécifiez l’indicateur DontRoute comme socketFlags paramètre, les données que vous envoyez ne seront pas routées.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode, ou Send lève un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode , vous devrez appeler Connect avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send se bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode non bloquant, Send peut se terminer correctement même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il est de la responsabilité de votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie les octets dans la mémoire tampon. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Exemples

L’exemple de code suivant spécifie la mémoire tampon de données, un décalage, une taille et SocketFlags pour l’envoi de données à un connecté 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

Remarques

Send envoie de manière synchrone des données à l’hôte distant spécifié dans la Connect méthode ou Accept et retourne le nombre d’octets correctement envoyés. Send peut être utilisé pour les protocoles orientés connexion et sans connexion.

Dans cette surcharge, si vous spécifiez l’indicateur DontRoute comme socketflags paramètre, les données que vous envoyez ne seront pas routées.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode ou Send lever un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser SendTo. Si vous n’utilisez SendTopas , vous devrez appeler Connect avant chaque appel à Send. Il est possible d’utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Vous devez également vous assurer que la taille ne dépasse pas la taille maximale des paquets du fournisseur de services sous-jacent. Si c’est le cas, le datagramme ne sera pas envoyé et Send lèvera un SocketException.

Si vous utilisez un protocole orienté connexion, Send se bloque jusqu’à ce que le nombre d’octets demandé soit envoyé, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer avec succès même s’il envoie moins que le nombre d’octets que vous demandez. Il incombe à votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie le nombre d’octets demandé. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Exemples

L’exemple de code suivant envoie les données trouvées dans la mémoire tampon et spécifie None pour 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

Remarques

Send envoie de façon synchrone des données à l’hôte distant établi dans la Connect méthode ou Accept et retourne le nombre d’octets correctement envoyés. Send peut être utilisé pour les protocoles orientés connexion et sans connexion.

Cette surcharge nécessite une mémoire tampon qui contient les données que vous souhaitez envoyer, le nombre d’octets que vous souhaitez envoyer et une combinaison de bits de n’importe quel SocketFlags. Si vous spécifiez l’indicateur DontRoute comme socketflags paramètre, les données que vous envoyez ne seront pas routées.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode, ou Send lève un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode, vous devez appeler la Connect méthode avant chaque appel à la Send méthode. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Avec un protocole orienté connexion, Send se bloque jusqu’à ce que le nombre d’octets demandé soit envoyé, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer avec succès même s’il envoie moins que le nombre d’octets que vous demandez. Il incombe à votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie le nombre d’octets demandé. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

Ce membre génère des informations de traçage lorsque vous activez le traçage réseau dans votre application. Pour plus d’informations, consultez Suivi réseau dans .NET Framework.

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Remarques

Send peut être utilisé pour les protocoles orientés connexion et sans connexion.

Cette surcharge nécessite au moins une mémoire tampon qui contient les données que vous souhaitez envoyer.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode, ou Send lève un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode , vous devrez appeler Connect avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send se bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer correctement même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il est de la responsabilité de votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie les octets dans la mémoire tampon. Il n’y a pas non plus de garantie que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité importante de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de l’espace pour mettre en mémoire tampon vos données pour un envoi réseau.

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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Remarques

Cette surcharge nécessite au moins une mémoire tampon qui contient les données que vous souhaitez envoyer. La SocketFlags valeur par défaut est 0. Si vous spécifiez l’indicateur DontRoute comme socketFlags paramètre, les données que vous envoyez ne seront pas routées.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode, ou Send lève un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et que vous envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode , vous devrez appeler Connect avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode non bloquant, Send peut se terminer correctement même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il incombe à votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie les octets dans la mémoire tampon. Il n’est pas non plus garanti que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité significative de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de la place pour mettre en mémoire tampon vos données pour un envoi réseau.

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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Exemples

L’exemple de code suivant illustre l’envoi de données sur une connexion 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

Remarques

Send envoie de manière synchrone des données à l’hôte distant établi dans la Connect méthode ou Accept et retourne le nombre d’octets envoyés avec succès. La Send méthode peut être utilisée à la fois pour les protocoles orientés connexion et sans connexion.

Cette surcharge nécessite une mémoire tampon qui contient les données que vous souhaitez envoyer et une combinaison de bits de SocketFlags. Par défaut, le décalage de la mémoire tampon est égal à 0 et le nombre d’octets à envoyer par défaut à la taille de la mémoire tampon. Si vous spécifiez l’indicateur DontRoute comme valeur de socketflags paramètre, les données que vous envoyez ne seront pas routées.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode ou Send lever un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode, vous devez appeler la Connect méthode avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer correctement, même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il incombe à votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie le nombre d’octets demandé. Il n’est pas non plus garanti que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité significative de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de la place pour mettre en mémoire tampon vos données pour un envoi réseau.

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Voir aussi

• 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

Paramètres

Retours

Le nombre d’octets envoyés au Socket.

Exceptions

Exemples

L’exemple de code suivant illustre l’envoi de données sur une connexion 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

Remarques

Send envoie de manière synchrone des données à l’hôte distant spécifié dans la Connect méthode ou Accept et retourne le nombre d’octets correctement envoyés. Send peut être utilisé à la fois pour les protocoles orientés connexion et sans connexion.

Cette surcharge nécessite une mémoire tampon qui contient les données que vous souhaitez envoyer. La SocketFlags valeur par défaut est 0, le décalage de mémoire tampon par défaut est égal à 0 et le nombre d’octets à envoyer par défaut à la taille de la mémoire tampon.

Si vous utilisez un protocole sans connexion, vous devez appeler Connect avant d’appeler cette méthode ou Send lever un SocketException. Si vous utilisez un protocole orienté connexion, vous devez utiliser Connect pour établir une connexion hôte distante ou utiliser Accept pour accepter une connexion entrante.

Si vous utilisez un protocole sans connexion et envisagez d’envoyer des données à plusieurs hôtes différents, vous devez utiliser la SendTo méthode . Si vous n’utilisez pas la SendTo méthode, vous devez appeler Connect avant chaque appel à Send. Vous pouvez utiliser SendTo même après avoir établi un hôte distant par défaut avec Connect. Vous pouvez également modifier l’hôte distant par défaut avant d’appeler Send en effectuant un autre appel à Connect.

Si vous utilisez un protocole orienté connexion, Send bloque jusqu’à ce que tous les octets de la mémoire tampon soient envoyés, sauf si un délai d’attente a été défini à l’aide Socket.SendTimeoutde . Si la valeur du délai d’attente a été dépassée, l’appel Send lève un SocketException. En mode sans blocage, Send peut se terminer correctement, même s’il envoie moins que le nombre d’octets dans la mémoire tampon. Il incombe à votre application de suivre le nombre d’octets envoyés et de réessayer l’opération jusqu’à ce que l’application envoie les octets dans la mémoire tampon. Il n’est pas non plus garanti que les données que vous envoyez s’affichent immédiatement sur le réseau. Pour augmenter l’efficacité du réseau, le système sous-jacent peut retarder la transmission jusqu’à ce qu’une quantité significative de données sortantes soit collectée. Une exécution réussie de la Send méthode signifie que le système sous-jacent a eu de la place pour mettre en mémoire tampon vos données pour un envoi réseau.

Voir aussi

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