Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Socket.BeginReceive (Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)

 

Data di pubblicazione: ottobre 2016

Inizia a ricevere in modo asincrono i dati da un elemento connesso Socket.

Spazio dei nomi:   System.Net.Sockets
Assembly:  System (in System.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, ExternalThreading = true)]
public IAsyncResult BeginReceive(
	byte[] buffer,
	int offset,
	int size,
	SocketFlags socketFlags,
	AsyncCallback callback,
	object state
)

Parametri

buffer
Type: System.Byte[]

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

offset
Type: System.Int32

La posizione in base zero di buffer parametro in cui memorizzare i dati ricevuti.

size
Type: System.Int32

Il numero di byte da ricevere.

socketFlags
Type: System.Net.Sockets.SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

callback
Type: System.AsyncCallback

Delegato AsyncCallback cui fa riferimento il metodo da richiamare al completamento dell'operazione.

state
Type: System.Object

Oggetto definito dall'utente che contiene informazioni sull'operazione di ricezione. Questo oggetto viene passato al delegato EndReceive al completamento dell'operazione.

Valore restituito

Type: System.IAsyncResult

Un IAsyncResult che fa riferimento alla lettura asincrona.

Exception Condition
ArgumentNullException

buffer è null.

SocketException

Si è verificato un errore durante il tentativo di accesso al socket. Per altre informazioni, vedere la sezione Osservazioni.

ObjectDisposedException

Socket è stato chiuso.

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 di offset parametro.

Asincrona BeginReceive operazione deve essere completata chiamando il EndReceive metodo. In genere, il metodo viene richiamato dal callback delegare.

Questo metodo si blocca fino al completamento dell'operazione. Per bloccare fino al completamento dell'operazione, utilizzare uno del Receive overload del metodo.

Per annullare un in sospeso BeginReceive, chiamare il Close metodo.

Per informazioni dettagliate sull'utilizzo del modello di programmazione asincrono, vedere Calling Synchronous Methods Asynchronously.

System_CAPS_noteNota

Se si riceve un SocketException, utilizzare il SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo avere ottenuto il codice, fare riferimento alla versione di Windows Sockets API errore codice documentazione 2 in MSDN library per una descrizione dettagliata dell'errore.

System_CAPS_noteNota

Tutti i/o avviate da un determinato thread viene annullata all'uscita dal thread. Un'operazione asincrona in sospeso può non riuscire se il thread termina prima del completamento dell'operazione.

System_CAPS_noteNota

state rappresenta un'istanza di una classe definita dall'utente.

System_CAPS_noteNota

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

System_CAPS_noteNota

Il contesto di esecuzione (il contesto di sicurezza, l'utente rappresentato e il contesto di chiamata) viene memorizzato nella cache per asincrona Socket metodi. Dopo il primo utilizzo di un particolare contesto (un oggetto specifico asincrono Socket metodo, una specifica Socket istanza e un callback specifico), nei successivi utilizzi di tale contesto verranno visualizzato un miglioramento delle prestazioni.

Nell'esempio seguente inizia a ricevere in modo asincrono i dati da un elemento connesso Socket.

public class StateObject{
     public Socket workSocket = null;
     public const int BUFFER_SIZE = 1024;
     public byte[] buffer = new byte[BUFFER_SIZE];
     public StringBuilder sb = new StringBuilder();
}
public static void Listen_Callback(IAsyncResult ar){
     allDone.Set();
     Socket s = (Socket) ar.AsyncState;
     Socket s2 = s.EndAccept(ar);
     StateObject so2 = new StateObject();
     so2.workSocket = s2;
     s2.BeginReceive(so2.buffer, 0, StateObject.BUFFER_SIZE,0,
	                       new AsyncCallback(Async_Send_Receive.Read_Callback), so2);	
}
public static void Read_Callback(IAsyncResult ar){
	StateObject so = (StateObject) ar.AsyncState;
	Socket s = so.workSocket;

	int read = s.EndReceive(ar);

	if (read > 0) {
            so.sb.Append(Encoding.ASCII.GetString(so.buffer, 0, read));
            s.BeginReceive(so.buffer, 0, StateObject.BUFFER_SIZE, 0, 
            	                     new AsyncCallback(Async_Send_Receive.Read_Callback), so);
	}
	else{
	     if (so.sb.Length > 1) {
	          //All of the data has been read, so displays it to the console
	          string strContent;
	          strContent = so.sb.ToString();
	          Console.WriteLine(String.Format("Read {0} byte from socket" + 
	          	               "data = {1} ", strContent.Length, strContent));
	     }
	     s.Close();
	}
}

.NET Framework
Disponibile da 1.1
Torna all'inizio
Mostra: