Socket.Receive Méthode

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);

public int Receive (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);

member this.Receive : byte[] * int * int * System.Net.Sockets.SocketFlags * SocketError -> int

Public Function Receive (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Remarques

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode est bloquée jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Une erreur s’est produite pendant la tentative d’accès au socket. Voir remarques ci-dessous. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Lorsque Available n’est pas zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible, jusqu’au nombre d’octets spécifié par le paramètre size. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(Span<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);

public int Receive (Span<byte> buffer, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);

member this.Receive : Span<byte> * System.Net.Sockets.SocketFlags * SocketError -> int

Public Function Receive (buffer As Span(Of Byte), socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Remarques

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Cette surcharge vous oblige uniquement à fournir une mémoire tampon de réception. Par défaut, le décalage de la mémoire tampon est égal à 0, la taille par défaut à la longueur du paramètre de mémoire tampon et la SocketFlags valeur par défaut est None.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode est bloquée jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Lorsque la valeur du délai d’attente est dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Lorsque Available n’est pas zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);

public int Receive (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);

member this.Receive : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags * SocketError -> int

Public Function Receive (buffers As IList(Of ArraySegment(Of Byte)), socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Remarques

Cette méthode lit les données dans le buffers paramètre et retourne le nombre d’octets correctement lus. Vous pouvez appeler à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite que vous fournissiez une ou plusieurs mémoires tampons de réception. La SocketFlags valeur par défaut est None.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de la connexion hôte distante établie dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket,Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffers paramètre, buffers est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(cli::array <System::Byte> ^ buffer, int size, System::Net::Sockets::SocketFlags socketFlags);

public int Receive (byte[] buffer, int size, System.Net.Sockets.SocketFlags socketFlags);

member this.Receive : byte[] * int * System.Net.Sockets.SocketFlags -> int

Public Function Receive (buffer As Byte(), size As Integer, socketFlags As SocketFlags) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Exemples

L’élément suivant reçoit les données trouvées dans bufferet spécifie None pour SocketFlags.

// Receive the host home page content and loop until all the data is received.
Int32 bytes = s->Receive( RecvBytes, RecvBytes->Length, SocketFlags::None );
strRetPage =  "Default HTML page on ";
strRetPage->Concat( server,  ":\r\n", ASCII->GetString( RecvBytes, 0, bytes ) );
while ( bytes > 0 )
{
   bytes = s->Receive( RecvBytes, RecvBytes->Length, SocketFlags::None );
   strRetPage->Concat( ASCII->GetString( RecvBytes, 0, bytes ) );
}

// Receive the host home page content and loop until all the data is received.
Int32 bytes = s.Receive(RecvBytes, RecvBytes.Length, 0);
strRetPage = "Default HTML page on " + server + ":\r\n";
strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, bytes);

while (bytes > 0)
{
  bytes = s.Receive(RecvBytes, RecvBytes.Length, 0);
  strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, bytes);
}

' Receive the host home page content and loop until all the data is received.

'Dim bytes As Int32 = s.Receive(RecvBytes, RecvBytes.Length, 0)
Dim bytes As Int32 = s.Receive(RecvBytes, RecvBytes.Length, 0)

strRetPage = "Default HTML page on " + server + ":\r\n"
strRetPage = "Default HTML page on " + server + ":" + ControlChars.Lf + ControlChars.NewLine

Dim i As Integer

While bytes > 0

  bytes = s.Receive(RecvBytes, RecvBytes.Length, 0)

  strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, bytes)

End While

Remarques

La Receive méthode lit les données dans le buffer paramètre et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite uniquement que vous fournissiez une mémoire tampon de réception, le nombre d’octets que vous souhaitez recevoir et le nécessaire SocketFlags.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez votre opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que possible, jusqu’au nombre d’octets spécifié par le size paramètre . Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(Span<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags);

public int Receive (Span<byte> buffer, System.Net.Sockets.SocketFlags socketFlags);

member this.Receive : Span<byte> * System.Net.Sockets.SocketFlags -> int

Public Function Receive (buffer As Span(Of Byte), socketFlags As SocketFlags) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Remarques

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite uniquement que vous fournissiez une mémoire tampon de réception. Le décalage de la mémoire tampon est égal par défaut à 0, la taille par défaut à la longueur du paramètre de mémoire tampon et la SocketFlags valeur par défaut est None.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Lorsque la valeur du délai d’attente est dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que possible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

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)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags);

public int Receive (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags);

member this.Receive : byte[] * int * int * System.Net.Sockets.SocketFlags -> int

Public Function Receive (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Exemples

L’exemple de code suivant spécifie une mémoire tampon de données, un décalage, une taille et un indicateur de socket avant de recevoir des données sur 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

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Une erreur s’est produite pendant la tentative d’accès au socket. Voir les remarques ci-dessous. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez un objet orienté Socketconnexion , la Receive méthode lit autant de données que possible, jusqu’au nombre d’octets spécifié par le paramètre size. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(cli::array <System::Byte> ^ buffer, System::Net::Sockets::SocketFlags socketFlags);

public int Receive (byte[] buffer, System.Net.Sockets.SocketFlags socketFlags);

member this.Receive : byte[] * System.Net.Sockets.SocketFlags -> int

Public Function Receive (buffer As Byte(), socketFlags As SocketFlags) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Exemples

L’exemple de code suivant spécifie une mémoire tampon de données et SocketFlags pour recevoir des données sur un connecté 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

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite uniquement que vous fournissiez une mémoire tampon de réception et le nécessaire SocketFlags. Le décalage de la mémoire tampon est égal par défaut à 0, et la taille par défaut à la longueur du paramètre d’octets.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez votre opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez une connexion sans Socketconnexion , Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(Span<System::Byte> buffer);

public int Receive (Span<byte> buffer);

member this.Receive : Span<byte> -> int

Public Function Receive (buffer As Span(Of Byte)) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Remarques

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite uniquement que vous fournissiez une mémoire tampon de réception. Le décalage de la mémoire tampon est égal par défaut à 0, la taille par défaut à la longueur du paramètre de mémoire tampon et la SocketFlags valeur par défaut est None.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Lorsque la valeur du délai d’attente est dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que possible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

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)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers);

public int Receive (System.Collections.Generic.IList<ArraySegment<byte>> buffers);

member this.Receive : System.Collections.Generic.IList<ArraySegment<byte>> -> int

Public Function Receive (buffers As IList(Of ArraySegment(Of Byte))) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Remarques

Cette méthode lit les données dans le paramètre buffers et retourne le nombre d’octets correctement lus. Vous pouvez appeler à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite que vous fournissiez une ou plusieurs mémoires tampons de réception.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de la connexion hôte distante établie dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez une connexion sans Socketconnexion , Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffers paramètre, buffers est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

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

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(cli::array <System::Byte> ^ buffer);

public int Receive (byte[] buffer);

member this.Receive : byte[] -> int

Public Function Receive (buffer As Byte()) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Exemples

L’exemple de code suivant reçoit des données sur un connecté 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

La Receive méthode lit les données dans le paramètre de mémoire tampon et retourne le nombre d’octets correctement lus. Vous pouvez appeler Receive à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite uniquement que vous fournissiez une mémoire tampon de réception. Le décalage de la mémoire tampon est égal par défaut à 0, la taille par défaut à la longueur du paramètre de mémoire tampon et la SocketFlags valeur par défaut est None.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de l’hôte distant établi dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez un sans connexion Socket, Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffer paramètre, buffer est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()

Source:

Socket.cs

Source:

Socket.cs

Source:

Socket.cs

public:
 int Receive(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers, System::Net::Sockets::SocketFlags socketFlags);

public int Receive (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags);

member this.Receive : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags -> int

Public Function Receive (buffers As IList(Of ArraySegment(Of Byte)), socketFlags As SocketFlags) As Integer

Paramètres

Retours

Nombre d’octets reçus.

Exceptions

Exemples

L’exemple de code suivant montre comment recevoir des données sur un connecté Socket.

// Build the buffers for the receive.
List<ArraySegment<Byte> >^ receiveBuffers = 
    gcnew List<ArraySegment<Byte> >(2);

array<Byte>^ bigBuffer = gcnew array<Byte>(1024);

// Specify the first buffer segment (2 bytes, starting 
// at the 4th element of bigBuffer)
receiveBuffers->Add(ArraySegment<Byte>(bigBuffer, 4, 2));

// Specify the second buffer segment (500 bytes, starting
// at the 20th element of bigBuffer)
receiveBuffers->Add(
    ArraySegment<Byte>(bigBuffer, 20, 500));

tcpSocket->Receive(receiveBuffers);

Console::WriteLine("{0}", 
    asciiEncoding->GetString(bigBuffer));

// Build the buffers for the receive.
List<ArraySegment<byte>> recvBuffers =
                         new List<ArraySegment<byte>>(2);

byte[] bigBuffer = new byte[1024];

// Specify the first buffer segment (2 bytes, starting
// at the 4th element of bigBuffer)
recvBuffers.Add(new ArraySegment<byte>(bigBuffer, 4, 2));

// Specify the second buffer segment (500 bytes, starting
// at the 20th element of bigBuffer)
recvBuffers.Add(new ArraySegment<byte>(bigBuffer, 20, 500));

int bytesReceived = mySocket.Receive(recvBuffers);

Console.WriteLine("{0}", ASCII.GetString(bigBuffer));

Remarques

Cette méthode lit les données dans le buffers paramètre et retourne le nombre d’octets correctement lus. Vous pouvez appeler à partir de sockets orientés connexion et sans connexion.

Cette surcharge nécessite que vous fournissiez une ou plusieurs mémoires tampons de réception. La SocketFlags valeur par défaut est None.

Si vous utilisez un protocole orienté connexion, vous devez appeler Connect pour établir une connexion hôte distante ou Accept pour accepter une connexion entrante avant d’appeler Receive. La Receive méthode lit uniquement les données qui arrivent de la connexion hôte distante établie dans la Connect méthode ou Accept . Si vous utilisez un protocole sans connexion, vous pouvez également utiliser la ReceiveFrom méthode . ReceiveFrom vous permet de recevoir des données provenant de n’importe quel hôte.

Si aucune donnée n’est disponible pour la lecture, la Receive méthode se bloque jusqu’à ce que les données soient disponibles, sauf si une valeur de délai d’attente a été définie à l’aide de Socket.ReceiveTimeout. Si la valeur du délai d’attente a été dépassée, l’appel Receive lève un SocketException. Si vous êtes en mode non bloquant et qu’aucune donnée n’est disponible dans la mémoire tampon de la pile de protocoles, la Receive méthode se termine immédiatement et lève un SocketException. Vous pouvez utiliser la Available propriété pour déterminer si des données sont disponibles pour la lecture. Quand Available est différent de zéro, réessayez l’opération de réception.

Si vous utilisez une méthode orientée Socketconnexion , la Receive méthode lit autant de données que disponible, jusqu’à la taille de la mémoire tampon. Si l’hôte distant arrête la Socket connexion avec la Shutdown méthode et que toutes les données disponibles ont été reçues, la Receive méthode se termine immédiatement et retourne zéro octet.

Si vous utilisez une connexion sans Socketconnexion , Receive lit le premier datagramme mis en file d’attente à partir de l’adresse de destination que vous spécifiez dans la Connect méthode . Si le datagramme que vous recevez est supérieur à la taille du buffers paramètre, buffers est rempli avec la première partie du message, les données excédentaires sont perdues et un SocketException est levée.

Voir aussi

• Connect(EndPoint)
• ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)
• Available
• Shutdown(SocketShutdown)
• Close()