TcpListener.AcceptTcpClient Método
Definição
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.
Aceita uma solicitação de conexão pendente.
public:
System::Net::Sockets::TcpClient ^ AcceptTcpClient();public System.Net.Sockets.TcpClient AcceptTcpClient ();member this.AcceptTcpClient : unit -> System.Net.Sockets.TcpClientPublic Function AcceptTcpClient () As TcpClientRetornos
Um TcpClient usado para enviar e receber dados.
Exceções
O ouvinte não foi iniciado com uma chamada para Start().
Use a propriedade ErrorCode para obter o código de erro específico. Quando tiver obtido esse código, você poderá consultar a documentação de códigos de erro da API da versão 2 do Windows Sockets para obter uma descrição detalhada do erro.
Exemplos
No exemplo de código a seguir, o AcceptTcpClient método é usado para retornar um TcpClient. Isso TcpClient é usado para se comunicar com o cliente conectado recentemente.
/**
* This program shows how to use the TcpListener class.
* It creates a TcpListener that listens on the specified port (13000).
* To run this program at the command line you enter:
* cs_tcpserver
* Any TcpClient that wants to use this server
* has to explicitly connect to an address obtained by the combination of
* the server on which this TcpServer is running and the port 13000.
* This TcpServer simply echoes back the message sent by the TcpClient, after
* translating it into uppercase.
**/
#using <System.dll>
using namespace System;
using namespace System::IO;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Text;
int main()
{
try
{
// Set the TcpListener on port 13000.
Int32 port = 13000;
TcpListener^ server = gcnew TcpListener(IPAddress::Any, port);
// Start listening for client requests.
server->Start();
// Buffer for reading data
array<Byte>^bytes = gcnew array<Byte>(256);
String^ data = nullptr;
// Enter the listening loop.
while ( true )
{
Console::Write( "Waiting for a connection... " );
// Perform a blocking call to accept requests.
// You could also use server.AcceptSocket() here.
TcpClient^ client = server->AcceptTcpClient();
Console::WriteLine( "Connected!" );
data = nullptr;
// Get a stream object for reading and writing
NetworkStream^ stream = client->GetStream();
Int32 i;
// Loop to receive all the data sent by the client.
while ( (i = stream->Read( bytes, 0, bytes->Length )) != 0 )
{
// Translate data bytes to a ASCII string.
data = System::Text::Encoding::ASCII->GetString( bytes, 0, i );
Console::WriteLine( String::Format( "Received: {0}", data ) );
// Process the data sent by the client.
data = data->ToUpper();
array<Byte>^msg = System::Text::Encoding::ASCII->GetBytes( data );
// Send back a response.
stream->Write( msg, 0, msg->Length );
Console::WriteLine( String::Format( "Sent: {0}", data ) );
}
// Shutdown and end connection
client->Close();
}
}
catch ( SocketException^ e )
{
Console::WriteLine( "SocketException: {0}", e );
}
Console::WriteLine( "\nHit enter to continue..." );
Console::Read();
}
/**
* The following sample is intended to demonstrate how to use a
* TcpListener for synchronous communcation with a TCP client
* It creates a TcpListener that listens on the specified port (13000).
* Any TCP client that wants to use this TcpListener has to explicitly connect
* to an address obtained by the combination of the server
* on which this TcpListener is running and the port 13000.
* This TcpListener simply echoes back the message sent by the client
* after translating it into uppercase.
* Refer to the related client in the TcpClient class.
*/
using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
public class TcpListenerSample
{
static void Main(string[] args)
{
try
{
// set the TcpListener on port 13000
int port = 13000;
TcpListener server = new TcpListener(IPAddress.Any, port);
// Start listening for client requests
server.Start();
// Buffer for reading data
byte[] bytes = new byte[1024];
string data;
//Enter the listening loop
while (true)
{
Console.Write("Waiting for a connection... ");
// Perform a blocking call to accept requests.
// You could also use server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
i = stream.Read(bytes, 0, bytes.Length);
while (i != 0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
Console.WriteLine(String.Format("Received: {0}", data));
// Process the data sent by the client.
data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
// Send back a response.
stream.Write(msg, 0, msg.Length);
Console.WriteLine(String.Format("Sent: {0}", data));
i = stream.Read(bytes, 0, bytes.Length);
}
// Shutdown and end connection
client.Close();
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
Console.WriteLine("Hit enter to continue...");
Console.Read();
}
}
' The following sample is intended to demonstrate how to use a
' TcpListener for synchronous communcation with a TCP client
' It creates a TcpListener that connects to the specified port (13000).
' Any TCP client that wants to use this TcpListener has to explicitly connect
' to an address obtained by the combination of the server
' on which this TcpListener is running and the port 13000.
' This TcpListener simply echoes back the message sent by the client
' after translating it into uppercase.
' Refer to the related client in the TcpClient class.
'/
Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
_
Class MyTcpListener
Public Shared Sub Main()
Try
' Set the TcpListener on port 13000.
Dim port As Int32 = 13000
Dim server As New TcpListener(IPAddress.Any, port)
' Start listening for client requests.
server.Start()
' Buffer for reading data
Dim bytes(1024) As [Byte]
Dim data As [String] = Nothing
' Enter the listening loop.
While True
Console.Write("Waiting for a connection... ")
' Perform a blocking call to accept requests.
' You could also use server.AcceptSocket() here.
Dim client As TcpClient = server.AcceptTcpClient()
Console.WriteLine("Connected!")
data = Nothing
' Get a stream object for reading and writing
Dim stream As NetworkStream = client.GetStream()
Dim i As Int32
' Loop to receive all the data sent by the client.
i = stream.Read(bytes, 0, bytes.Length)
While (i <> 0)
' Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i)
Console.WriteLine([String].Format("Received: {0}", data))
' Process the data sent by the client.
data = data.ToUpper()
Dim msg As [Byte]() = System.Text.Encoding.ASCII.GetBytes(data)
' Send back a response.
stream.Write(msg, 0, msg.Length)
Console.WriteLine([String].Format("Sent: {0}", data))
i = stream.Read(bytes, 0, bytes.Length)
End While
' Shutdown and end connection
client.Close()
End While
Catch e As SocketException
Console.WriteLine("SocketException: {0}", e)
End Try
Console.WriteLine(ControlChars.Cr + "Hit enter to continue...")
Console.Read()
End Sub
End Class
Comentários
AcceptTcpClient é um método de bloqueio que retorna um TcpClient que você pode usar para enviar e receber dados. Use o Pending método para determinar se as solicitações de conexão estão disponíveis na fila de conexão de entrada se você quiser evitar o bloqueio.
Use o TcpClient.GetStream método para obter o subjacente NetworkStream do retornado TcpClient. Ele NetworkStream fornecerá métodos para enviar e receber com o host remoto. Quando você terminar com o TcpClientmétodo, certifique-se de chamar seu Close método. Se você quiser maior flexibilidade do que uma TcpClient oferta, considere usar AcceptSocket.
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 no .NET Framework.