Socket.ReceiveFrom Método

Referência

Definição

Namespace:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Recebe um datagrama e armazena o ponto de extremidade de origem.

Sobrecargas

ReceiveFrom(Byte[], Int32, SocketFlags, EndPoint)	Recebe o número especificado de bytes no buffer de dados usando o SocketFlags especificado e armazena o ponto de extremidade.
ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)	Recebe o número de bytes de dados no local especificado no buffer de dados usando o SocketFlags especificado e armazena o ponto de extremidade.
ReceiveFrom(Span<Byte>, SocketFlags, EndPoint)	Recebe um datagrama no buffer de dados, usando o SocketFlags especificado e armazena o ponto de extremidade.
ReceiveFrom(Byte[], SocketFlags, EndPoint)	Recebe um datagrama no buffer de dados, usando o SocketFlags especificado e armazena o ponto de extremidade.
ReceiveFrom(Span<Byte>, SocketFlags, SocketAddress)	Recebe um datagrama no buffer de dados, usando o SocketFlags especificado e armazena o ponto de extremidade.
ReceiveFrom(Span<Byte>, EndPoint)	Recebe um datagrama no buffer de dados e armazena o ponto de extremidade.
ReceiveFrom(Byte[], EndPoint)	Recebe um datagrama no buffer de dados e armazena o ponto de extremidade.

ReceiveFrom(Byte[], Int32, SocketFlags, EndPoint)

Origem:: Socket.cs

Origem:: Socket.cs

Origem:: Socket.cs

Recebe o número especificado de bytes no buffer de dados usando o SocketFlags especificado e armazena o ponto de extremidade.

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

buffer: Byte[]

Uma matriz do tipo Byte que é o local de armazenamento dos dados recebidos.

size: Int32

O número de bytes a serem recebidos.

socketFlags: SocketFlags

Uma combinação bit a bit dos valores SocketFlags.

remoteEP: EndPoint

Uma referência a um EndPoint do mesmo tipo que o ponto de extremidade do host remoto a ser atualizado no recebimento bem-sucedido.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

buffer é null.

- ou -

remoteEP é null.

ArgumentOutOfRangeException

size é menor que 0.

- ou -

size é maior que o comprimento do buffer.

SocketException

socketFlags não é uma combinação válida de valores.

- ou -

A propriedade LocalEndPoint não foi definida.

- ou -

Ocorre um erro de sistema operacional ao acessar o Socket.

ObjectDisposedException

O Socket foi fechado.

SecurityException

Um chamador na pilha de chamadas não tem as permissões necessárias.

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.

Observação

Antes de chamar ReceiveFrom, você deve associar explicitamente o Socket a um ponto de extremidade local usando o Bind método . Se você não fizer isso, ReceiveFrom lançará um SocketException. Se você receber um SocketException, use a SocketException.ErrorCode propriedade para obter o código de erro específico. Depois de obter esse código, consulte a documentação do código de erro da API do Windows Sockets versão 2 para obter uma descrição detalhada do erro.

Observação

O AddressFamily do EndPoint usado em ReceiveFrom precisa corresponder ao AddressFamily do EndPoint usado em SendTo.

Observação

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

Aplica-se a

ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)

Origem:: Socket.cs

Origem:: Socket.cs

Origem:: Socket.cs

Recebe o número de bytes de dados no local especificado no buffer de dados usando o SocketFlags especificado e armazena o ponto de extremidade.

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

buffer: Byte[]

Uma matriz do tipo Byte que é o local de armazenamento dos dados recebidos.

offset: Int32

A posição no parâmetro buffer para armazenar os dados recebidos.

size: Int32

O número de bytes a serem recebidos.

socketFlags: SocketFlags

Uma combinação bit a bit dos valores SocketFlags.

remoteEP: EndPoint

Uma referência a um EndPoint do mesmo tipo que o ponto de extremidade do host remoto a ser atualizado no recebimento bem-sucedido.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

buffer é null.

- ou -

remoteEP é null.

ArgumentOutOfRangeException

offset é menor que 0.

- ou -

offset é maior que o comprimento do buffer.

- ou -

size é menor que 0.

- ou -

size é maior que o comprimento de buffer menos o valor do parâmetro de deslocamento.

SocketException

socketFlags não é uma combinação válida de valores.

- ou -

A propriedade LocalEndPoint não foi definida.

- ou -

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

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

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.

Observação

O AddressFamily do EndPoint usado em ReceiveFrom precisa corresponder ao AddressFamily do EndPoint usado em SendTo.

Observação

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

Aplica-se a

ReceiveFrom(Span<Byte>, SocketFlags, EndPoint)

Origem:: Socket.cs

Origem:: Socket.cs

Origem:: Socket.cs

Recebe um datagrama no buffer de dados, usando o SocketFlags especificado e armazena o ponto de extremidade.

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

buffer: Span<Byte>

Um intervalo de bytes que é o local de armazenamento para dados recebidos.

socketFlags: SocketFlags

Uma combinação bit a bit dos valores SocketFlags.

remoteEP: EndPoint

Uma referência a um EndPoint do mesmo tipo que o ponto de extremidade do host remoto a ser atualizado no recebimento bem-sucedido.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

remoteEP é null.

SocketException

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

Aplica-se a

ReceiveFrom(Byte[], SocketFlags, EndPoint)

Origem:: Socket.cs

Origem:: Socket.cs

Origem:: Socket.cs

Recebe um datagrama no buffer de dados, usando o SocketFlags especificado e armazena o ponto de extremidade.

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

buffer: Byte[]

Uma matriz do tipo Byte que é o local de armazenamento dos dados recebidos.

socketFlags: SocketFlags

Uma combinação bit a bit dos valores SocketFlags.

remoteEP: EndPoint

Uma referência a um EndPoint do mesmo tipo que o ponto de extremidade do host remoto a ser atualizado no recebimento bem-sucedido.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

buffer é null.

- ou -

remoteEP é null.

SocketException

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

SecurityException

Um chamador na pilha de chamadas não tem as permissões necessárias.

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

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.

Observação

Antes de chamar ReceiveFrom, você deve associar explicitamente o Socket a um ponto de extremidade local usando o Bind método . Se você não fizer isso, ReceiveFrom lançará um SocketException.

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.

Observação

Se você receber um SocketException, use a SocketException.ErrorCode propriedade para obter o código de erro específico. Depois de obter esse código, consulte a documentação do código de erro da API do Windows Sockets versão 2 para obter uma descrição detalhada do erro.

Observação

O AddressFamily do EndPoint usado em ReceiveFrom precisa corresponder ao AddressFamily do EndPoint usado em SendTo.

Observação

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

Aplica-se a

ReceiveFrom(Span<Byte>, SocketFlags, SocketAddress)

Origem:: Socket.cs

Origem:: Socket.cs

Recebe um datagrama no buffer de dados, usando o SocketFlags especificado e armazena o ponto de extremidade.

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

buffer: Span<Byte>

Um intervalo de bytes que é o local de armazenamento para dados recebidos.

socketFlags: SocketFlags

Uma combinação bit a bit dos valores SocketFlags.

receivedAddress: SocketAddress

Uma SocketAddress instância que é atualizada com o valor do par remoto quando esse método retorna.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

receivedAddress é null.

SocketException

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

Aplica-se a

ReceiveFrom(Span<Byte>, EndPoint)

Origem:: Socket.cs

Origem:: Socket.cs

Origem:: Socket.cs

Recebe um datagrama no buffer de dados e armazena o ponto de extremidade.

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

buffer: Span<Byte>

Um intervalo de bytes que é o local de armazenamento para dados recebidos.

remoteEP: EndPoint

Uma referência a um EndPoint do mesmo tipo que o ponto de extremidade do host remoto a ser atualizado no recebimento bem-sucedido.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

remoteEP é null.

SocketException

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

Aplica-se a

ReceiveFrom(Byte[], EndPoint)

Origem:: Socket.cs

Origem:: Socket.cs

Origem:: Socket.cs

Recebe um datagrama no buffer de dados e armazena o ponto de extremidade.

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

buffer: Byte[]

Uma matriz do tipo Byte que é o local de armazenamento dos dados recebidos.

remoteEP: EndPoint

Uma referência a um EndPoint do mesmo tipo que o ponto de extremidade do host remoto a ser atualizado no recebimento bem-sucedido.

Retornos

Int32

O número de bytes recebidos.

Exceções

ArgumentNullException

buffer é null.

- ou -

remoteEP é null.

SocketException

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

SecurityException

Um chamador na pilha de chamadas não tem as permissões necessárias.

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

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.

Observação

Antes de chamar ReceiveFrom, você deve associar explicitamente o Socket a um ponto de extremidade local usando o Bind método . Se você não fizer isso, ReceiveFrom lançará um SocketException.

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.

Observação

O AddressFamily do EndPoint usado em ReceiveFrom precisa corresponder ao AddressFamily do EndPoint usado em SendTo.

Observação

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede em .NET Framework.

Confira também

Aplica-se a

Compartilhar via

Socket.ReceiveFrom Método

Definição

Sobrecargas

ReceiveFrom(Byte[], Int32, SocketFlags, EndPoint)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

ReceiveFrom(Span<Byte>, SocketFlags, EndPoint)

Parâmetros

Retornos

Exceções

Aplica-se a

ReceiveFrom(Byte[], SocketFlags, EndPoint)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

ReceiveFrom(Span<Byte>, SocketFlags, SocketAddress)

Parâmetros

Retornos

Exceções

Aplica-se a

ReceiveFrom(Span<Byte>, EndPoint)

Parâmetros

Retornos

Exceções

Aplica-se a

ReceiveFrom(Byte[], EndPoint)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais