TcpListener.AcceptTcpClient Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Accetta una richiesta di connessione in sospeso.
public:
System::Net::Sockets::TcpClient ^ AcceptTcpClient();public System.Net.Sockets.TcpClient AcceptTcpClient ();member this.AcceptTcpClient : unit -> System.Net.Sockets.TcpClientPublic Function AcceptTcpClient () As TcpClientRestituisce
Oggetto TcpClient utilizzato per inviare e ricevere dati.
Eccezioni
Il listener non è stato avviato con una chiamata a Start().
Per ottenere il codice di errore specificato, utilizzare la proprietà ErrorCode. Una volta ottenuto il codice, è possibile trovare una descrizione dettagliata dell'errore nella documentazione relativa ai codici di errore dell'API di Windows Sockets versione 2.
Esempio
Nell'esempio di codice seguente viene usato il AcceptTcpClient metodo per restituire un oggetto TcpClient. Viene TcpClient usato per comunicare con il client appena connesso.
/**
* 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
Commenti
AcceptTcpClient è un metodo di blocco che restituisce un TcpClient oggetto che è possibile usare per inviare e ricevere dati. Utilizzare il Pending metodo per determinare se le richieste di connessione sono disponibili nella coda di connessione in ingresso se si desidera evitare il blocco.
Utilizzare il TcpClient.GetStream metodo per ottenere l'oggetto sottostante NetworkStream dell'oggetto restituito TcpClient. fornisce NetworkStream metodi per l'invio e la ricezione con l'host remoto. Quando si esegue con TcpClient, assicurarsi di chiamare il relativo Close metodo. Se si vuole una maggiore flessibilità rispetto a un'offerta TcpClient , è consigliabile usare AcceptSocket.
Nota
Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.
