Socket.Receive Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

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 .

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

Commenti

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 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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffers è null.

-oppure-

buffers. Il numero totale è zero.

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

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 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 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 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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

size supera la dimensione di buffer.

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

Esempio

Di seguito vengono ricevuti None i dati trovati in buffere viene specificato 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 da socket sia orientati alla connessione che da socket senza connessione.

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

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 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 al numero di byte specificato dal size parametro . 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.

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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

Commenti

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 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 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

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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

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.

SocketException

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.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

Esempio

Nell'esempio di codice seguente vengono specificati 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

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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffer è null.

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

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 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

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>)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

Commenti

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 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

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>>)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

Il valore del parametro buffer è null.

SocketException

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

ObjectDisposedException

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 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 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 Socket 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 conqueued dall'indirizzo Connect di destinazione specificato nel 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 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[])

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffer è null.

SocketException

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

ObjectDisposedException

L'oggetto Socket è stato chiuso.

SecurityException

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

Esempio

Nell'esempio di codice seguente vengono ricevuti dati in 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 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 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

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)

Source:: Socket.cs

Source:: Socket.cs

Source:: 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

Int32

Numero di byte ricevuti.

Eccezioni

ArgumentNullException

buffers è null.

-oppure-

buffers. Il numero totale è zero.

SocketException

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

ObjectDisposedException

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 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.

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