Socket.Receive Método

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive método será concluído imediatamente e gerará um SocketException. Ocorreu um erro ao tentar acessar o soquete. Consulte os comentários abaixo. 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados disponível, até o número de bytes especificado pelo parâmetro size. Se o host remoto desligar a Socket conexão com o Shutdown método e todos os dados disponíveis tiverem sido recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento. O deslocamento do buffer assume como padrão 0, o tamanho assume como padrão o comprimento do parâmetro de buffer e o valor assume Nonecomo SocketFlags padrão .

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Quando o valor de tempo limite for excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketpara conexão, o Receive método lerá o máximo de dados disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Comentários

Esse método lê dados no buffers parâmetro e retorna o número de bytes lidos com êxito. Você pode chamar de soquetes orientados à conexão e sem conexão.

Essa sobrecarga exige que você forneça um ou mais buffers de recebimento. O SocketFlags valor usa Nonecomo padrão .

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam da conexão de host remoto estabelecida no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados que estiver disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão,Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffers parâmetro, buffers será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O seguinte recebe os dados encontrados em buffere especifica None para 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

Comentários

O Receive método lê dados no buffer parâmetro e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento, o número de bytes que você deseja receber e o necessário SocketFlags.

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento. O deslocamento do buffer assume como padrão 0, o tamanho assume como padrão o comprimento do parâmetro de buffer e o valor assume Nonecomo SocketFlags padrão .

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Quando o valor de tempo limite for excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketpara conexão, o Receive método lerá o máximo de dados disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

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

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir especifica um buffer de dados, um deslocamento, um tamanho e um sinalizador de soquete antes de receber dados em um conectado 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

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive método será concluído imediatamente e gerará um SocketException. Ocorreu um erro ao tentar acessar o soquete. Consulte os comentários abaixo. 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados disponível, até o número de bytes especificado pelo parâmetro size. Se o host remoto desligar a Socket conexão com o Shutdown método e todos os dados disponíveis tiverem sido recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir especifica um buffer de dados e SocketFlags para receber dados em um conectado 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

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento e o necessário SocketFlags. O deslocamento do buffer assume como padrão 0 e o tamanho assume como padrão o comprimento do parâmetro de bytes.

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o Receive 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 Receive 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.

Se você estiver usando um orientado Socketpara conexão, o Receive método lerá o máximo de dados que estiver disponível até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento. O deslocamento do buffer assume como padrão 0, o tamanho assume como padrão o comprimento do parâmetro de buffer e o valor assume Nonecomo SocketFlags padrão .

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Quando o valor de tempo limite for excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketpara conexão, o Receive método lerá o máximo de dados disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

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

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Comentários

Esse método lê dados no parâmetro buffers e retorna o número de bytes lidos com êxito. Você pode chamar de soquetes orientados à conexão e sem conexão.

Essa sobrecarga exige que você forneça um ou mais buffers de recebimento.

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam da conexão de host remoto estabelecida no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados que estiver disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffers parâmetro, buffers será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir recebe dados em um conectado 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

Comentários

O Receive método lê dados no parâmetro de buffer e retorna o número de bytes lidos com êxito. Você pode chamar Receive de soquetes orientados à conexão e sem conexão.

Essa sobrecarga requer apenas que você forneça um buffer de recebimento. O deslocamento do buffer assume como padrão 0, o tamanho assume como padrão o comprimento do parâmetro de buffer e o valor assume Nonecomo SocketFlags padrão .

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam do host remoto estabelecido no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados que estiver disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffer parâmetro, buffer será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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

Origem:

Socket.cs

Origem:

Socket.cs

Origem:

Socket.cs

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

Parâmetros

Retornos

O número de bytes recebidos.

Exceções

Exemplos

O exemplo de código a seguir demonstra como receber dados em um conectado 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));

Comentários

Esse método lê dados no buffers parâmetro e retorna o número de bytes lidos com êxito. Você pode chamar de soquetes orientados à conexão e sem conexão.

Essa sobrecarga exige que você forneça um ou mais buffers de recebimento. O SocketFlags valor usa Nonecomo padrão .

Se você estiver usando um protocolo orientado a conexão, deverá chamar Connect para estabelecer uma conexão de host remoto ou Accept para aceitar uma conexão de entrada antes de chamar Receive. O Receive método lerá apenas os dados que chegam da conexão de host remoto estabelecida no Connect método ou Accept . Se você estiver usando um protocolo sem conexão, também poderá usar o ReceiveFrom método . ReceiveFrom permitirá que você receba dados que chegam de qualquer host.

Se nenhum dado estiver disponível para leitura, o método será bloqueado até que os Receive dados sejam disponibilizados, a menos que um valor de tempo limite tenha sido definido usando Socket.ReceiveTimeout. Se o valor de tempo limite tiver sido excedido, a Receive chamada gerará um SocketException. Se você estiver no modo sem bloqueio e não houver dados disponíveis no buffer de pilha de protocolo, o Receive 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.

Se você estiver usando um orientado Socketa conexão, o Receive método lerá o máximo de dados que estiver disponível, até o tamanho do 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 Receive método será concluído imediatamente e retornará zero bytes.

Se você estiver usando um sem Socketconexão, Receive lerá o primeiro datagrama enfileirado do endereço de destino especificado no Connect método . Se o datagrama recebido for maior que o tamanho do buffers parâmetro, buffers será preenchido com a primeira parte da mensagem, os dados em excesso serão perdidos e um SocketException será gerado.

Confira também

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