Socket.ReceiveFrom Método

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir recebe um datagrama sem conexão de um host remoto. O tamanho do buffer e SocketFlags são passados para o ReceiveFrom método .

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

Comentários

O ReceiveFrom método lê dados no buffer parâmetro , retorna o número de bytes lidos com êxito e captura o ponto de extremidade do host remoto do qual os dados foram enviados. Esse método será útil se você pretende receber datagramas sem conexão de um host desconhecido ou de vários hosts.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento, o número de bytes que você deseja receber, o necessário SocketFlagse um EndPoint que representa o host remoto. O deslocamento do buffer assume como padrão 0.

Com protocolos sem conexão, ReceiveFrom lerá o primeiro datagrama enfileirado recebido no buffer de rede local. Se o datagrama recebido for maior que o tamanho de buffer, o ReceiveFrom método preencherá buffer com o máximo possível da mensagem e gerará um SocketException. Se você estiver usando um protocolo não confiável, os dados em excesso serão perdidos. Se você estiver usando um protocolo confiável, os dados em excesso serão retidos pelo provedor de serviços e você poderá recuperá-los chamando o ReceiveFrom método com um buffer grande o suficiente.

Se nenhum dado estiver disponível para leitura, o ReceiveFrom método será bloqueado até que os dados sejam disponibilizados. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o ReceiveFrom método será concluído imediatamente e gerará um SocketException. Você pode usar a propriedade para determinar se os Available dados estão disponíveis para leitura. Quando Available for diferente de zero, repita a operação de recebimento.

Embora seja ReceiveFrom destinado a protocolos sem conexão, você também pode usar um protocolo orientado para conexão. Se você optar por fazer isso, primeiro deverá estabelecer uma conexão de host remoto chamando o Connect método ou aceitar uma conexão de host remoto de entrada chamando o Accept método . Se você não estabelecer ou aceitar uma conexão antes de chamar o ReceiveFrom método , obterá um SocketException. Você também pode estabelecer um host remoto padrão para um protocolo sem conexão antes de chamar o ReceiveFrom método .

Com soquetes orientados à conexão, ReceiveFrom lerá o máximo de dados que estiver disponível até o número de bytes especificado pelo size parâmetro . Se o host remoto desligar a Socket conexão com o Shutdown método e todos os dados disponíveis tiverem sido recebidos, o ReceiveFrom método será concluído imediatamente e retornará zero bytes.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir recebe um datagrama sem conexão de um host remoto. O deslocamento, o tamanho do buffer e SocketFlags são passados para o ReceiveFrom método .

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

Comentários

O ReceiveFrom método lê dados no buffer parâmetro , retorna o número de bytes lidos com êxito e captura o ponto de extremidade do host remoto do qual os dados foram enviados. Esse método será útil se você pretende receber datagramas sem conexão de um host desconhecido ou de vários hosts.

Com protocolos sem conexão, ReceiveFrom lerá o primeiro datagrama enfileirado recebido no buffer de rede local. Se o datagrama recebido for maior que o tamanho de buffer, o ReceiveFrom método preencherá buffer com o máximo possível da mensagem e gerará um SocketException. Se você estiver usando um protocolo não confiável, os dados em excesso serão perdidos. Se você estiver usando um protocolo confiável, os dados em excesso serão retidos pelo provedor de serviços e você poderá recuperá-los chamando o ReceiveFrom método com um buffer grande o suficiente.

Se nenhum dado estiver disponível para leitura, o ReceiveFrom método será bloqueado até que os dados sejam disponibilizados. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o ReceiveFrom método será concluído imediatamente e gerará um SocketException. Você pode usar a propriedade para determinar se os Available dados estão disponíveis para leitura. Quando Available for diferente de zero, repita a operação de recebimento.

Embora seja ReceiveFrom destinado a protocolos sem conexão, você também pode usar um protocolo orientado para conexão. Se você optar por fazer isso, primeiro deverá estabelecer uma conexão de host remoto chamando o Connect método ou aceitar uma conexão de host remoto de entrada chamando o Accept método . Se você não estabelecer ou aceitar uma conexão antes de chamar o ReceiveFrom método, obterá um SocketException. Você também pode estabelecer um host remoto padrão para um protocolo sem conexão antes de chamar o ReceiveFrom método .

Com soquetes orientados à conexão, ReceiveFrom lerá o máximo de dados que estiver disponível até a quantidade de bytes especificada pelo size parâmetro . Se o host remoto desligar a Socket conexão com o Shutdown método e todos os dados disponíveis tiverem sido Recebidos, o ReceiveFrom método será concluído imediatamente e retornará zero bytes.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir recebe um datagrama sem conexão de um host remoto. SocketFlags são passados para o ReceiveFrom método .

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

Comentários

O ReceiveFrom método lê dados no buffer parâmetro , retorna o número de bytes lidos com êxito e captura o ponto de extremidade do host remoto do qual os dados foram enviados. Esse método será útil se você pretende receber datagramas sem conexão de um host desconhecido ou de vários hosts.

Essa sobrecarga exige apenas que você forneça um buffer de recebimento, o necessário SocketFlagse um EndPoint que represente o host remoto. O deslocamento é padrão para 0 e o tamanho usa como padrão o comprimento do parâmetro buffer.

Com protocolos sem conexão, ReceiveFrom lerá o primeiro datagrama enfileirado recebido no buffer de rede local. Se o datagrama recebido for maior que o tamanho de buffer, o ReceiveFrom método preencherá buffer com o máximo possível da mensagem e lançará um SocketException. Se você estiver usando um protocolo não confiável, os dados em excesso serão perdidos. Se você estiver usando um protocolo confiável, os dados em excesso serão retidos pelo provedor de serviços e você poderá recuperá-los chamando o ReceiveFrom método com um buffer grande o suficiente.

Se nenhum dado estiver disponível para leitura, o ReceiveFrom método será bloqueado até que os dados sejam disponibilizados. Se você estiver no modo de não bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o ReceiveFrom método será concluído imediatamente e gerará um SocketException. Você pode usar a propriedade para determinar se os Available dados estão disponíveis para leitura. Quando Available não for zero, tente novamente a operação de recebimento.

Embora seja ReceiveFrom destinado a protocolos sem conexão, você também pode usar um protocolo orientado a conexões. Se você optar por fazer isso, primeiro deverá estabelecer uma conexão de host remoto chamando o Connect método ou aceitar uma conexão de host remoto de entrada chamando o Accept método . Se você não estabelecer ou aceitar uma conexão antes de chamar o ReceiveFrom método, obterá um SocketException. Você também pode estabelecer um host remoto padrão para um protocolo sem conexão antes de chamar o ReceiveFrom método .

Com soquetes orientados à conexão, ReceiveFrom lerá o máximo de dados que estiver disponível até o tamanho de buffer. Se o host remoto desligar a Socket conexão com o Shutdown método e todos os dados disponíveis tiverem sido Recebidos, o ReceiveFrom método será concluído imediatamente e retornará zero bytes.

Confira também

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

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir recebe um datagrama sem conexão de um 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

Comentários

O ReceiveFrom método lê dados no buffer parâmetro , retorna o número de bytes lidos com êxito e captura o ponto de extremidade do host remoto do qual os dados foram enviados. Esse método será útil se você pretende receber datagramas sem conexão de um host desconhecido ou de vários hosts.

Essa sobrecarga exige apenas que você forneça um recebimento buffere um EndPoint que represente o host remoto. O deslocamento do buffer é padrão para 0. O tamanho usa como padrão o comprimento do buffer parâmetro e o socketFlags valor é padrão para None.

Com protocolos sem conexão, ReceiveFrom lerá o primeiro datagrama enfileirado recebido no buffer de rede local. Se o datagrama recebido for maior que o tamanho de buffer, o ReceiveFrom método preencherá buffer com o máximo possível da mensagem e gerará um SocketException. Se você estiver usando um protocolo não confiável, os dados em excesso serão perdidos. Se você estiver usando um protocolo confiável, os dados em excesso serão retidos pelo provedor de serviços e você poderá recuperá-los chamando o ReceiveFrom método com um buffer grande o suficiente.

Se nenhum dado estiver disponível para leitura, o ReceiveFrom método será bloqueado até que os dados sejam disponibilizados. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o ReceiveFrom método será concluído imediatamente e gerará um SocketException. Você pode usar a propriedade para determinar se os Available dados estão disponíveis para leitura. Quando Available for diferente de zero, repita a operação de recebimento.

Embora seja ReceiveFrom destinado a protocolos sem conexão, você também pode usar um protocolo orientado para conexão. Se você optar por fazer isso, primeiro deverá estabelecer uma conexão de host remoto chamando o Connect método ou aceitar uma conexão de host remoto de entrada chamando o Accept método . Se você não estabelecer ou aceitar uma conexão antes de chamar o ReceiveFrom método , obterá um SocketException. Você também pode estabelecer um host remoto padrão para um protocolo sem conexão antes de chamar o ReceiveFrom método .

Com soquetes orientados à conexão, ReceiveFrom lerá o máximo de dados que estiver disponível até o tamanho de buffer. Se o host remoto desligar a Socket conexão com o Shutdown método e todos os dados disponíveis tiverem sido recebidos, o ReceiveFrom método será concluído imediatamente e retornará zero bytes.

Confira também

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