Socket.Receive Método

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lançará um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Ocorreu um erro ao tentar aceder ao soquete. Veja as Observações abaixo. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiver a usar um orientado Socketà ligação , o Receive método lê tantos dados quanto estiver disponível, até ao número de bytes especificado pelo parâmetro de tamanho. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar uma ligação Socketsem ligação, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Exemplos

O seguinte exemplo de código especifica um buffer de dados, um deslocamento, um tamanho e uma flag de socket antes de receber dados num .Socket

// 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

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lançará um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Ocorreu um erro ao tentar aceder ao soquete. Veja as Observações abaixo. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiver a usar um orientado Socketà ligação , o Receive método lê tantos dados quanto estiver disponível, até ao número de bytes especificado pelo parâmetro de tamanho. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar uma ligação Socketsem ligação, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga só exige que forneça um buffer de receção. O deslocamento do buffer é 0 por defeito, o tamanho corresponde ao comprimento do parâmetro do buffer, e o SocketFlags valor é .None

Se estiver a usar um protocolo orientado a conexões, deve ligar Connect para estabelecer uma ligação remota ao host, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiveres a usar um protocolo sem ligação, também podes usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Quando o valor de time-out é ultrapassado, a Receive chamada lança um SocketException. Se estiveres em modo não-bloqueante e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será concluído imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiveres a usar um sistema orientado Socketà ligação , o Receive método vai ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar um connectionless Socket, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Exemplos

O seguinte recebe os dados encontrados em buffer, e 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, 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

Observações

O Receive método lê dados no buffer parâmetro e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga só exige que forneça um buffer de receção, o número de bytes que deseja receber e o necessário SocketFlags.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lançará um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será concluído imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a sua operação de receção.

Se estiver a usar um orientado Socketà ligação , o Receive método irá ler tantos dados quanto estiver disponível, até ao número de bytes especificados pelo size parâmetro. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar uma ligação Socketsem ligação, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga só exige que forneça um buffer de receção. O deslocamento do buffer é 0 por defeito, o tamanho corresponde ao comprimento do parâmetro do buffer, e o SocketFlags valor é .None

Se estiver a usar um protocolo orientado a conexões, deve ligar Connect para estabelecer uma ligação remota ao host, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiveres a usar um protocolo sem ligação, também podes usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Quando o valor de time-out é ultrapassado, a Receive chamada lança um SocketException. Se estiveres em modo não-bloqueante e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será concluído imediatamente e lança um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiveres a usar um sistema orientado Socketà ligação , o Receive método vai ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar um connectionless Socket, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

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

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Observações

Este método lê dados no buffers parâmetro e devolve o número de bytes lidos com sucesso. Pode ligar tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga exige que forneça um ou mais buffers de receção. O SocketFlags valor por defeito é None.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam da ligação remota do host estabelecida no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lança um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiver a usar um dispositivo orientado Socketà ligação , o Receive método irá ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar uma ligação Socketsem ligação,Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffers parâmetro, buffers for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Exemplos

O seguinte exemplo de código especifica um buffer de dados, e SocketFlags para receber dados num .Socket

// 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

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga só exige que forneça um buffer de receção e o necessário SocketFlags. O deslocamento do buffer é 0 por defeito, e o tamanho corresponde ao comprimento do parâmetro do byte.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método bloqueia até que os dados estejam disponíveis. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a sua operação de receção.

Se estiver a usar uma orientação Socketde ligação , o Receive método irá ler tantos dados quanto estiver disponível até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar um connectionless Socket, Receive irá ler o primeiro datagrama enfileirado a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga só exige que forneça um buffer de receção. O deslocamento do buffer é 0 por defeito, o tamanho corresponde ao comprimento do parâmetro do buffer, e o SocketFlags valor é .None

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação remota ao host, ou Accept aceitar uma ligação recebida antes de ligar Receive. O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiveres a usar um protocolo sem ligação, também podes usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Quando o valor de time-out é ultrapassado, a Receive chamada lança um SocketException. Se estiveres em modo não-bloqueante e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será concluído imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiveres a usar um sistema orientado Socketà ligação , o Receive método vai ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar um connectionless Socket, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

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

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Observações

Este método lê dados no parâmetro de buffers e devolve o número de bytes lidos com sucesso. Pode ligar tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga exige que forneça um ou mais buffers de receção.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam da ligação remota do host estabelecida no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lançará um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiver a usar um dispositivo orientado Socketà ligação , o Receive método irá ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar um connectionless Socket, Receive irá ler o primeiro datagrama enfileirado a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffers parâmetro, buffers for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Nota Este membro gera informação de rastreio quando ativa o rastreio de rede na sua aplicação. Para mais informações, consulte Network Tracing in .NET Framework.

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Exemplos

O exemplo de código seguinte recebe dados sobre um .Socket

// 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

Observações

O Receive método lê dados no parâmetro do buffer e devolve o número de bytes lidos com sucesso. Pode ligar Receive tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga só exige que forneça um buffer de receção. O deslocamento do buffer é 0 por defeito, o tamanho corresponde ao comprimento do parâmetro do buffer, e o SocketFlags valor é .None

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam do host remoto estabelecido no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lançará um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiver a usar um dispositivo orientado Socketà ligação , o Receive método irá ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar uma ligação Socketsem ligação, Receive vai ler o primeiro datagrama em fila a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffer parâmetro, buffer for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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

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

Devoluções

O número total de bytes recebidos. O método retorna zero (0) apenas se foram solicitados zero bytes ou se não houver mais bytes disponíveis porque o socket peer realizou um desligamento gracioso.

Exceções

Exemplos

O exemplo de código seguinte demonstra como receber dados num .Socket

// 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));

Observações

Este método lê dados no buffers parâmetro e devolve o número de bytes lidos com sucesso. Pode ligar tanto a partir de tomadas orientadas por ligação como sem conexão.

Esta sobrecarga exige que forneça um ou mais buffers de receção. O SocketFlags valor por defeito é None.

Se estiver a usar um protocolo orientado à ligação, deve ou ligar Connect para estabelecer uma ligação hoste remota, ou Accept aceitar uma ligação recebida antes de ligar Receivepara . O Receive método só lê dados que chegam da ligação remota do host estabelecida no Connect método ou.Accept Se estiver a usar um protocolo sem conexão, também pode usar o ReceiveFrom método. ReceiveFrom permitirá que receba dados provenientes de qualquer host.

Se não houver dados disponíveis para leitura, o Receive método irá bloquear até que os dados estejam disponíveis, a menos que tenha sido definido um valor de time-out usando Socket.ReceiveTimeout. Se o valor de time-out for ultrapassado, a Receive chamada lança um SocketException. Se estiver em modo não bloqueante, e não houver dados disponíveis no buffer da pilha de protocolos, o Receive método será completado imediatamente e lançará um SocketException. Pode usar a Available propriedade para determinar se há dados disponíveis para leitura. Quando Available for diferente de zero, tente novamente a operação de receção.

Se estiver a usar um dispositivo orientado Socketà ligação , o Receive método irá ler tantos dados quanto estiver disponível, até ao tamanho do buffer. Se o host remoto desligar a Socket ligação com o Shutdown método e todos os dados disponíveis forem recebidos, o Receive método será concluído imediatamente e retornará zero bytes.

Se estiveres a usar um connectionless Socket, Receive irá ler o primeiro datagrama enfileirado a partir do endereço de destino que especificas no Connect método. Se o datagrama que recebes for maior do que o tamanho do buffers parâmetro, buffers for preenchido com a primeira parte da mensagem, os dados em excesso perdem-se e a SocketException é lançado.

Ver também

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