Socket.ReceiveFrom Metodo

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

Socket.cs

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

public int ReceiveFrom (byte[] buffer, int size, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP);

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

Public Function ReceiveFrom (buffer As Byte(), size As Integer, socketFlags As SocketFlags, ByRef remoteEP As EndPoint) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

L'esempio di codice seguente riceve un datagramma senza connessione da un host remoto. Le dimensioni del buffer e SocketFlags vengono passate al ReceiveFrom metodo .

static void ReceiveFrom3()
{
   IPHostEntry^ hostEntry = Dns::Resolve( Dns::GetHostName() );
   IPEndPoint^ endPoint = gcnew IPEndPoint( hostEntry->AddressList[ 0 ],11000 );

   Socket^ s = gcnew Socket( endPoint->Address->AddressFamily,
      SocketType::Dgram,
      ProtocolType::Udp );
   
   // Creates an IPEndPoint to capture the identity of the sending host.
   IPEndPoint^ sender = gcnew IPEndPoint( IPAddress::Any,0 );
   EndPoint^ senderRemote = safe_cast<EndPoint^>(sender);
   
   // Binding is required with ReceiveFrom calls.
   s->Bind( endPoint );

   array<Byte>^ msg = gcnew array<Byte>(256);
   Console::WriteLine(  "SWaiting to receive datagrams from client..." );
   // This call blocks. 
   s->ReceiveFrom( msg, msg->Length, SocketFlags::None, senderRemote );
   s->Close();
}

public static void ReceiveFrom3()
{
    IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
    IPEndPoint endPoint = new IPEndPoint(hostEntry.AddressList[0], 11000);

    Socket s = new Socket(endPoint.Address.AddressFamily,
        SocketType.Dgram,
        ProtocolType.Udp);

    // Creates an IPEndPoint to capture the identity of the sending host.
    IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
    EndPoint senderRemote = (EndPoint)sender;

    // Binding is required with ReceiveFrom calls.
    s.Bind(endPoint);

    byte[] msg = new Byte[256];
    Console.WriteLine("Waiting to receive datagrams from client...");
    // This call blocks.
    s.ReceiveFrom(msg, msg.Length, SocketFlags.None, ref senderRemote);
    s.Close();
}

Public Shared Sub ReceiveFrom3() 
    Dim hostEntry As IPHostEntry = Dns.GetHostEntry(Dns.GetHostName())
    Dim endPoint As New IPEndPoint(hostEntry.AddressList(0), 11000)
    
    Dim s As New Socket(endPoint.Address.AddressFamily, SocketType.Dgram, ProtocolType.Udp)
    
    ' Creates an IPEndPoint to capture the identity of the sending host.
    Dim sender As New IPEndPoint(IPAddress.Any, 0)
    Dim senderRemote As EndPoint = CType(sender, EndPoint)
    
    ' Binding is required with ReceiveFrom calls.
    s.Bind(endPoint)
    
    Dim msg() As Byte = New [Byte](255) {}
    Console.WriteLine("Waiting to receive datagrams from client...")
    ' This call blocks. 
    s.ReceiveFrom(msg, msg.Length, SocketFlags.None, senderRemote)
    s.Close()

End Sub

Commenti

Il ReceiveFrom metodo legge i dati nel buffer parametro , restituisce il numero di byte letti correttamente e acquisisce l'endpoint host remoto da cui sono stati inviati i dati. Questo metodo è utile se si intende ricevere datagrammi senza connessione da un host sconosciuto o da più host.

Questo overload richiede solo di fornire un buffer di ricezione, il numero di byte che si desidera ricevere, l'oggetto necessario SocketFlagse un oggetto EndPoint che rappresenta l'host remoto. Per impostazione predefinita, l'offset del buffer è 0.

Con i protocolli senza connessione, ReceiveFrom leggerà il primo datagramma accodato ricevuto nel buffer di rete locale. Se il datagramma ricevuto è maggiore delle dimensioni di buffer, il ReceiveFrom metodo riempirà buffer la maggior parte del messaggio possibile e genererà un'eccezione SocketException. Se si usa un protocollo inaffidabile, i dati in eccesso andranno persi. Se si usa un protocollo affidabile, i dati in eccesso verranno conservati dal provider di servizi e sarà possibile recuperarlo chiamando il ReceiveFrom metodo con un buffer sufficientemente grande.

Se non sono disponibili dati per la lettura, il ReceiveFrom 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 ReceiveFrom 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.

Anche se ReceiveFrom è destinato ai protocolli senza connessione, è possibile usare anche un protocollo orientato alla connessione. Se si sceglie di eseguire questa operazione, è innanzitutto necessario stabilire una connessione host remota chiamando il Connect metodo o accettando una connessione host remota in ingresso chiamando il Accept metodo . Se non si stabilisce o si accetta una connessione prima di chiamare il ReceiveFrom metodo , si otterrà un oggetto SocketException. È anche possibile stabilire un host remoto predefinito per un protocollo senza connessione prima di chiamare il ReceiveFrom metodo .

Con i socket orientati alla connessione, ReceiveFrom 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 ReceiveFrom metodo verrà completato immediatamente e restituirà zero byte.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

Socket.cs

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

public int ReceiveFrom (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP);

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

Public Function ReceiveFrom (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags, ByRef remoteEP As EndPoint) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

L'esempio di codice seguente riceve un datagramma senza connessione da un host remoto. Offset, dimensioni del buffer e SocketFlags vengono passati al ReceiveFrom metodo .

static void ReceiveFrom4()
{
   IPHostEntry^ hostEntry = Dns::Resolve( Dns::GetHostName() );
   IPEndPoint^ endPoint = gcnew IPEndPoint( hostEntry->AddressList[ 0 ],11000 );

   Socket^ s = gcnew Socket( endPoint->Address->AddressFamily,
      SocketType::Dgram,
      ProtocolType::Udp );
   
   // Creates an IpEndPoint to capture the identity of the sending host.
   IPEndPoint^ sender = gcnew IPEndPoint( IPAddress::Any,0 );
   EndPoint^ senderRemote = safe_cast<EndPoint^>(sender);
   
   // Binding is required with ReceiveFrom calls.
   s->Bind( endPoint );

   array<Byte>^ msg = gcnew array<Byte>(256);
   Console::WriteLine(  "SWaiting to receive datagrams from client..." );
   // This call blocks.  
   s->ReceiveFrom( msg, 0, msg->Length, SocketFlags::None, senderRemote );
   s->Close();
}

public static void ReceiveFrom4()
{
    IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
    IPEndPoint endPoint = new IPEndPoint(hostEntry.AddressList[0], 11000);

    Socket s = new Socket(endPoint.Address.AddressFamily,
        SocketType.Dgram,
        ProtocolType.Udp);

    // Creates an IpEndPoint to capture the identity of the sending host.
    IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
    EndPoint senderRemote = (EndPoint)sender;

    // Binding is required with ReceiveFrom calls.
    s.Bind(endPoint);
    byte[] msg = new Byte[256];
    Console.WriteLine("Waiting to receive datagrams from client...");
    // This call blocks.
    s.ReceiveFrom(msg, 0, msg.Length, SocketFlags.None, ref senderRemote);
    s.Close();
}

Public Shared Sub ReceiveFrom4() 
    Dim hostEntry As IPHostEntry = Dns.GetHostEntry(Dns.GetHostName())
    Dim endPoint As New IPEndPoint(hostEntry.AddressList(0), 11000)
    
    Dim s As New Socket(endPoint.Address.AddressFamily, SocketType.Dgram, ProtocolType.Udp)
    
    ' Creates an IpEndPoint to capture the identity of the sending host.
    Dim sender As New IPEndPoint(IPAddress.Any, 0)
    Dim senderRemote As EndPoint = CType(sender, EndPoint)
    
    ' Binding is required with ReceiveFrom calls.
    s.Bind(endPoint)
    Dim msg() As Byte = New [Byte](255) {}
    Console.WriteLine("Waiting to receive datagrams from client...")
    ' This call blocks.  
    s.ReceiveFrom(msg, 0, msg.Length, SocketFlags.None, senderRemote)
    s.Close()

End Sub

Commenti

Il ReceiveFrom metodo legge i dati nel buffer parametro , restituisce il numero di byte letti correttamente e acquisisce l'endpoint host remoto da cui sono stati inviati i dati. Questo metodo è utile se si intende ricevere datagrammi senza connessione da un host sconosciuto o da più host.

Con i protocolli senza connessione, ReceiveFrom leggerà il primo datagramma accodato ricevuto nel buffer di rete locale. Se il datagramma ricevuto è maggiore delle dimensioni di buffer, il ReceiveFrom metodo riempirà buffer la maggior parte del messaggio possibile e genererà un'eccezione SocketException. Se si usa un protocollo inaffidabile, i dati in eccesso andranno persi. Se si usa un protocollo affidabile, i dati in eccesso verranno conservati dal provider di servizi e sarà possibile recuperarlo chiamando il ReceiveFrom metodo con un buffer sufficientemente grande.

Se non sono disponibili dati per la lettura, il ReceiveFrom 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 ReceiveFrom 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.

Anche se ReceiveFrom è destinato ai protocolli senza connessione, è possibile usare anche un protocollo orientato alla connessione. Se si sceglie di eseguire questa operazione, è innanzitutto necessario stabilire una connessione host remota chiamando il Connect metodo o accettando una connessione host remota in ingresso chiamando il Accept metodo . Se non si stabilisce o si accetta una connessione prima di chiamare il ReceiveFrom metodo , si otterrà un oggetto SocketException. È anche possibile stabilire un host remoto predefinito per un protocollo senza connessione prima di chiamare il ReceiveFrom metodo .

Con i socket orientati alla connessione, ReceiveFrom leggerà la quantità di dati disponibile fino alla quantità di byte specificata dal size parametro . Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il ReceiveFrom metodo verrà completato immediatamente e restituirà zero byte.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

Socket.cs

public:
 int ReceiveFrom(Span<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags, System::Net::EndPoint ^ % remoteEP);

public int ReceiveFrom (Span<byte> buffer, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP);

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

Public Function ReceiveFrom (buffer As Span(Of Byte), socketFlags As SocketFlags, ByRef remoteEP As EndPoint) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

Socket.cs

public:
 int ReceiveFrom(cli::array <System::Byte> ^ buffer, System::Net::Sockets::SocketFlags socketFlags, System::Net::EndPoint ^ % remoteEP);

public int ReceiveFrom (byte[] buffer, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP);

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

Public Function ReceiveFrom (buffer As Byte(), socketFlags As SocketFlags, ByRef remoteEP As EndPoint) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

L'esempio di codice seguente riceve un datagramma senza connessione da un host remoto. SocketFlags vengono passati al ReceiveFrom metodo .

static void ReceiveFrom2()
{
   IPHostEntry^ hostEntry = Dns::Resolve( Dns::GetHostName() );
   IPEndPoint^ endPoint = gcnew IPEndPoint( hostEntry->AddressList[ 0 ],11000 );

   Socket^ s = gcnew Socket( endPoint->Address->AddressFamily,
      SocketType::Dgram,
      ProtocolType::Udp );
   
   // Creates an IpEndPoint to capture the identity of the sending host.
   IPEndPoint^ sender = gcnew IPEndPoint( IPAddress::Any,0 );
   EndPoint^ senderRemote = safe_cast<EndPoint^>(sender);
   
   // Binding is required with ReceiveFrom calls.
   s->Bind( endPoint );

   array<Byte>^ msg = gcnew array<Byte>(256);
   Console::WriteLine( "Waiting to receive datagrams from client..." );
   // This call blocks. 
   s->ReceiveFrom( msg, SocketFlags::None, senderRemote );
   s->Close();
}

public static void ReceiveFrom2()
{
    IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
    IPEndPoint endPoint = new IPEndPoint(hostEntry.AddressList[0], 11000);

    Socket s = new Socket(endPoint.Address.AddressFamily,
        SocketType.Dgram,
        ProtocolType.Udp);

    // Creates an IpEndPoint to capture the identity of the sending host.
    IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
    EndPoint senderRemote = (EndPoint)sender;

    // Binding is required with ReceiveFrom calls.
    s.Bind(endPoint);

    byte[] msg = new Byte[256];
    Console.WriteLine("Waiting to receive datagrams from client...");
    // This call blocks.
    s.ReceiveFrom(msg, SocketFlags.None, ref senderRemote);
    s.Close();
}

Public Shared Sub ReceiveFrom2() 
    Dim hostEntry As IPHostEntry = Dns.GetHostEntry(Dns.GetHostName())
    Dim endPoint As New IPEndPoint(hostEntry.AddressList(0), 11000)
    
    Dim s As New Socket(endPoint.Address.AddressFamily, SocketType.Dgram, ProtocolType.Udp)
    
    ' Creates an IpEndPoint to capture the identity of the sending host.
    Dim sender As New IPEndPoint(IPAddress.Any, 0)
    Dim senderRemote As EndPoint = CType(sender, EndPoint)
    
    ' Binding is required with ReceiveFrom calls.
    s.Bind(endPoint)
    
    Dim msg() As Byte = New [Byte](255) {}
    Console.WriteLine("Waiting to receive datagrams from client...")
    ' This call blocks. 
    s.ReceiveFrom(msg, SocketFlags.None, senderRemote)
    s.Close()

End Sub

Commenti

Il ReceiveFrom metodo legge i dati nel buffer parametro , restituisce il numero di byte letti correttamente e acquisisce l'endpoint host remoto da cui sono stati inviati i dati. Questo metodo è utile se si intende ricevere datagrammi senza connessione da un host sconosciuto o da più host.

Questo overload richiede solo di fornire un buffer di ricezione, l'oggetto necessario SocketFlagse un oggetto EndPoint che rappresenta l'host remoto. L'offset viene impostato per impostazione predefinita su 0 e la dimensione predefinita corrisponde alla lunghezza del parametro del buffer.

Con i protocolli senza connessione, ReceiveFrom leggerà il primo datagramma accodato ricevuto nel buffer di rete locale. Se il datagramma ricevuto è maggiore delle dimensioni di buffer, il ReceiveFrom metodo riempirà buffer la maggior parte del messaggio possibile e genererà un'eccezione SocketException. Se si usa un protocollo inaffidabile, i dati in eccesso andranno persi. Se si usa un protocollo affidabile, i dati in eccesso verranno conservati dal provider di servizi e sarà possibile recuperarlo chiamando il ReceiveFrom metodo con un buffer sufficientemente grande.

Se non sono disponibili dati per la lettura, il ReceiveFrom 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 ReceiveFrom 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.

Anche se ReceiveFrom è destinato ai protocolli senza connessione, è possibile usare anche un protocollo orientato alla connessione. Se si sceglie di eseguire questa operazione, è innanzitutto necessario stabilire una connessione host remota chiamando il Connect metodo o accettando una connessione host remota in ingresso chiamando il Accept metodo . Se non si stabilisce o si accetta una connessione prima di chiamare il ReceiveFrom metodo , si otterrà un oggetto SocketException. È anche possibile stabilire un host remoto predefinito per un protocollo senza connessione prima di chiamare il ReceiveFrom metodo .

Con i socket orientati alla connessione, ReceiveFrom leggerà la quantità di dati disponibile fino alle dimensioni di buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il ReceiveFrom metodo verrà completato immediatamente e restituirà zero byte.

Vedi anche

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

Origine:

Socket.cs

Origine:

Socket.cs

public:
 int ReceiveFrom(Span<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags, System::Net::SocketAddress ^ receivedAddress);

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

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

Public Function ReceiveFrom (buffer As Span(Of Byte), socketFlags As SocketFlags, receivedAddress As SocketAddress) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

Socket.cs

public:
 int ReceiveFrom(Span<System::Byte> buffer, System::Net::EndPoint ^ % remoteEP);

public int ReceiveFrom (Span<byte> buffer, ref System.Net.EndPoint remoteEP);

member this.ReceiveFrom : Span<byte> * EndPoint -> int

Public Function ReceiveFrom (buffer As Span(Of Byte), ByRef remoteEP As EndPoint) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Origine:

Socket.cs

Origine:

Socket.cs

Origine:

Socket.cs

public:
 int ReceiveFrom(cli::array <System::Byte> ^ buffer, System::Net::EndPoint ^ % remoteEP);

public int ReceiveFrom (byte[] buffer, ref System.Net.EndPoint remoteEP);

member this.ReceiveFrom : byte[] * EndPoint -> int

Public Function ReceiveFrom (buffer As Byte(), ByRef remoteEP As EndPoint) As Integer

Parametri

Restituisce

Numero di byte ricevuti.

Eccezioni

Esempio

L'esempio di codice seguente riceve un datagramma senza connessione da un host remoto.

static void ReceiveFrom1()
{
   IPHostEntry^ hostEntry = Dns::Resolve( Dns::GetHostName() );
   IPEndPoint^ endPoint = gcnew IPEndPoint( hostEntry->AddressList[ 0 ],11000 );

   Socket^ s = gcnew Socket( endPoint->Address->AddressFamily,
      SocketType::Dgram,
      ProtocolType::Udp );
   
   // Creates an IPEndPoint to capture the identity of the sending host.
   IPEndPoint^ sender = gcnew IPEndPoint( IPAddress::Any,0 );
   EndPoint^ senderRemote = safe_cast<EndPoint^>(sender);
   
   // Binding is required with ReceiveFrom calls.
   s->Bind( endPoint );

   array<Byte>^ msg = gcnew array<Byte>(256);
   Console::WriteLine( "Waiting to receive datagrams from client..." );
   
   // This call blocks. 
   s->ReceiveFrom( msg, senderRemote );
   s->Close();
}

public static void ReceiveFrom1()
{
    IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
    IPEndPoint endPoint = new IPEndPoint(hostEntry.AddressList[0], 11000);

    Socket s = new Socket(endPoint.Address.AddressFamily,
        SocketType.Dgram,
        ProtocolType.Udp);

    // Creates an IPEndPoint to capture the identity of the sending host.
    IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
    EndPoint senderRemote = (EndPoint)sender;

    // Binding is required with ReceiveFrom calls.
    s.Bind(endPoint);

    byte[] msg = new Byte[256];
    Console.WriteLine("Waiting to receive datagrams from client...");

    // This call blocks.
    s.ReceiveFrom(msg, ref senderRemote);
    s.Close();
}

Public Shared Sub ReceiveFrom1() 
    Dim hostEntry As IPHostEntry = Dns.GetHostEntry(Dns.GetHostName())
    Dim endPoint As New IPEndPoint(hostEntry.AddressList(0), 11000)
    
    Dim s As New Socket(endPoint.Address.AddressFamily, SocketType.Dgram, ProtocolType.Udp)
    
    ' Creates an IPEndPoint to capture the identity of the sending host.
    Dim sender As New IPEndPoint(IPAddress.Any, 0)
    Dim senderRemote As EndPoint = CType(sender, EndPoint)
    
    ' Binding is required with ReceiveFrom calls.
    s.Bind(endPoint)
    
    Dim msg() As Byte = New [Byte](255) {}
    Console.WriteLine("Waiting to receive datagrams from client...")
    
    ' This call blocks. 
    s.ReceiveFrom(msg, senderRemote)
    s.Close()

End Sub

Commenti

Il ReceiveFrom metodo legge i dati nel buffer parametro , restituisce il numero di byte letti correttamente e acquisisce l'endpoint host remoto da cui sono stati inviati i dati. Questo metodo è utile se si intende ricevere datagrammi senza connessione da un host sconosciuto o da più host.

Questo overload richiede solo di fornire una ricezione buffere un oggetto EndPoint che rappresenta l'host remoto. Per impostazione predefinita, l'offset del buffer è 0. Per impostazione predefinita, la dimensione è la lunghezza del buffer parametro e il socketFlags valore predefinito è None.

Con i protocolli senza connessione, ReceiveFrom leggerà il primo datagramma accodato ricevuto nel buffer di rete locale. Se il datagramma ricevuto è maggiore delle dimensioni di buffer, il ReceiveFrom metodo riempirà buffer la maggior parte del messaggio possibile e genererà un'eccezione SocketException. Se si usa un protocollo inaffidabile, i dati in eccesso andranno persi. Se si usa un protocollo affidabile, i dati in eccesso verranno conservati dal provider di servizi e sarà possibile recuperarlo chiamando il ReceiveFrom metodo con un buffer sufficientemente grande.

Se non sono disponibili dati per la lettura, il ReceiveFrom 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 ReceiveFrom 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.

Anche se ReceiveFrom è destinato ai protocolli senza connessione, è possibile usare anche un protocollo orientato alla connessione. Se si sceglie di eseguire questa operazione, è innanzitutto necessario stabilire una connessione host remota chiamando il Connect metodo o accettando una connessione host remota in ingresso chiamando il Accept metodo . Se non si stabilisce o si accetta una connessione prima di chiamare il ReceiveFrom metodo , si otterrà un oggetto SocketException. È anche possibile stabilire un host remoto predefinito per un protocollo senza connessione prima di chiamare il ReceiveFrom metodo .

Con i socket orientati alla connessione, ReceiveFrom leggerà la quantità di dati disponibile fino alle dimensioni di buffer. Se l'host remoto arresta la Socket connessione con il Shutdown metodo e tutti i dati disponibili sono stati ricevuti, il ReceiveFrom metodo verrà completato immediatamente e restituirà zero byte.

Vedi anche

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