Socket Socket Socket Socket Class

Definition

Implementiert die Berkeley-Sockets-Schnittstelle.Implements the Berkeley sockets interface.

public ref class Socket : IDisposable
public class Socket : IDisposable
type Socket = class
    interface IDisposable
Public Class Socket
Implements IDisposable
Vererbung
SocketSocketSocketSocket
Implementiert

Beispiele

Im folgenden Codebeispiel wird gezeigt, Socket wie die-Klasse zum Senden von Daten an einen HTTP-Server und zum Empfangen der Antwort verwendet werden kann.The following code example shows how the Socket class can be used to send data to an HTTP server and receive the response. Dieses Beispiel wird so lange blockiert, bis die gesamte Seite empfangen wird.This example blocks until the entire page is received.

#using <System.dll>

using namespace System;
using namespace System::Text;
using namespace System::IO;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Collections;
Socket^ ConnectSocket( String^ server, int port )
{
   Socket^ s = nullptr;
   IPHostEntry^ hostEntry = nullptr;
   
   // Get host related information.
   hostEntry = Dns::Resolve( server );
   
   // Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
   // an exception that occurs when the host IP Address is not compatible with the address family
   // (typical in the IPv6 case).
   IEnumerator^ myEnum = hostEntry->AddressList->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      IPAddress^ address = safe_cast<IPAddress^>(myEnum->Current);
      IPEndPoint^ endPoint = gcnew IPEndPoint( address,port );
      Socket^ tmpS = gcnew Socket( endPoint->AddressFamily,SocketType::Stream,ProtocolType::Tcp );
      tmpS->Connect( endPoint );
      if ( tmpS->Connected )
      {
         s = tmpS;
         break;
      }
      else
      {
         continue;
      }
   }

   return s;
}

// This method requests the home page content for the specified server.
String^ SocketSendReceive( String^ server, int port )
{
   String^ request = String::Concat( "GET / HTTP/1.1\r\nHost: ", server, "\r\nConnection: Close\r\n\r\n" );
   array<Byte>^bytesSent = Encoding::ASCII->GetBytes( request );
   array<Byte>^bytesReceived = gcnew array<Byte>(256);
   String^ strRetPage = "";
   
   // Create a socket connection with the specified server and port.
   Socket^ s = ConnectSocket( server, port );
   if ( s == nullptr )
      return ("Connection failed");
   
   // Send request to the server.
   s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
   
   // Receive the server home page content.
   int bytes = 0;
   strRetPage = String::Concat( "Default HTML page on ", server, ":\r\n" );
   do
   {
      bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
      strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
   }
   while ( bytes > 0 );
   
   s->Dispose();

   return strRetPage;
}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   String^ host;
   int port = 80;
   if ( args->Length == 1 )
      
   // If no server name is passed as argument to this program, 
   // use the current host name as default.
   host = Dns::GetHostName();
   else
      host = args[ 1 ];

   String^ result = SocketSendReceive( host, port );
   Console::WriteLine( result );
}
using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;

public class GetSocket
{
    private static Socket ConnectSocket(string server, int port)
    {
        Socket s = null;
        IPHostEntry hostEntry = null;
        
        // Get host related information.
        hostEntry = Dns.GetHostEntry(server);

        // Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
        // an exception that occurs when the host IP Address is not compatible with the address family
        // (typical in the IPv6 case).
        foreach(IPAddress address in hostEntry.AddressList)
        {
            IPEndPoint ipe = new IPEndPoint(address, port);
            Socket tempSocket = 
                new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            tempSocket.Connect(ipe);

            if(tempSocket.Connected)
            {
                s = tempSocket;
                break;
            }
            else
            {
                continue;
            }
        }
        return s;
    }

    // This method requests the home page content for the specified server.
    private static string SocketSendReceive(string server, int port) 
    {
        string request = "GET / HTTP/1.1\r\nHost: " + server + 
            "\r\nConnection: Close\r\n\r\n";
        Byte[] bytesSent = Encoding.ASCII.GetBytes(request);
        Byte[] bytesReceived = new Byte[256];
        string page = "";
        
        // Create a socket connection with the specified server and port.
        using(Socket s = ConnectSocket(server, port)) {

            if (s == null)
                return ("Connection failed");
        
            // Send request to the server.
            s.Send(bytesSent, bytesSent.Length, 0);  
            
            // Receive the server home page content.
            int bytes = 0;
            page = "Default HTML page on " + server + ":\r\n";

            // The following will block until the page is transmitted.
            do {
                bytes = s.Receive(bytesReceived, bytesReceived.Length, 0);
                page = page + Encoding.ASCII.GetString(bytesReceived, 0, bytes);
            }
            while (bytes > 0);
        }
        
        return page;
    }
    
    public static void Main(string[] args) 
    {
        string host;
        int port = 80;

        if (args.Length == 0)
            // If no server name is passed as argument to this program, 
            // use the current host name as the default.
            host = Dns.GetHostName();
        else
            host = args[0];

        string result = SocketSendReceive(host, port); 
        Console.WriteLine(result);
    }
}

Imports System.Text
Imports System.IO
Imports System.Net
Imports System.Net.Sockets

Public Class GetSocket
   
   Private Shared Function ConnectSocket(server As String, port As Integer) As Socket
      Dim s As Socket = Nothing
      Dim hostEntry As IPHostEntry = Nothing      
     
         ' Get host related information.
        hostEntry = Dns.GetHostEntry(server)
         
         ' Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
         ' an exception that occurs when the host host IP Address is not compatible with the address family
         ' (typical in the IPv6 case).
      Dim address As IPAddress
 
        For Each address In  hostEntry.AddressList
            Dim endPoint As New IPEndPoint(address, port)
            Dim tempSocket As New Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
      
            tempSocket.Connect(endPoint)
            
            If tempSocket.Connected Then
               s = tempSocket
               Exit For
            End If

         Next address
      
      Return s
   End Function
   
   ' This method requests the home page content for the specified server.
   
   Private Shared Function SocketSendReceive(server As String, port As Integer) As String
      'Set up variables and String to write to the server.
      Dim ascii As Encoding = Encoding.ASCII
      Dim request As String = "GET / HTTP/1.1" + ControlChars.Cr + ControlChars.Lf + "Host: " + server + ControlChars.Cr + ControlChars.Lf + "Connection: Close" + ControlChars.Cr + ControlChars.Lf + ControlChars.Cr + ControlChars.Lf
      Dim bytesSent As [Byte]() = ascii.GetBytes(request)
      Dim bytesReceived(255) As [Byte]
      Dim page As String = ""  
      
      ' Create a socket connection with the specified server and port.
      Dim s As Socket = ConnectSocket(server, port)
      
      If s Is Nothing Then
         Return "Connection failed"
      End If 
      ' Send request to the server.
      s.Send(bytesSent, bytesSent.Length, 0)
      
      ' Receive the server  home page content.
      Dim bytes As Int32
      
      ' Read the first 256 bytes.
      page = "Default HTML page on " + server + ":" + ControlChars.Cr + ControlChars.Lf
      
      ' The following will block until the page is transmitted.
      Do
         bytes = s.Receive(bytesReceived, bytesReceived.Length, 0)
            page = page + Encoding.ASCII.GetString(bytesReceived, 0, bytes)
      Loop While bytes > 0
      
      Return page
   End Function 
   
   'Entry point which delegates to C-style main Private Function
   Public Overloads Shared Sub Main()
      Main(System.Environment.GetCommandLineArgs())
   End Sub
   
   Overloads Private Shared Sub Main(args() As String)
      Dim host As String
      Dim port As Integer = 80
      
      If args.Length = 1 Then
         ' If no server name is passed as argument to this program, 
         ' use the current host name as default.
         host = Dns.GetHostName()
      Else
         host = args(1)
      End If 
      
      Dim result As String = SocketSendReceive(host, port)
      
      Console.WriteLine(result)
   End Sub
End Class  

Hinweise

Die Socket -Klasse stellt einen umfangreichen Satz von Methoden und Eigenschaften für die Netzwerkkommunikation bereit.The Socket class provides a rich set of methods and properties for network communications. Die Socket -Klasse ermöglicht es Ihnen, sowohl synchrone als auch asynchrone Datenübertragungen mithilfe eines der in der ProtocolType -Enumeration aufgeführten Kommunikationsprotokolle auszuführen.The Socket class allows you to perform both synchronous and asynchronous data transfer using any of the communication protocols listed in the ProtocolType enumeration.

Die Socket -Klasse folgt dem .NET Framework Benennungs Muster für asynchrone Methoden.The Socket class follows the .NET Framework naming pattern for asynchronous methods. Beispielsweise entspricht die synchrone Receive -Methode den asynchronen BeginReceive -und- EndReceive Methoden.For example, the synchronous Receive method corresponds to the asynchronous BeginReceive and EndReceive methods.

Wenn für die Anwendung nur ein Thread während der Ausführung erforderlich ist, verwenden Sie die folgenden Methoden, die für den synchronen Betriebsmodus vorgesehen sind.If your application only requires one thread during execution, use the following methods, which are designed for synchronous operation mode.

  • Wenn Sie ein Verbindungs orientiertes Protokoll wie z. b. TCP verwenden, kann der Server mit der Listen -Methode auf Verbindungen lauschen.If you are using a connection-oriented protocol such as TCP, your server can listen for connections using the Listen method. Die Accept -Methode verarbeitet alle eingehenden Verbindungsanforderungen und Socket gibt einen zurück, den Sie verwenden können, um Daten mit dem Remote Host zu kommunizieren.The Accept method processes any incoming connection requests and returns a Socket that you can use to communicate data with the remote host. Verwenden Sie diese Socket Rückgabe, um Send die Receive -oder-Methode aufzurufen.Use this returned Socket to call the Send or Receive method. Rufen Sie Bind die-Methode vor dem Listen Aufrufen der-Methode auf, wenn Sie die lokale IP-Adresse und die Portnummer angeben möchten.Call the Bind method prior to calling the Listen method if you want to specify the local IP address and port number. Verwenden Sie die Portnummer 0 (null), wenn der zugrunde liegende Dienstanbieter einen freien Port zuweisen soll.Use a port number of zero if you want the underlying service provider to assign a free port for you. Wenn Sie eine Verbindung mit einem Überwachungshost herstellen möchten, Connect müssen Sie die-Methode aufzurufen.If you want to connect to a listening host, call the Connect method. Um Daten zu kommunizieren, können Send Sie Receive die-oder-Methode abrufen.To communicate data, call the Send or Receive method.

  • Wenn Sie ein verbindungsloses Protokoll (z. b. UDP) verwenden, müssen Sie nicht auf Verbindungen lauschen.If you are using a connectionless protocol such as UDP, you do not need to listen for connections at all. Ruft die ReceiveFrom -Methode auf, um eingehende Datagramme zu akzeptieren.Call the ReceiveFrom method to accept any incoming datagrams. Verwenden Sie SendTo die-Methode, um Datagramme an einen Remote Host zu senden.Use the SendTo method to send datagrams to a remote host.

Verwenden Sie die folgenden Methoden, die für den asynchronen Betriebsmodus entwickelt wurden, um die Kommunikation mit separaten Threads während der Ausführung zu verarbeiten.To process communications using separate threads during execution, use the following methods, which are designed for asynchronous operation mode.

Wenn Sie mehrere asynchrone Vorgänge für einen Socket ausführen, werden diese nicht notwendigerweise in der Reihenfolge, in der Sie gestartet wurden, vervollständigt.If you perform multiple asynchronous operations on a socket, they do not necessarily complete in the order in which they are started.

Wenn Sie mit dem Senden und empfangen von Daten fertig sind Shutdown , verwenden Sie die Socket-Methode, um zu deaktivieren.When you are finished sending and receiving data, use the Shutdown method to disable the Socket. Rufen Sie Shutdownnach dem Aufrufen Close der-Methode auf, um alle dem Socketzugeordneten Ressourcen freizugeben.After calling Shutdown, call the Close method to release all resources associated with the Socket.

Die Socket -Klasse ermöglicht es Ihnen, Socket mit der SetSocketOption -Methode zu konfigurieren.The Socket class allows you to configure your Socket using the SetSocketOption method. Rufen Sie diese Einstellungen mithilfe GetSocketOption der-Methode ab.Retrieve these settings using the GetSocketOption method.

Hinweis

Wenn Sie eine relativ einfache Anwendung schreiben und keine maximale Leistung benötigen, sollten Sie die Verwendung TcpClientvon TcpListener, und UdpClientin Erwägung gezogen.If you are writing a relatively simple application and do not require maximum performance, consider using TcpClient, TcpListener, and UdpClient. Diese Klassen stellen eine einfachere und benutzerfreundlichere Oberfläche für die Socket Kommunikation bereit.These classes provide a simpler and more user-friendly interface to Socket communications.

Konstruktoren

Socket(AddressFamily, SocketType, ProtocolType) Socket(AddressFamily, SocketType, ProtocolType) Socket(AddressFamily, SocketType, ProtocolType) Socket(AddressFamily, SocketType, ProtocolType)

Initialisiert eine neue Instanz der Socket-Klasse unter Verwendung der angegebenen Adressfamilie sowie des angegebenen Sockettyps und Protokolls.Initializes a new instance of the Socket class using the specified address family, socket type and protocol.

Socket(SocketInformation) Socket(SocketInformation) Socket(SocketInformation) Socket(SocketInformation)

Initialisiert eine neue Instanz der Socket-Klasse mit dem angegebenen Wert, der von DuplicateAndClose(Int32) zurückgegeben wird.Initializes a new instance of the Socket class using the specified value returned from DuplicateAndClose(Int32).

Socket(SocketType, ProtocolType) Socket(SocketType, ProtocolType) Socket(SocketType, ProtocolType) Socket(SocketType, ProtocolType)

Initialisiert eine neue Instanz der Socket-Klasse unter Verwendung der angegebenen Sockettyps und Protokolls.Initializes a new instance of the Socket class using the specified socket type and protocol.

Eigenschaften

AddressFamily AddressFamily AddressFamily AddressFamily

Ruft die Adressfamilie des Socket ab.Gets the address family of the Socket.

Available Available Available Available

Ruft die Datenmenge ab, die über das Netzwerk empfangen wurde und gelesen werden kann.Gets the amount of data that has been received from the network and is available to be read.

Blocking Blocking Blocking Blocking

Ruft einen Wert ab, der angibt, ob sich der Socket im blockierenden Modus befindet.Gets or sets a value that indicates whether the Socket is in blocking mode.

Connected Connected Connected Connected

Ruft einen Wert ab, der angibt, ob ein Socket mit dem Remotehost des letzten Send-Vorgangs oder Receive-Vorgangs verbunden ist.Gets a value that indicates whether a Socket is connected to a remote host as of the last Send or Receive operation.

DontFragment DontFragment DontFragment DontFragment

Ruft einen Boolean-Wert ab, der angibt, ob der Socket die Fragmentierung von IP (Internet Protocol)-Datagrammen zulässt, oder legt diesen fest.Gets or sets a Boolean value that specifies whether the Socket allows Internet Protocol (IP) datagrams to be fragmented.

DualMode DualMode DualMode DualMode

Ruft einen Boolean-Wert ab, der angibt, ob der Socket ein für IPv4 und IPv6 verwendeter Dualmodussocket ist, oder legt ihn fest.Gets or sets a Boolean value that specifies whether the Socket is a dual-mode socket used for both IPv4 and IPv6.

EnableBroadcast EnableBroadcast EnableBroadcast EnableBroadcast

Ruft einen Boolean-Wert ab, der angibt, ob der Socket Broadcastpakete senden oder empfangen kann, oder legt diesen fest.Gets or sets a Boolean value that specifies whether the Socket can send or receive broadcast packets.

ExclusiveAddressUse ExclusiveAddressUse ExclusiveAddressUse ExclusiveAddressUse

Ruft einen Boolean-Wert ab, der angibt, ob der Socket das Binden nur eines einzigen Prozesses an einen Anschluss zulässt, oder legt diesen fest.Gets or sets a Boolean value that specifies whether the Socket allows only one process to bind to a port.

Handle Handle Handle Handle

Ruft das Betriebssystemhandle für den Socket ab.Gets the operating system handle for the Socket.

IsBound IsBound IsBound IsBound

Ruft einen Wert ab, der angibt, ob der Socket an einen bestimmten lokalen Anschluss gebunden ist.Gets a value that indicates whether the Socket is bound to a specific local port.

LingerState LingerState LingerState LingerState

Ruft einen Wert ab, der angibt, ob der Socket bei einem Versuch, alle ausstehenden Daten zu senden, das Schließen eines Sockets verzögert, oder legt diesen fest.Gets or sets a value that specifies whether the Socket will delay closing a socket in an attempt to send all pending data.

LocalEndPoint LocalEndPoint LocalEndPoint LocalEndPoint

Ruft den lokalen Endpunkt ab.Gets the local endpoint.

MulticastLoopback MulticastLoopback MulticastLoopback MulticastLoopback

Ruft einen Wert ab, der angibt, ob ausgehende Multicastpakete an die sendende Anwendung übermittelt werden, oder legt diesen fest.Gets or sets a value that specifies whether outgoing multicast packets are delivered to the sending application.

NoDelay NoDelay NoDelay NoDelay

Ruft einen Boolean-Wert ab, der angibt, ob der Stream-Socket den Nagle-Algorithmus verwendet, oder legt diesen fest.Gets or sets a Boolean value that specifies whether the stream Socket is using the Nagle algorithm.

OSSupportsIPv4 OSSupportsIPv4 OSSupportsIPv4 OSSupportsIPv4

Gibt an, ob das zugrunde liegende Betriebssystem und die Netzwerkkarten IPv4 (Internet Protocol, Version 4) unterstützen.Indicates whether the underlying operating system and network adaptors support Internet Protocol version 4 (IPv4).

OSSupportsIPv6 OSSupportsIPv6 OSSupportsIPv6 OSSupportsIPv6

Gibt an, ob das zugrunde liegende Betriebssystem und die Netzwerkkarten IPv6 (Internet Protocol, Version 6) unterstützen.Indicates whether the underlying operating system and network adaptors support Internet Protocol version 6 (IPv6).

ProtocolType ProtocolType ProtocolType ProtocolType

Ruft den Protokolltyp des Socket ab.Gets the protocol type of the Socket.

ReceiveBufferSize ReceiveBufferSize ReceiveBufferSize ReceiveBufferSize

Ruft einen Wert ab, der die Größe des Empfangspuffers des Socket angibt, oder legt diesen fest.Gets or sets a value that specifies the size of the receive buffer of the Socket.

ReceiveTimeout ReceiveTimeout ReceiveTimeout ReceiveTimeout

Ruft einen Wert ab, der die Zeitspanne bis zum Timeout eines synchronen Receive-Aufrufs angibt, oder legt diesen fest.Gets or sets a value that specifies the amount of time after which a synchronous Receive call will time out.

RemoteEndPoint RemoteEndPoint RemoteEndPoint RemoteEndPoint

Ruft den Remoteendpunkt ab.Gets the remote endpoint.

SafeHandle SafeHandle SafeHandle SafeHandle

Ruft ein SafeSocketHandle ab, das den Sockethandle darstellt, der vom aktuellen Socket-Objekt gekapselt wird.Gets a SafeSocketHandle that represents the socket handle that the current Socket object encapsulates.

SendBufferSize SendBufferSize SendBufferSize SendBufferSize

Ruft einen Wert ab, der die Größe des Sendepuffers für den Socket angibt, oder legt diesen fest.Gets or sets a value that specifies the size of the send buffer of the Socket.

SendTimeout SendTimeout SendTimeout SendTimeout

Ruft einen Wert ab, der die Zeitspanne bis zum Timeout eines synchronen Send-Aufrufs angibt, oder legt diesen fest.Gets or sets a value that specifies the amount of time after which a synchronous Send call will time out.

SocketType SocketType SocketType SocketType

Ruft den Typ des Socket ab.Gets the type of the Socket.

SupportsIPv4 SupportsIPv4 SupportsIPv4 SupportsIPv4

Ruft einen Wert ab, der angibt, ob IPv4-Unterstützung verfügbar und auf dem aktuellen Host aktiviert ist.Gets a value indicating whether IPv4 support is available and enabled on the current host.

SupportsIPv6 SupportsIPv6 SupportsIPv6 SupportsIPv6

Ruft einen Wert ab, der angibt, ob das Framework IPv6 für bestimmte veraltete Dns-Member unterstützt.Gets a value that indicates whether the Framework supports IPv6 for certain obsolete Dns members.

Ttl Ttl Ttl Ttl

Ruft einen Wert ab, der die Gültigkeitsdauer (TTL) von IP (Internet Protocol)-Paketen angibt, die vom Socket gesendet werden.Gets or sets a value that specifies the Time To Live (TTL) value of Internet Protocol (IP) packets sent by the Socket.

UseOnlyOverlappedIO UseOnlyOverlappedIO UseOnlyOverlappedIO UseOnlyOverlappedIO

Gibt an, ob der Socket nur den Modus für überlappende E/A-Vorgänge verwenden soll.Specifies whether the socket should only use Overlapped I/O mode.

Methoden

Accept() Accept() Accept() Accept()

Erstellt einen neuen Socket für eine neu erstellte Verbindung.Creates a new Socket for a newly created connection.

AcceptAsync(SocketAsyncEventArgs) AcceptAsync(SocketAsyncEventArgs) AcceptAsync(SocketAsyncEventArgs) AcceptAsync(SocketAsyncEventArgs)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.Begins an asynchronous operation to accept an incoming connection attempt.

BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.Begins an asynchronous operation to accept an incoming connection attempt.

BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.Begins an asynchronous operation to accept an incoming connection attempt and receives the first block of data sent by the client application.

BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung von einem angegebenen Socket anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.Begins an asynchronous operation to accept an incoming connection attempt from a specified socket and receives the first block of data sent by the client application.

BeginConnect(EndPoint, AsyncCallback, Object) BeginConnect(EndPoint, AsyncCallback, Object) BeginConnect(EndPoint, AsyncCallback, Object) BeginConnect(EndPoint, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung.Begins an asynchronous request for a remote host connection.

BeginConnect(IPAddress, Int32, AsyncCallback, Object) BeginConnect(IPAddress, Int32, AsyncCallback, Object) BeginConnect(IPAddress, Int32, AsyncCallback, Object) BeginConnect(IPAddress, Int32, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung.Begins an asynchronous request for a remote host connection. Der Host wird durch eine IPAddress und eine Anschlussnummer angegeben.The host is specified by an IPAddress and a port number.

BeginConnect(IPAddress[], Int32, AsyncCallback, Object) BeginConnect(IPAddress[], Int32, AsyncCallback, Object) BeginConnect(IPAddress[], Int32, AsyncCallback, Object) BeginConnect(IPAddress[], Int32, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung.Begins an asynchronous request for a remote host connection. Der Host wird durch ein IPAddress-Array und eine Anschlussnummer angegeben.The host is specified by an IPAddress array and a port number.

BeginConnect(String, Int32, AsyncCallback, Object) BeginConnect(String, Int32, AsyncCallback, Object) BeginConnect(String, Int32, AsyncCallback, Object) BeginConnect(String, Int32, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung.Begins an asynchronous request for a remote host connection. Der Host wird durch einen Hostnamen und eine Portnummer angegeben.The host is specified by a host name and a port number.

BeginDisconnect(Boolean, AsyncCallback, Object) BeginDisconnect(Boolean, AsyncCallback, Object) BeginDisconnect(Boolean, AsyncCallback, Object) BeginDisconnect(Boolean, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung zum Trennen der Verbindung mit einem Remoteendunkt.Begins an asynchronous request to disconnect from a remote endpoint.

BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)

Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.Begins to asynchronously receive data from a connected Socket.

BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object) BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object) BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object) BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)

Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.Begins to asynchronously receive data from a connected Socket.

BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object) BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object) BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object) BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)

Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.Begins to asynchronously receive data from a connected Socket.

BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object) BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object) BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object) BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)

Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.Begins to asynchronously receive data from a connected Socket.

BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)

Beginnt den asynchronen Datenempfang aus dem angegebenen Netzwerkgerät.Begins to asynchronously receive data from a specified network device.

BeginReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)

Beginnt unter Verwendung der angegebenen SocketFlags-Klassen den asynchronen Empfang der angegebenen Anzahl von Datenbytes an der angegebenen Position im Datenpuffer und speichert die Endpunkt- und Paketinformationen.Begins to asynchronously receive the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)

Sendet Daten asynchron an einen verbundenen Socket.Sends data asynchronously to a connected Socket.

BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object) BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object) BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object) BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)

Sendet Daten asynchron an einen verbundenen Socket.Sends data asynchronously to a connected Socket.

BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object) BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object) BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object) BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)

Sendet Daten asynchron an einen verbundenen Socket.Sends data asynchronously to a connected Socket.

BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object) BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object) BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object) BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)

Sendet Daten asynchron an einen verbundenen Socket.Sends data asynchronously to a connected Socket.

BeginSendFile(String, AsyncCallback, Object) BeginSendFile(String, AsyncCallback, Object) BeginSendFile(String, AsyncCallback, Object) BeginSendFile(String, AsyncCallback, Object)

Sendet die Datei fileName unter Verwendung des Socket-Flags an ein verbundenes UseDefaultWorkerThread-Objekt.Sends the file fileName to a connected Socket object using the UseDefaultWorkerThread flag.

BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object) BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object) BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object) BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object)

Sendet eine Datei und Datenpuffer asynchron an ein verbundenes Socket-Objekt.Sends a file and buffers of data asynchronously to a connected Socket object.

BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)

Sendet asynchron Daten an einen angegebenen Remotehost.Sends data asynchronously to a specific remote host.

Bind(EndPoint) Bind(EndPoint) Bind(EndPoint) Bind(EndPoint)

Ordnet einem Socket einen lokalen Endpunkt zu.Associates a Socket with a local endpoint.

CancelConnectAsync(SocketAsyncEventArgs) CancelConnectAsync(SocketAsyncEventArgs) CancelConnectAsync(SocketAsyncEventArgs) CancelConnectAsync(SocketAsyncEventArgs)

Bricht eine asynchrone Anforderung einer Remotehostverbindung ab.Cancels an asynchronous request for a remote host connection.

Close() Close() Close() Close()

Schließt die Socket-Verbindung und gibt alle zugeordneten Ressourcen frei.Closes the Socket connection and releases all associated resources.

Close(Int32) Close(Int32) Close(Int32) Close(Int32)

Schließt die Socket-Verbindung und gibt alle zugeordneten Ressourcen mit einem angegebenen Timeout frei, damit in der Warteschlange befindliche Daten gesendet werden können.Closes the Socket connection and releases all associated resources with a specified timeout to allow queued data to be sent.

Connect(EndPoint) Connect(EndPoint) Connect(EndPoint) Connect(EndPoint)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host.

Connect(IPAddress, Int32) Connect(IPAddress, Int32) Connect(IPAddress, Int32) Connect(IPAddress, Int32)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host. Der Host wird mit einer IP-Adresse und einer Portnummer angegeben.The host is specified by an IP address and a port number.

Connect(IPAddress[], Int32) Connect(IPAddress[], Int32) Connect(IPAddress[], Int32) Connect(IPAddress[], Int32)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host. Der Host wird durch ein Array von IP-Adressen und eine Portnummer angegeben.The host is specified by an array of IP addresses and a port number.

Connect(String, Int32) Connect(String, Int32) Connect(String, Int32) Connect(String, Int32)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host. Der Host wird durch einen Hostnamen und eine Portnummer angegeben.The host is specified by a host name and a port number.

ConnectAsync(SocketAsyncEventArgs) ConnectAsync(SocketAsyncEventArgs) ConnectAsync(SocketAsyncEventArgs) ConnectAsync(SocketAsyncEventArgs)

Beginnt eine asynchrone Anforderung einer Verbindung mit einem Remotehost.Begins an asynchronous request for a connection to a remote host.

ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs) ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs) ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs) ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs)

Beginnt eine asynchrone Anforderung einer Verbindung mit einem Remotehost.Begins an asynchronous request for a connection to a remote host.

Disconnect(Boolean) Disconnect(Boolean) Disconnect(Boolean) Disconnect(Boolean)

Schließt die Socketverbindung und ermöglicht die Wiederverwendung des Sockets.Closes the socket connection and allows reuse of the socket.

DisconnectAsync(SocketAsyncEventArgs) DisconnectAsync(SocketAsyncEventArgs) DisconnectAsync(SocketAsyncEventArgs) DisconnectAsync(SocketAsyncEventArgs)

Beginnt eine asynchrone Anforderung zum Trennen der Verbindung mit einem Remoteendunkt.Begins an asynchronous request to disconnect from a remote endpoint.

Dispose() Dispose() Dispose() Dispose()

Gibt alle von der aktuellen Instanz der Socket-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the Socket class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt die vom Socket verwendeten, nicht verwalteten Ressourcen frei und verwirft optional auch die verwalteten Ressourcen.Releases the unmanaged resources used by the Socket, and optionally disposes of the managed resources.

DuplicateAndClose(Int32) DuplicateAndClose(Int32) DuplicateAndClose(Int32) DuplicateAndClose(Int32)

Dupliziert den Socketverweis für den Zielprozess und schließt den Socket für diesen Prozess.Duplicates the socket reference for the target process, and closes the socket for this process.

EndAccept(Byte[], IAsyncResult) EndAccept(Byte[], IAsyncResult) EndAccept(Byte[], IAsyncResult) EndAccept(Byte[], IAsyncResult)

Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt ein neues Socket-Objekt zum Behandeln der Remotehostkommunikation.Asynchronously accepts an incoming connection attempt and creates a new Socket object to handle remote host communication. Diese Methode gibt einen Puffer zurück, der die ersten übertragenen Daten enthält.This method returns a buffer that contains the initial data transferred.

EndAccept(Byte[], Int32, IAsyncResult) EndAccept(Byte[], Int32, IAsyncResult) EndAccept(Byte[], Int32, IAsyncResult) EndAccept(Byte[], Int32, IAsyncResult)

Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt ein neues Socket-Objekt zum Behandeln der Remotehostkommunikation.Asynchronously accepts an incoming connection attempt and creates a new Socket object to handle remote host communication. Diese Methode gibt einen Puffer zurück, der die ersten Daten und die Anzahl der übertragenen Bytes enthält.This method returns a buffer that contains the initial data and the number of bytes transferred.

EndAccept(IAsyncResult) EndAccept(IAsyncResult) EndAccept(IAsyncResult) EndAccept(IAsyncResult)

Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt einen neuen Socket zum Behandeln der Remotehostkommunikation.Asynchronously accepts an incoming connection attempt and creates a new Socket to handle remote host communication.

EndConnect(IAsyncResult) EndConnect(IAsyncResult) EndConnect(IAsyncResult) EndConnect(IAsyncResult)

Beendet eine ausstehende asynchrone Verbindungsanforderung.Ends a pending asynchronous connection request.

EndDisconnect(IAsyncResult) EndDisconnect(IAsyncResult) EndDisconnect(IAsyncResult) EndDisconnect(IAsyncResult)

Beendet eine ausstehende asynchrone Anforderung zur Trennung der Verbindung.Ends a pending asynchronous disconnect request.

EndReceive(IAsyncResult) EndReceive(IAsyncResult) EndReceive(IAsyncResult) EndReceive(IAsyncResult)

Beendet einen ausstehenden asynchronen Lesevorgang.Ends a pending asynchronous read.

EndReceive(IAsyncResult, SocketError) EndReceive(IAsyncResult, SocketError) EndReceive(IAsyncResult, SocketError) EndReceive(IAsyncResult, SocketError)

Beendet einen ausstehenden asynchronen Lesevorgang.Ends a pending asynchronous read.

EndReceiveFrom(IAsyncResult, EndPoint) EndReceiveFrom(IAsyncResult, EndPoint) EndReceiveFrom(IAsyncResult, EndPoint) EndReceiveFrom(IAsyncResult, EndPoint)

Beendet einen ausstehenden asynchronen Lesevorgang von einem bestimmten Endpunkt.Ends a pending asynchronous read from a specific endpoint.

EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation) EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation) EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation) EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation)

Beendet einen ausstehenden asynchronen Lesevorgang von einem bestimmten Endpunkt.Ends a pending asynchronous read from a specific endpoint. Diese Methode stellt außerdem mehr Informationen über das Paket als EndReceiveFrom(IAsyncResult, EndPoint) bereit.This method also reveals more information about the packet than EndReceiveFrom(IAsyncResult, EndPoint).

EndSend(IAsyncResult) EndSend(IAsyncResult) EndSend(IAsyncResult) EndSend(IAsyncResult)

Beendet einen ausstehenden asynchronen Sendevorgang.Ends a pending asynchronous send.

EndSend(IAsyncResult, SocketError) EndSend(IAsyncResult, SocketError) EndSend(IAsyncResult, SocketError) EndSend(IAsyncResult, SocketError)

Beendet einen ausstehenden asynchronen Sendevorgang.Ends a pending asynchronous send.

EndSendFile(IAsyncResult) EndSendFile(IAsyncResult) EndSendFile(IAsyncResult) EndSendFile(IAsyncResult)

Beendet ein ausstehendes asynchrones Senden einer Datei.Ends a pending asynchronous send of a file.

EndSendTo(IAsyncResult) EndSendTo(IAsyncResult) EndSendTo(IAsyncResult) EndSendTo(IAsyncResult)

Beendet einen ausstehenden asynchronen Sendevorgang an einen bestimmten Zielort.Ends a pending asynchronous send to a specific location.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

Gibt von der Socket-Klasse verwendete Ressourcen frei.Frees resources used by the Socket class.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Gibt einen Hashwert für eine Socket-Instanz zurück.Returns a hash value for a Socket instance.

GetSocketOption(SocketOptionLevel, SocketOptionName) GetSocketOption(SocketOptionLevel, SocketOptionName) GetSocketOption(SocketOptionLevel, SocketOptionName) GetSocketOption(SocketOptionLevel, SocketOptionName)

Gibt den Wert einer angegebenen, als Objekt dargestellten Socket-Option zurück.Returns the value of a specified Socket option, represented as an object.

GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[]) GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[]) GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[]) GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

Gibt die angegebene Socket-Optionseinstellung als Bytearray dargestellt zurück.Returns the specified Socket option setting, represented as a byte array.

GetSocketOption(SocketOptionLevel, SocketOptionName, Int32) GetSocketOption(SocketOptionLevel, SocketOptionName, Int32) GetSocketOption(SocketOptionLevel, SocketOptionName, Int32) GetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Gibt den Wert der angegebenen Socket-Option in einem Array zurück.Returns the value of the specified Socket option in an array.

GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
IOControl(Int32, Byte[], Byte[]) IOControl(Int32, Byte[], Byte[]) IOControl(Int32, Byte[], Byte[]) IOControl(Int32, Byte[], Byte[])

Legt mit numerischen Steuerungscodes die Betriebsmodi niedriger Ebene für den Socket fest.Sets low-level operating modes for the Socket using numerical control codes.

IOControl(IOControlCode, Byte[], Byte[]) IOControl(IOControlCode, Byte[], Byte[]) IOControl(IOControlCode, Byte[], Byte[]) IOControl(IOControlCode, Byte[], Byte[])

Legt mithilfe der Socket-Enumeration zum Angeben von Steuerungscodes Betriebsmodi niedriger Ebene für den IOControlCode fest.Sets low-level operating modes for the Socket using the IOControlCode enumeration to specify control codes.

Listen(Int32) Listen(Int32) Listen(Int32) Listen(Int32)

Versetzt einen Socket in den Überwachungszustand.Places a Socket in a listening state.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Poll(Int32, SelectMode) Poll(Int32, SelectMode) Poll(Int32, SelectMode) Poll(Int32, SelectMode)

Bestimmt den Status des Socket.Determines the status of the Socket.

Receive(Byte[]) Receive(Byte[]) Receive(Byte[]) Receive(Byte[])

Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer.Receives data from a bound Socket into a receive buffer.

Receive(Byte[], Int32, Int32, SocketFlags) Receive(Byte[], Int32, Int32, SocketFlags) Receive(Byte[], Int32, Int32, SocketFlags) Receive(Byte[], Int32, Int32, SocketFlags)

Empfängt die angegebene Anzahl von Bytes aus einem gebundenen Socket an der angegebenen Offsetposition des Empfangspuffers, wobei die angegebenen SocketFlags verwendet werden.Receives the specified number of bytes from a bound Socket into the specified offset position of the receive buffer, using the specified SocketFlags.

Receive(Byte[], Int32, Int32, SocketFlags, SocketError) Receive(Byte[], Int32, Int32, SocketFlags, SocketError) Receive(Byte[], Int32, Int32, SocketFlags, SocketError) Receive(Byte[], Int32, Int32, SocketFlags, SocketError)

Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.Receives data from a bound Socket into a receive buffer, using the specified SocketFlags.

Receive(Byte[], Int32, SocketFlags) Receive(Byte[], Int32, SocketFlags) Receive(Byte[], Int32, SocketFlags) Receive(Byte[], Int32, SocketFlags)

Empfängt die angegebene Anzahl von Datenbytes aus einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.Receives the specified number of bytes of data from a bound Socket into a receive buffer, using the specified SocketFlags.

Receive(Byte[], SocketFlags) Receive(Byte[], SocketFlags) Receive(Byte[], SocketFlags) Receive(Byte[], SocketFlags)

Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.Receives data from a bound Socket into a receive buffer, using the specified SocketFlags.

Receive(IList<ArraySegment<Byte>>) Receive(IList<ArraySegment<Byte>>) Receive(IList<ArraySegment<Byte>>) Receive(IList<ArraySegment<Byte>>)

Empfängt Daten von einem gebundenen Socket und fügt sie in die Liste der Empfangspuffer ein.Receives data from a bound Socket into the list of receive buffers.

Receive(IList<ArraySegment<Byte>>, SocketFlags) Receive(IList<ArraySegment<Byte>>, SocketFlags) Receive(IList<ArraySegment<Byte>>, SocketFlags) Receive(IList<ArraySegment<Byte>>, SocketFlags)

Empfängt Daten von einem gebundenen Socket in der Liste der Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.Receives data from a bound Socket into the list of receive buffers, using the specified SocketFlags.

Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError) Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError) Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError) Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

Empfängt Daten von einem gebundenen Socket in der Liste der Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.Receives data from a bound Socket into the list of receive buffers, using the specified SocketFlags.

Receive(Span<Byte>) Receive(Span<Byte>) Receive(Span<Byte>) Receive(Span<Byte>)
Receive(Span<Byte>, SocketFlags) Receive(Span<Byte>, SocketFlags) Receive(Span<Byte>, SocketFlags) Receive(Span<Byte>, SocketFlags)
Receive(Span<Byte>, SocketFlags, SocketError) Receive(Span<Byte>, SocketFlags, SocketError) Receive(Span<Byte>, SocketFlags, SocketError) Receive(Span<Byte>, SocketFlags, SocketError)
ReceiveAsync(SocketAsyncEventArgs) ReceiveAsync(SocketAsyncEventArgs) ReceiveAsync(SocketAsyncEventArgs) ReceiveAsync(SocketAsyncEventArgs)

Startet eine asynchrone Anforderung, um Daten von einem verbundenen Socket-Objekt zu empfangen.Begins an asynchronous request to receive data from a connected Socket object.

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

Empfängt ein Datagramm im Datenpuffer und speichert den Endpunkt.Receives a datagram into the data buffer and stores the endpoint.

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

Empfängt die angegebene Anzahl von Datenbytes an der angegebenen Position im Datenpuffer, verwendet dabei die angegebenen SocketFlags und speichert den Endpunkt.Receives the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint.

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

Empfängt mithilfe der angegebenen SocketFlags die angegebene Anzahl von Bytes im Datenpuffer und speichert den Endpunkt.Receives the specified number of bytes into the data buffer, using the specified SocketFlags, and stores the endpoint.

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

Empfängt mithilfe der angegebenen SocketFlags ein Datagramm im Datenpuffer und speichert den Endpunkt.Receives a datagram into the data buffer, using the specified SocketFlags, and stores the endpoint.

ReceiveFromAsync(SocketAsyncEventArgs) ReceiveFromAsync(SocketAsyncEventArgs) ReceiveFromAsync(SocketAsyncEventArgs) ReceiveFromAsync(SocketAsyncEventArgs)

Beginnt den asynchronen Datenempfang aus dem angegebenen Netzwerkgerät.Begins to asynchronously receive data from a specified network device.

ReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, IPPacketInformation) ReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, IPPacketInformation) ReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, IPPacketInformation) ReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, IPPacketInformation)

Empfängt die angegebene Anzahl von Datenbytes an der angegebenen Position im Datenpuffer, verwendet dabei die angegebenen SocketFlags und speichert die Endpunkt- und Paketinformationen.Receives the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

ReceiveMessageFromAsync(SocketAsyncEventArgs) ReceiveMessageFromAsync(SocketAsyncEventArgs) ReceiveMessageFromAsync(SocketAsyncEventArgs) ReceiveMessageFromAsync(SocketAsyncEventArgs)

Beginnt unter Verwendung der angegebenen SocketFlags den asynchronen Empfang der angegebenen Anzahl von Datenbytes an der angegebenen Position im Datenpuffer und speichert die Endpunkt- und Paketinformationen.Begins to asynchronously receive the specified number of bytes of data into the specified location in the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

Select(IList, IList, IList, Int32) Select(IList, IList, IList, Int32) Select(IList, IList, IList, Int32) Select(IList, IList, IList, Int32)

Bestimmt den Status von einem oder mehreren Sockets.Determines the status of one or more sockets.

Send(Byte[]) Send(Byte[]) Send(Byte[]) Send(Byte[])

Sendet Daten an einen verbundenen Socket.Sends data to a connected Socket.

Send(Byte[], Int32, Int32, SocketFlags) Send(Byte[], Int32, Int32, SocketFlags) Send(Byte[], Int32, Int32, SocketFlags) Send(Byte[], Int32, Int32, SocketFlags)

Sendet die angegebene Anzahl von Datenbytes an einen verbundenen Socket, beginnend bei einem angegebenen Offset und unter Verwendung der angegebenen SocketFlags.Sends the specified number of bytes of data to a connected Socket, starting at the specified offset, and using the specified SocketFlags.

Send(Byte[], Int32, Int32, SocketFlags, SocketError) Send(Byte[], Int32, Int32, SocketFlags, SocketError) Send(Byte[], Int32, Int32, SocketFlags, SocketError) Send(Byte[], Int32, Int32, SocketFlags, SocketError)

Sendet unter Verwendung der angegebenen Socket die angegebene Anzahl von Datenbytes an einen verbundenen SocketFlags, beginnend beim angegebenen Offset.Sends the specified number of bytes of data to a connected Socket, starting at the specified offset, and using the specified SocketFlags

Send(Byte[], Int32, SocketFlags) Send(Byte[], Int32, SocketFlags) Send(Byte[], Int32, SocketFlags) Send(Byte[], Int32, SocketFlags)

Sendet die angegebene Anzahl von Datenbytes an einen verbundenen Socket, wobei die angegebenen SocketFlags verwendet werden.Sends the specified number of bytes of data to a connected Socket, using the specified SocketFlags.

Send(Byte[], SocketFlags) Send(Byte[], SocketFlags) Send(Byte[], SocketFlags) Send(Byte[], SocketFlags)

Sendet Daten mithilfe der angegebenen Socket an einen verbundenen SocketFlags.Sends data to a connected Socket using the specified SocketFlags.

Send(IList<ArraySegment<Byte>>) Send(IList<ArraySegment<Byte>>) Send(IList<ArraySegment<Byte>>) Send(IList<ArraySegment<Byte>>)

Sendet den Satz der Puffer in der Liste an einen verbundenen Socket.Sends the set of buffers in the list to a connected Socket.

Send(IList<ArraySegment<Byte>>, SocketFlags) Send(IList<ArraySegment<Byte>>, SocketFlags) Send(IList<ArraySegment<Byte>>, SocketFlags) Send(IList<ArraySegment<Byte>>, SocketFlags)

Sendet den Satz von Puffern in der Liste unter Verwendung der angegebenen Socket an einen verbundenen SocketFlags.Sends the set of buffers in the list to a connected Socket, using the specified SocketFlags.

Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError) Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError) Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError) Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

Sendet den Satz von Puffern in der Liste unter Verwendung der angegebenen Socket an einen verbundenen SocketFlags.Sends the set of buffers in the list to a connected Socket, using the specified SocketFlags.

Send(ReadOnlySpan<Byte>) Send(ReadOnlySpan<Byte>) Send(ReadOnlySpan<Byte>) Send(ReadOnlySpan<Byte>)
Send(ReadOnlySpan<Byte>, SocketFlags) Send(ReadOnlySpan<Byte>, SocketFlags) Send(ReadOnlySpan<Byte>, SocketFlags) Send(ReadOnlySpan<Byte>, SocketFlags)
Send(ReadOnlySpan<Byte>, SocketFlags, SocketError) Send(ReadOnlySpan<Byte>, SocketFlags, SocketError) Send(ReadOnlySpan<Byte>, SocketFlags, SocketError) Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)
SendAsync(SocketAsyncEventArgs) SendAsync(SocketAsyncEventArgs) SendAsync(SocketAsyncEventArgs) SendAsync(SocketAsyncEventArgs)

Sendet Daten asynchron an ein verbundenes Socket-Objekt.Sends data asynchronously to a connected Socket object.

SendFile(String) SendFile(String) SendFile(String) SendFile(String)

Sendet die Datei fileName mit dem Socket-Übertragungsflag an ein verbundenes UseDefaultWorkerThread-Objekt.Sends the file fileName to a connected Socket object with the UseDefaultWorkerThread transmit flag.

SendFile(String, Byte[], Byte[], TransmitFileOptions) SendFile(String, Byte[], Byte[], TransmitFileOptions) SendFile(String, Byte[], Byte[], TransmitFileOptions) SendFile(String, Byte[], Byte[], TransmitFileOptions)

Sendet die Datei fileName und puffert Daten mit dem angegebenen TransmitFileOptions-Wert in einem verbundenen Socket-Objekt.Sends the file fileName and buffers of data to a connected Socket object using the specified TransmitFileOptions value.

SendPacketsAsync(SocketAsyncEventArgs) SendPacketsAsync(SocketAsyncEventArgs) SendPacketsAsync(SocketAsyncEventArgs) SendPacketsAsync(SocketAsyncEventArgs)

Sendet eine Auflistung von Dateien oder Datenpuffern im Speicher asynchron an ein verbundenes Socket-Objekt.Sends a collection of files or in memory data buffers asynchronously to a connected Socket object.

SendTo(Byte[], EndPoint) SendTo(Byte[], EndPoint) SendTo(Byte[], EndPoint) SendTo(Byte[], EndPoint)

Sendet Daten an den angegebenen Endpunkt.Sends data to the specified endpoint.

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

Sendet die angegebene Anzahl von Datenbytes an den angegebenen Endpunkt und beginnt dabei an der angegebenen Position im Puffer, wobei die angegebenen SocketFlags verwendet werden.Sends the specified number of bytes of data to the specified endpoint, starting at the specified location in the buffer, and using the specified SocketFlags.

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

Sendet die angegebene Anzahl von Datenbytes an den angegebenen Endpunkt, wobei die angegebenen SocketFlags verwendet werden.Sends the specified number of bytes of data to the specified endpoint using the specified SocketFlags.

SendTo(Byte[], SocketFlags, EndPoint) SendTo(Byte[], SocketFlags, EndPoint) SendTo(Byte[], SocketFlags, EndPoint) SendTo(Byte[], SocketFlags, EndPoint)

Sendet Daten an einen bestimmten Endpunkt unter Verwendung der angegebenen SocketFlags.Sends data to a specific endpoint using the specified SocketFlags.

SendToAsync(SocketAsyncEventArgs) SendToAsync(SocketAsyncEventArgs) SendToAsync(SocketAsyncEventArgs) SendToAsync(SocketAsyncEventArgs)

Sendet asynchron Daten an einen angegebenen Remotehost.Sends data asynchronously to a specific remote host.

SetIPProtectionLevel(IPProtectionLevel) SetIPProtectionLevel(IPProtectionLevel) SetIPProtectionLevel(IPProtectionLevel) SetIPProtectionLevel(IPProtectionLevel)

Legt die IP-Schutzebene für einen Socket fest.Set the IP protection level on a socket.

SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean) SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean) SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean) SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean)

Legt die angegebene Socket-Option auf den angegebenen Boolean-Wert fest.Sets the specified Socket option to the specified Boolean value.

SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[]) SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[]) SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[]) SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

Legt die angegebene Socket-Option auf den angegebenen, als Bytearray dargestellten Wert fest.Sets the specified Socket option to the specified value, represented as a byte array.

SetSocketOption(SocketOptionLevel, SocketOptionName, Int32) SetSocketOption(SocketOptionLevel, SocketOptionName, Int32) SetSocketOption(SocketOptionLevel, SocketOptionName, Int32) SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Legt die angegebene Socket-Option auf den angegebenen ganzzahligen Wert fest.Sets the specified Socket option to the specified integer value.

SetSocketOption(SocketOptionLevel, SocketOptionName, Object) SetSocketOption(SocketOptionLevel, SocketOptionName, Object) SetSocketOption(SocketOptionLevel, SocketOptionName, Object) SetSocketOption(SocketOptionLevel, SocketOptionName, Object)

Legt die angegebene Socket-Option auf den angegebenen, als Objekt dargestellten Wert fest.Sets the specified Socket option to the specified value, represented as an object.

Shutdown(SocketShutdown) Shutdown(SocketShutdown) Shutdown(SocketShutdown) Shutdown(SocketShutdown)

Deaktiviert Senden und Empfangen für einen Socket.Disables sends and receives on a Socket.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Gibt alle vom Socket verwendeten Ressourcen frei.Releases all resources used by the Socket.

Erweiterungsmethoden

AcceptAsync(Socket) AcceptAsync(Socket) AcceptAsync(Socket) AcceptAsync(Socket)

Führt einen asynchronen Vorgang aus, um einen eingehenden Verbindungsversuch auf dem Socket anzunehmen.Performs an asynchronous operation on to accept an incoming connection attempt on the socket.

AcceptAsync(Socket, Socket) AcceptAsync(Socket, Socket) AcceptAsync(Socket, Socket) AcceptAsync(Socket, Socket)

Führt einen asynchronen Vorgang aus, um einen eingehenden Verbindungsversuch auf dem Socket anzunehmen.Performs an asynchronous operation on to accept an incoming connection attempt on the socket.

ConnectAsync(Socket, EndPoint) ConnectAsync(Socket, EndPoint) ConnectAsync(Socket, EndPoint) ConnectAsync(Socket, EndPoint)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host.

ConnectAsync(Socket, IPAddress, Int32) ConnectAsync(Socket, IPAddress, Int32) ConnectAsync(Socket, IPAddress, Int32) ConnectAsync(Socket, IPAddress, Int32)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host. Der Host wird mit einer IP-Adresse und einer Portnummer angegeben.The host is specified by an IP address and a port number.

ConnectAsync(Socket, IPAddress[], Int32) ConnectAsync(Socket, IPAddress[], Int32) ConnectAsync(Socket, IPAddress[], Int32) ConnectAsync(Socket, IPAddress[], Int32)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host. Der Host wird durch ein Array von IP-Adressen und eine Portnummer angegeben.The host is specified by an array of IP addresses and a port number.

ConnectAsync(Socket, String, Int32) ConnectAsync(Socket, String, Int32) ConnectAsync(Socket, String, Int32) ConnectAsync(Socket, String, Int32)

Stellt eine Verbindung mit einem Remotehost her.Establishes a connection to a remote host. Der Host wird durch einen Hostnamen und eine Portnummer angegeben.The host is specified by a host name and a port number.

ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags) ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags) ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags) ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags)

Empfängt Daten aus einem verbundenen Socket.Receives data from a connected socket.

ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags) ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags) ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags) ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)

Empfängt Daten aus einem verbundenen Socket.Receives data from a connected socket.

ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken) ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken) ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken) ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken)
ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)

Empfängt Daten von einem angegebenen Netzwerkgerät.Receives data from a specified network device.

ReceiveMessageFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) ReceiveMessageFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) ReceiveMessageFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) ReceiveMessageFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)

Empfängt die angegebene Anzahl von Datenbytes an der angegebenen Position im Datenpuffer, verwendet dabei die angegebenen SocketFlags und speichert die Endpunkt- und Paketinformationen.Receives the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

SendAsync(Socket, ArraySegment<Byte>, SocketFlags) SendAsync(Socket, ArraySegment<Byte>, SocketFlags) SendAsync(Socket, ArraySegment<Byte>, SocketFlags) SendAsync(Socket, ArraySegment<Byte>, SocketFlags)

Sendet Daten an einen verbundenen Socket.Sends data to a connected socket.

SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags) SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags) SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags) SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)

Sendet Daten an einen verbundenen Socket.Sends data to a connected socket.

SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken) SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken) SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken) SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)
SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint) SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)

Sendet asynchron Daten an einen angegebenen Remotehost.Sends data asynchronously to a specific remote host.

Sicherheit

SocketPermission
, Um eine ausgehende Verbindung herzustellen oder eine eingehende Anforderung zu akzeptieren.To establish an outgoing connection or accept an incoming request.

Gilt für:

Threadsicherheit

Instanzen dieser Klasse sind Thread sicher.Instances of this class are thread safe.

Siehe auch