Condividi tramite


Socket.Receive Metodo

Definizione

Riceve dati da un oggetto Socket associato.

Overload

Receive(Byte[], Int32, Int32, SocketFlags, SocketError)

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

Receive(Span<Byte>, SocketFlags, SocketError)

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

Riceve dati in un elenco di buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

Receive(Byte[], Int32, SocketFlags)

Riceve in un buffer di ricezione il numero specificato di byte di dati da un oggetto Socket associato, utilizzando l'oggetto SocketFlags specificato.

Receive(Span<Byte>, SocketFlags)

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

Receive(Byte[], Int32, Int32, SocketFlags)

Riceve il numero specificato di byte da un Socket associato nella posizione di offset predefinita del buffer di ricezione, utilizzando il SocketFlags specificato.

Receive(Byte[], SocketFlags)

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

Receive(Span<Byte>)

Riceve dati in un buffer di ricezione da un oggetto Socket associato.

Receive(IList<ArraySegment<Byte>>)

Riceve dati da un Socket associato nell'elenco dei buffer di ricezione.

Receive(Byte[])

Riceve dati in un buffer di ricezione da un oggetto Socket associato.

Receive(IList<ArraySegment<Byte>>, SocketFlags)

Riceve dati in un elenco di buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

Receive(Byte[], Int32, Int32, SocketFlags, SocketError)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

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

buffer
Byte[]

Matrice di tipo Byte che costituisce la posizione di archiviazione per i dati ricevuti.

offset
Int32

Posizione nel parametro buffer in cui archiviare i dati ricevuti.

size
Int32

Numero di byte da ricevere.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

errorCode
SocketError

Oggetto SocketError che memorizza l'errore del socket.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffer è null.

offset è minore di 0.

-oppure-

offset è maggiore della lunghezza di buffer.

-oppure-

size è minore di 0.

-oppure-

size è maggiore della lunghezza di buffer meno il valore del parametro offset .

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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 .

Nota

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

Si applica a

Receive(Span<Byte>, SocketFlags, SocketError)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

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

buffer
Span<Byte>

Intervallo di byte che costituisce la posizione di archiviazione per i dati ricevuti.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di enumerazione che specifica i comportamenti di invio e ricezione.

errorCode
SocketError

Quando termina, questo metodo contiene uno dei valori di enumerazione che definisce i codici errore per il socket.

Restituisce

Numero di byte ricevuti.

Eccezioni

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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 .

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a

Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un elenco di buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

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

buffers
IList<ArraySegment<Byte>>

Elenco di ArraySegment<T> di tipo Byte contenente i dati ricevuti.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

errorCode
SocketError

Oggetto SocketError che memorizza l'errore del socket.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffers è null.

-oppure-

buffers. Il numero totale è zero.

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

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.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a

Receive(Byte[], Int32, SocketFlags)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve in un buffer di ricezione il numero specificato di byte di dati da un oggetto Socket associato, utilizzando l'oggetto SocketFlags specificato.

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

buffer
Byte[]

Matrice di tipo Byte che costituisce la posizione di archiviazione per i dati ricevuti.

size
Int32

Numero di byte da ricevere.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffer è null.

size supera la dimensione di buffer.

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a

Receive(Span<Byte>, SocketFlags)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

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

buffer
Span<Byte>

Intervallo di byte che costituisce la posizione di archiviazione per i dati ricevuti.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di enumerazione che specifica i comportamenti di invio e ricezione.

Restituisce

Numero di byte ricevuti.

Eccezioni

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

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

Si applica a

Receive(Byte[], Int32, Int32, SocketFlags)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve il numero specificato di byte da un Socket associato nella posizione di offset predefinita del buffer di ricezione, utilizzando il SocketFlags specificato.

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

buffer
Byte[]

Matrice di tipo Byte che rappresenta la posizione di archiviazione dei dati ricevuti.

offset
Int32

Posizione in buffer per memorizzare i dati ricevuti.

size
Int32

Numero di byte da ricevere.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffer è null.

offset è minore di 0.

-oppure-

offset è maggiore della lunghezza di buffer.

-oppure-

size è minore di 0.

-oppure-

size è maggiore della lunghezza di buffer meno il valore del parametro offset.

socketFlags non è una combinazione valida di valori.

-oppure-

La proprietà LocalEndPoint non è stata impostata.

-oppure-

Si verifica un errore del sistema operativo durante l'accesso a Socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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 .

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a

Receive(Byte[], SocketFlags)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

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

buffer
Byte[]

Matrice di tipo Byte che costituisce la posizione di archiviazione per i dati ricevuti.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffer è null.

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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 .

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a

Receive(Span<Byte>)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un buffer di ricezione da un oggetto Socket associato.

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

buffer
Span<Byte>

Intervallo di byte che costituisce la posizione di archiviazione per i dati ricevuti.

Restituisce

Numero di byte ricevuti.

Eccezioni

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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 .

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

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

Si applica a

Receive(IList<ArraySegment<Byte>>)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati da un Socket associato nell'elenco dei buffer di ricezione.

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

buffers
IList<ArraySegment<Byte>>

Elenco di ArraySegment<T> di tipo Byte contenente i dati ricevuti.

Restituisce

Numero di byte ricevuti.

Eccezioni

Il valore del parametro buffer è null.

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

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

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

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.

Si applica a

Receive(Byte[])

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un buffer di ricezione da un oggetto Socket associato.

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

buffer
Byte[]

Matrice di tipo Byte che costituisce la posizione di archiviazione per i dati ricevuti.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffer è null.

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

Uno dei chiamanti nello stack di chiamate non dispone delle autorizzazioni richieste.

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 .

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a

Receive(IList<ArraySegment<Byte>>, SocketFlags)

Origine:
Socket.cs
Origine:
Socket.cs
Origine:
Socket.cs

Riceve dati in un elenco di buffer di ricezione da un Socket associato, utilizzando il SocketFlags specificato.

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

buffers
IList<ArraySegment<Byte>>

Elenco di ArraySegment<T> di tipo Byte contenente i dati ricevuti.

socketFlags
SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Numero di byte ricevuti.

Eccezioni

buffers è null.

-oppure-

buffers. Il numero totale è zero.

Si è verificato un errore durante il tentativo di accesso al socket.

L'oggetto Socket è stato chiuso.

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 .

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

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

Si applica a