Socket.Receive Metodo

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Commenti

Il Receive metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive da socket sia orientati alla connessione che da socket senza connessione.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genererà un oggetto SocketException. Se si è in modalità non di blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e verrà generato un'eccezione SocketException. Si è verificato un errore durante il tentativo di accesso al socket. Vedere le osservazioni riportate di seguito. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino al numero di byte specificato dal parametro size. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza connessione Socket, Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffer parametro, buffer viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Commenti

Il Receive metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive da socket sia orientati alla connessione che da socket senza connessione.

Questo overload richiede solo di fornire un buffer di ricezione. Per impostazione predefinita, l'offset del buffer è 0, la dimensione predefinita è la lunghezza del parametro del buffer e il SocketFlags valore predefinito è None.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Quando viene superato il valore di timeout, la Receive chiamata genererà un oggetto SocketException. Se si usa la modalità di non blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e genera un'eccezione SocketException. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza Socketconnessione, Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffer parametro, buffer viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Commenti

Questo metodo legge i dati nel buffers parametro e restituisce il numero di byte letti correttamente. È possibile chiamare sia da socket con connessione che senza connessione.

Questo overload richiede di fornire uno o più buffer di ricezione. Il SocketFlags valore predefinito è None.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dalla connessione host remota stabilita nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo blocca fino a quando i dati non sono disponibili, a meno che non sia stato impostato un valore di timeout usando Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genera un SocketExceptionoggetto . Se si è in modalità non blocca e non sono disponibili dati nel buffer dello stack di protocolli, il Receive metodo verrà completato immediatamente e generato un SocketExceptionoggetto . È possibile usare la proprietà per determinare se i Available dati sono disponibili per la lettura. Quando Available è diverso da zero, riprovare l'operazione di ricezione.

Se si usa una connessione orientata Socketalla connessione, il Receive metodo leggerà il numero di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la connessione con il SocketShutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza Socketconnessione,Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagram ricevuto è maggiore della dimensione del parametro, viene riempito con la prima parte del buffers messaggio, buffers i dati in eccesso vengono persi e viene generato un SocketException oggetto.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

Di seguito vengono ricevuti None i dati trovati in buffere specifica per 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

Commenti

Il Receive metodo legge i dati nel buffer parametro e restituisce il numero di byte letti correttamente. È possibile chiamare Receive sia da socket con connessione che senza connessione.

Questo overload richiede solo di fornire un buffer di ricezione, il numero di byte che si desidera ricevere e il necessario SocketFlags.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo blocca fino a quando i dati non sono disponibili, a meno che non sia stato impostato un valore di timeout usando Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genererà un SocketExceptionoggetto . Se si è in modalità non blocca e non sono disponibili dati nel buffer dello stack di protocolli, il Receive metodo verrà completato immediatamente e genera un SocketExceptionoggetto . È possibile usare la proprietà per determinare se i Available dati sono disponibili per la lettura. Quando Available non è zero, riprovare l'operazione di ricezione.

Se si usa una connessione orientata Socketalla connessione, il Receive metodo leggerà il numero massimo di dati disponibili, fino al numero di byte specificati dal size parametro. Se l'host remoto arresta la connessione con il SocketShutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza Socketconnessione, Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagram ricevuto è maggiore della dimensione del parametro, viene riempito con la prima parte del buffer messaggio, buffer i dati in eccesso vengono persi e viene generato un SocketException oggetto.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Commenti

Il Receive metodo legge i dati nel parametro del buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive sia da socket con connessione che senza connessione.

Questo overload richiede solo di fornire un buffer di ricezione. L'offset del buffer è predefinito su 0, le dimensioni predefinite sono la lunghezza del parametro del buffer e il SocketFlags valore predefinito è None.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo blocca fino a quando i dati non sono disponibili, a meno che non sia stato impostato un valore di timeout usando Socket.ReceiveTimeout. Quando il valore di timeout viene superato, la Receive chiamata genererà un SocketExceptionoggetto . Se si è in modalità non blocca e non sono disponibili dati nel buffer dello stack di protocolli, il Receive metodo verrà completato immediatamente e generato un SocketExceptionoggetto . È possibile usare la proprietà per determinare se i Available dati sono disponibili per la lettura. Quando Available è diverso da zero, riprovare l'operazione di ricezione.

Se si usa una connessione orientata Socketa una connessione, il Receive metodo leggerà il numero di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la connessione con il SocketShutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza Socketconnessione, Receive leggerà il primo datagramma in coda dall'indirizzo Connect di destinazione specificato nel metodo . Se il datagram ricevuto è maggiore della dimensione del parametro, viene riempito con la prima parte del buffer messaggio, buffer i dati in eccesso vengono persi e viene generato un SocketException oggetto.

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

Nell'esempio di codice seguente viene specificato un buffer di dati, un offset, una dimensione e un flag socket prima di ricevere dati in un oggetto connesso 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

Commenti

Il Receive metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive da socket sia orientati alla connessione che da socket senza connessione.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genererà un oggetto SocketException. Se si è in modalità non di blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e verrà generato un'eccezione SocketException. Si è verificato un errore durante il tentativo di accesso al socket. Vedere le osservazioni riportate di seguito. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino al numero di byte specificato dal parametro size. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza connessione Socket, Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffer parametro, buffer viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

Nell'esempio di codice seguente viene specificato un buffer di dati e SocketFlags per la ricezione di dati in un oggetto connesso 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

Commenti

Il Receive metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive da socket sia orientati alla connessione che da socket senza connessione.

Questo overload richiede solo di fornire un buffer di ricezione e l'oggetto necessario SocketFlags. Per impostazione predefinita, l'offset del buffer è 0 e per impostazione predefinita la lunghezza del parametro di byte.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili. Se si è in modalità non di blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e verrà generato un'eccezione SocketException. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile fino alle dimensioni del buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza connessione Socket, Receive leggerà il primo datagramma accodato dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffer parametro, buffer viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Commenti

Il Receive metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive da socket sia orientati alla connessione che da socket senza connessione.

Questo overload richiede solo di fornire un buffer di ricezione. Per impostazione predefinita, l'offset del buffer è 0, la dimensione predefinita è la lunghezza del parametro del buffer e il SocketFlags valore predefinito è None.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Quando viene superato il valore di timeout, la Receive chiamata genererà un oggetto SocketException. Se si usa la modalità di non blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e genera un'eccezione SocketException. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza Socketconnessione, Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore delle dimensioni del buffer parametro, buffer viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Commenti

Questo metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare da socket sia orientati alla connessione che da socket senza connessione.

Questo overload richiede di fornire uno o più buffer di ricezione.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dalla connessione host remota stabilita nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genererà un oggetto SocketException. Se si è in modalità non di blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e verrà generato un'eccezione SocketException. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza connessione Socket, Receive leggerà il primo datagramma accodato dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffers parametro, buffers viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Nota Questo membro restituisce informazioni di traccia quando si abilita la traccia di rete nell'applicazione. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

Nell'esempio di codice seguente vengono ricevuti dati su un oggetto connesso 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

Commenti

Il Receive metodo legge i dati nel parametro buffer e restituisce il numero di byte letti correttamente. È possibile chiamare Receive da socket sia orientati alla connessione che da socket senza connessione.

Questo overload richiede solo di fornire un buffer di ricezione. Per impostazione predefinita, l'offset del buffer è 0, la dimensione predefinita è la lunghezza del parametro del buffer e il SocketFlags valore predefinito è None.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dall'host remoto stabilito nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genererà un oggetto SocketException. Se si è in modalità non di blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e verrà generato un'eccezione SocketException. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza connessione Socket, Receive leggerà il primo datagramma in coda dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffer parametro, buffer viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

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

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

Nell'esempio di codice seguente viene illustrato come ricevere dati in un oggetto connesso 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));

Commenti

Questo metodo legge i dati nel buffers parametro e restituisce il numero di byte letti correttamente. È possibile chiamare da socket sia orientati alla connessione che da socket senza connessione.

Questo overload richiede di fornire uno o più buffer di ricezione. Il SocketFlags valore predefinito è None.

Se si usa un protocollo orientato alla connessione, è necessario chiamare Connect per stabilire una connessione host remota o Accept per accettare una connessione in ingresso prima di chiamare Receive. Il Receive metodo leggerà solo i dati che arrivano dalla connessione host remota stabilita nel Connect metodo o Accept . Se si usa un protocollo senza connessione, è anche possibile usare il ReceiveFrom metodo . ReceiveFrom consentirà di ricevere i dati provenienti da qualsiasi host.

Se non sono disponibili dati per la lettura, il Receive metodo bloccherà fino a quando i dati non saranno disponibili, a meno che non sia stato impostato un valore di timeout tramite Socket.ReceiveTimeout. Se il valore di timeout è stato superato, la Receive chiamata genera un'eccezione SocketException. Se si è in modalità non di blocco e non sono disponibili dati nel buffer dello stack di protocollo, il Receive metodo verrà completato immediatamente e verrà generato un'eccezione SocketException. È possibile utilizzare la Available proprietà per determinare se i dati sono disponibili per la lettura. Quando Available è diverso da zero, ripetere l'operazione di ricezione.

Se si usa un oggetto orientato Socketalla connessione, il Receive metodo leggerà la quantità di dati disponibile, fino alle dimensioni del buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il Receive metodo verrà completato immediatamente e restituirà zero byte.

Se si usa un oggetto senza connessione Socket, Receive leggerà il primo datagramma accodato dall'indirizzo di destinazione specificato nel Connect metodo . Se il datagramma ricevuto è maggiore della dimensione del buffers parametro, buffers viene riempito con la prima parte del messaggio, i dati in eccesso vengono persi e viene generata un'eccezione SocketException .

Vedi anche

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