Socket Klasse

Definition

Namespace:: System.Net.Sockets

Assemblys:: System.dll, System.Net.Sockets.dll

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Implementiert die Berkeley-Sockets-Schnittstelle.

public ref class Socket : IDisposable

public class Socket : IDisposable

type Socket = class
    interface IDisposable

Public Class Socket
Implements IDisposable

Vererbung: Object
Socket

Implementiert: IDisposable

Beispiele

Das folgende Codebeispiel zeigt, wie die -Klasse verwendet werden kann, um Daten an einen HTTP-Server zu senden Socket und die Antwort zu empfangen. In diesem Beispiel wird blockiert, bis die gesamte Seite empfangen wird.

#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 umfangreiches Satz von Methoden und Eigenschaften für die Netzwerkkommunikation zur Unterstützung der Netzwerkkommunikation zur Verfingung von Netzwerkverbindungen zur Mit Socket der -Klasse können Sie sowohl synchrone als auch asynchrone Datenübertragungen mithilfe eines der in der -Enumeration aufgeführten Kommunikationsprotokolle ProtocolType ausführen.

Die Socket -Klasse folgt dem .NET Framework Benennungsmuster für asynchrone Methoden. Beispielsweise entspricht die Receive synchrone Methode den asynchronen Methoden BeginReceive und EndReceive .

Wenn Ihre Anwendung während der Ausführung nur einen Thread erfordert, verwenden Sie die folgenden Methoden, die für den synchronen Betriebsmodus konzipiert sind.

Wenn Sie ein verbindungsorientiertes Protokoll wie TCP verwenden, kann Ihr Server mithilfe der -Methode auf Verbindungen Listen lauschen. Die -Methode verarbeitet alle eingehenden Verbindungsanforderungen und gibt eine zurück, mit der Sie Daten mit dem Accept Socket Remotehost kommunizieren können. Verwenden Sie diese Socket zurückgegebene , um die Send - oder Receive -Methode auf aufruft. Rufen Sie Bind die -Methode vor dem Aufrufen der -Methode auf, wenn Sie die lokale IP-Adresse und Listen Portnummer angeben möchten. Verwenden Sie die Portnummer 0 (null), wenn der zugrunde liegende Dienstanbieter Ihnen einen kostenlosen Port zuweisen soll. Wenn Sie eine Verbindung mit einem lauschenden Host herstellen möchten, rufen Sie die Connect -Methode auf. Um Daten zu kommunizieren, rufen Sie die Send - oder Receive -Methode auf.
Wenn Sie ein verbindungsloses Protokoll wie UDP verwenden, müssen Sie überhaupt nicht auf Verbindungen lauschen. Rufen Sie die ReceiveFrom -Methode auf, um alle eingehenden Datagramme zu akzeptieren. Verwenden Sie die SendTo -Methode, um Datagramme an einen Remotehost zu senden.

Um die Kommunikation während der Ausführung mithilfe separater Threads zu verarbeiten, verwenden Sie die folgenden Methoden, die für den asynchronen Betriebsmodus konzipiert sind.

Wenn Sie ein verbindungsorientiertes Protokoll wie TCP verwenden, verwenden Sie die Methoden , und , um eine Verbindung mit einem Socket BeginConnect EndConnect lauschenden Host herzustellen. Verwenden Sie die BeginSend Methoden und oder und , um Daten EndSend BeginReceive EndReceive asynchron zu kommunizieren. Eingehende Verbindungsanforderungen können mit und BeginAccept verarbeitet EndAccept werden.
Wenn Sie ein verbindungsloses Protokoll wie UDP verwenden, können Sie und zum Senden von Datagrammen und und zum BeginSendTo EndSendTo Empfangen von BeginReceiveFrom EndReceiveFrom Datagrammen verwenden.

Wenn Sie mehrere asynchrone Vorgänge für einen Socket ausführen, werden diese nicht unbedingt in der Reihenfolge abgeschlossen, in der sie gestartet werden.

Wenn Sie mit dem Senden und Empfangen von Daten fertig sind, verwenden Sie die Shutdown -Methode, um zu Socket deaktivieren. Rufen Sie nach Shutdown dem Aufruf von die Close -Methode auf, um alle Ressourcen frei zu geben, die zugeordnet Socket sind.

Mit Socket der -Klasse können Sie ihre Socket mithilfe der -Methode SetSocketOption konfigurieren. Rufen Sie diese Einstellungen mithilfe der -Methode GetSocketOption ab.

Hinweis

Wenn Sie eine relativ einfache Anwendung schreiben und keine maximale Leistung erfordern, erwägen Sie die Verwendung TcpClient von TcpListener , und UdpClient . Diese Klassen bieten eine einfachere und benutzerfreundlichere Schnittstelle für die Socket Kommunikation.

Konstruktoren

Socket(AddressFamily, SocketType, ProtocolType)	Initialisiert eine neue Instanz der Socket-Klasse unter Verwendung der angegebenen Adressfamilie sowie des angegebenen Sockettyps und Protokolls.
Socket(SafeSocketHandle)	Initialisiert für das angegebene Sockethandle eine neue Instanz der Socket-Klasse.
Socket(SocketInformation)	Initialisiert eine neue Instanz der Socket-Klasse mit dem angegebenen Wert, der von DuplicateAndClose(Int32) zurückgegeben wird.
Socket(SocketType, ProtocolType)	Initialisiert eine neue Instanz der Socket-Klasse unter Verwendung der angegebenen Sockettyps und Protokolls. Wenn das Betriebssystem IPv6 unterstützt, erstellt dieser Konstruktor einen Socket im dualen Modus. Andernfalls wird ein IPv4-Socket erstellt.

Eigenschaften

AddressFamily	Ruft die Adressfamilie des Socket ab.
Available	Ruft die Datenmenge ab, die über das Netzwerk empfangen wurde und gelesen werden kann.
Blocking	Ruft einen Wert ab, der angibt, ob sich der Socket im blockierenden Modus befindet.
Connected	Ruft einen Wert ab, der angibt, ob ein Socket mit dem Remotehost des letzten Send-Vorgangs oder Receive-Vorgangs verbunden ist.
DontFragment	Ruft einen Wert ab, der angibt, ob der Socket die Fragmentierung von IP-Datagrammen (Internet Protocol) zulässt, oder legt diesen fest.
DualMode	Ruft einen Wert ab, der angibt, ob es sich bei um einen Socket im dualen Modus handelt, der sowohl für IPv4 als auch für IPv6 verwendet wird, oder Socket legt diesen fest.
EnableBroadcast	Ruft einen Boolean-Wert ab, der angibt, ob der Socket Broadcastpakete senden oder empfangen kann, oder legt diesen fest.
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.
Handle	Ruft das Betriebssystemhandle für den Socket ab.
IsBound	Ruft einen Wert ab, der angibt, ob der Socket an einen bestimmten lokalen Anschluss gebunden ist.
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.
LocalEndPoint	Ruft den lokalen Endpunkt ab.
MulticastLoopback	Ruft einen Wert ab, der angibt, ob ausgehende Multicastpakete an die sendende Anwendung übermittelt werden, oder legt diesen fest.
NoDelay	Ruft einen Boolean-Wert ab, der angibt, ob der Stream-Socket den Nagle-Algorithmus verwendet, oder legt diesen fest.
OSSupportsIPv4	Gibt an, ob das zugrunde liegende Betriebssystem und die Netzwerkkarten IPv4 (Internet Protocol, Version 4) unterstützen.
OSSupportsIPv6	Gibt an, ob das zugrunde liegende Betriebssystem und die Netzwerkkarten IPv6 (Internet Protocol, Version 6) unterstützen.
OSSupportsUnixDomainSockets	Gibt an, ob das zugrunde liegende Betriebssystem die UNIX-Domänensockets unterstützt.
ProtocolType	Ruft den Protokolltyp des Socket ab.
ReceiveBufferSize	Ruft einen Wert ab, der die Größe des Empfangspuffers des Socket angibt, oder legt diesen fest.
ReceiveTimeout	Ruft einen Wert ab, der die Zeitspanne bis zum Timeout eines synchronen Receive-Aufrufs angibt, oder legt diesen fest.
RemoteEndPoint	Ruft den Remoteendpunkt ab.
SafeHandle	Ruft ein SafeSocketHandle ab, das den Sockethandle darstellt, der vom aktuellen Socket-Objekt gekapselt wird.
SendBufferSize	Ruft einen Wert ab, der die Größe des Sendepuffers für den Socket angibt, oder legt diesen fest.
SendTimeout	Ruft einen Wert ab, der die Zeitspanne bis zum Timeout eines synchronen Send-Aufrufs angibt, oder legt diesen fest.
SocketType	Ruft den Typ des Socket ab.
SupportsIPv4	Veraltet. Veraltet. Veraltet. Veraltet. Ruft einen Wert ab, der angibt, ob IPv4-Unterstützung verfügbar und auf dem aktuellen Host aktiviert ist.
SupportsIPv6	Veraltet. Veraltet. Veraltet. Veraltet. Ruft einen Wert ab, der angibt, ob das Framework IPv6 für bestimmte veraltete Dns-Member unterstützt.
Ttl	Ruft einen Wert ab, der die Gültigkeitsdauer (TTL) von IP (Internet Protocol)-Paketen angibt, die vom Socket gesendet werden.
UseOnlyOverlappedIO	Veraltet. Ruft einen Wert ab, der angibt, ob der Socket nur den überlappenden E/A-Modus verwenden soll, oder legt diesen fest. Unter .NET 5 und höher (einschließlich .NET Core-Versionen) ist der Wert immer `false` .

Methoden

Accept()	Erstellt einen neuen Socket für eine neu erstellte Verbindung.
AcceptAsync()	Akzeptiert eine eingehende Verbindung.
AcceptAsync(CancellationToken)	Akzeptiert eine eingehende Verbindung.
AcceptAsync(Socket)	Akzeptiert eine eingehende Verbindung.
AcceptAsync(Socket, CancellationToken)	Akzeptiert eine eingehende Verbindung.
AcceptAsync(SocketAsyncEventArgs)	Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.
BeginAccept(AsyncCallback, Object)	Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.
BeginAccept(Int32, AsyncCallback, Object)	Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.
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.
BeginConnect(EndPoint, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung.
BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Der Host wird durch eine IPAddress und eine Anschlussnummer angegeben.
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Der Host wird durch ein IPAddress-Array und eine Anschlussnummer angegeben.
BeginConnect(String, Int32, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Der Host wird durch einen Hostnamen und eine Portnummer angegeben.
BeginDisconnect(Boolean, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung zum Trennen der Verbindung mit einem Remoteendunkt.
BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)	Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.
BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)	Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.
BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)	Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.
BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)	Beginnt den asynchronen Datenempfang aus dem verbundenen Socket.
BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)	Beginnt den asynchronen Datenempfang aus dem angegebenen Netzwerkgerät.
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.
BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)	Sendet Daten asynchron an einen verbundenen Socket.
BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)	Sendet Daten asynchron an einen verbundenen Socket.
BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)	Sendet Daten asynchron an einen verbundenen Socket.
BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)	Sendet Daten asynchron an einen verbundenen Socket.
BeginSendFile(String, AsyncCallback, Object)	Sendet die Datei `fileName` unter Verwendung des Socket-Flags an ein verbundenes UseDefaultWorkerThread-Objekt.
BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object)	Sendet eine Datei und Datenpuffer asynchron an ein verbundenes Socket-Objekt.
BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)	Sendet asynchron Daten an einen angegebenen Remotehost.
Bind(EndPoint)	Ordnet einem Socket einen lokalen Endpunkt zu.
CancelConnectAsync(SocketAsyncEventArgs)	Bricht eine asynchrone Anforderung einer Remotehostverbindung ab.
Close()	Schließt die Socket-Verbindung und gibt alle zugeordneten Ressourcen frei.
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.
Connect(EndPoint)	Stellt eine Verbindung mit einem Remotehost her.
Connect(IPAddress, Int32)	Stellt eine Verbindung mit einem Remotehost her. Der Host wird mit einer IP-Adresse und einer Portnummer angegeben.
Connect(IPAddress[], Int32)	Stellt eine Verbindung mit einem Remotehost her. Der Host wird durch ein Array von IP-Adressen und eine Portnummer angegeben.
Connect(String, Int32)	Stellt eine Verbindung mit einem Remotehost her. Der Host wird durch einen Hostnamen und eine Portnummer angegeben.
ConnectAsync(EndPoint)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(EndPoint, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(IPAddress, Int32)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(IPAddress, Int32, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(IPAddress[], Int32)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(IPAddress[], Int32, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(SocketAsyncEventArgs)	Beginnt eine asynchrone Anforderung einer Verbindung mit einem Remotehost.
ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs)	Beginnt eine asynchrone Anforderung einer Verbindung mit einem Remotehost.
ConnectAsync(String, Int32)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(String, Int32, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her.
Disconnect(Boolean)	Schließt die Socketverbindung und ermöglicht die Wiederverwendung des Sockets.
DisconnectAsync(Boolean, CancellationToken)	Trennt einen verbundenen Socket vom Remotehost.
DisconnectAsync(SocketAsyncEventArgs)	Beginnt eine asynchrone Anforderung zum Trennen der Verbindung mit einem Remoteendunkt.
Dispose()	Gibt alle von der aktuellen Instanz der Socket-Klasse verwendeten Ressourcen frei.
Dispose(Boolean)	Gibt die vom Socket verwendeten, nicht verwalteten Ressourcen frei und verwirft optional auch die verwalteten Ressourcen.
DuplicateAndClose(Int32)	Dupliziert den Socketverweis für den Zielprozess und schließt den Socket für diesen Prozess.
EndAccept(Byte[], IAsyncResult)	Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt ein neues Socket-Objekt zum Behandeln der Remotehostkommunikation. Diese Methode gibt einen Puffer zurück, der die ersten übertragenen Daten enthält.
EndAccept(Byte[], Int32, IAsyncResult)	Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt ein neues Socket-Objekt zum Behandeln der Remotehostkommunikation. Diese Methode gibt einen Puffer zurück, der die ersten Daten und die Anzahl der übertragenen Bytes enthält.
EndAccept(IAsyncResult)	Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt einen neuen Socket zum Behandeln der Remotehostkommunikation.
EndConnect(IAsyncResult)	Beendet eine ausstehende asynchrone Verbindungsanforderung.
EndDisconnect(IAsyncResult)	Beendet eine ausstehende asynchrone Anforderung zur Trennung der Verbindung.
EndReceive(IAsyncResult)	Beendet einen ausstehenden asynchronen Lesevorgang.
EndReceive(IAsyncResult, SocketError)	Beendet einen ausstehenden asynchronen Lesevorgang.
EndReceiveFrom(IAsyncResult, EndPoint)	Beendet einen ausstehenden asynchronen Lesevorgang von einem bestimmten Endpunkt.
EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation)	Beendet einen ausstehenden asynchronen Lesevorgang von einem bestimmten Endpunkt. Diese Methode stellt außerdem mehr Informationen über das Paket als EndReceiveFrom(IAsyncResult, EndPoint) bereit.
EndSend(IAsyncResult)	Beendet einen ausstehenden asynchronen Sendevorgang.
EndSend(IAsyncResult, SocketError)	Beendet einen ausstehenden asynchronen Sendevorgang.
EndSendFile(IAsyncResult)	Beendet ein ausstehendes asynchrones Senden einer Datei.
EndSendTo(IAsyncResult)	Beendet einen ausstehenden asynchronen Sendevorgang an einen bestimmten Zielort.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Finalize()	Gibt von der Socket-Klasse verwendete Ressourcen frei.
GetHashCode()	Gibt einen Hashwert für eine Socket-Instanz zurück.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetRawSocketOption(Int32, Int32, Span<Byte>)	Ruft einen Socketoptionswert unter Verwendung plattformspezifischer Ebenen- und Namensbezeichner ab.
GetSocketOption(SocketOptionLevel, SocketOptionName)	Gibt den Wert einer angegebenen, als Objekt dargestellten Socket-Option zurück.
GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])	Gibt die angegebene Socket-Optionseinstellung als Bytearray dargestellt zurück.
GetSocketOption(SocketOptionLevel, SocketOptionName, Int32)	Gibt den Wert der angegebenen Socket-Option in einem Array zurück.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
IOControl(Int32, Byte[], Byte[])	Legt mit numerischen Steuerungscodes die Betriebsmodi niedriger Ebene für den Socket fest.
IOControl(IOControlCode, Byte[], Byte[])	Legt mithilfe der Socket-Enumeration zum Angeben von Steuerungscodes Betriebsmodi niedriger Ebene für den IOControlCode fest.
Listen()	Versetzt einen Socket in den Überwachungszustand.
Listen(Int32)	Versetzt einen Socket in den Überwachungszustand.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Poll(Int32, SelectMode)	Bestimmt den Status des Socket.
Receive(Byte[])	Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer.
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.
Receive(Byte[], Int32, Int32, SocketFlags, SocketError)	Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
Receive(Byte[], Int32, SocketFlags)	Empfängt die angegebene Anzahl von Datenbytes aus einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
Receive(Byte[], SocketFlags)	Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
Receive(IList<ArraySegment<Byte>>)	Empfängt Daten von einem gebundenen Socket und fügt sie in die Liste der Empfangspuffer ein.
Receive(IList<ArraySegment<Byte>>, SocketFlags)	Empfängt Daten von einem gebundenen Socket in der Liste der Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError)	Empfängt Daten von einem gebundenen Socket in der Liste der Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
Receive(Span<Byte>)	Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer.
Receive(Span<Byte>, SocketFlags)	Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
Receive(Span<Byte>, SocketFlags, SocketError)	Empfängt Daten von einem gebundenen Socket in einem Empfangspuffer, wobei die angegebenen SocketFlags verwendet werden.
ReceiveAsync(ArraySegment<Byte>, SocketFlags)	Empfängt Daten aus einem verbundenen Socket.
ReceiveAsync(IList<ArraySegment<Byte>>, SocketFlags)	Empfängt Daten aus einem verbundenen Socket.
ReceiveAsync(Memory<Byte>, SocketFlags, CancellationToken)	Empfängt Daten aus einem verbundenen Socket.
ReceiveAsync(SocketAsyncEventArgs)	Startet eine asynchrone Anforderung, um Daten von einem verbundenen Socket-Objekt zu empfangen.
ReceiveFrom(Byte[], EndPoint)	Empfängt ein Datagramm im Datenpuffer und speichert den Endpunkt.
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.
ReceiveFrom(Byte[], Int32, SocketFlags, EndPoint)	Empfängt mithilfe der angegebenen SocketFlags die angegebene Anzahl von Bytes im Datenpuffer und speichert den Endpunkt.
ReceiveFrom(Byte[], SocketFlags, EndPoint)	Empfängt mithilfe der angegebenen SocketFlags ein Datagramm im Datenpuffer und speichert den Endpunkt.
ReceiveFrom(Span<Byte>, EndPoint)	Empfängt ein Datagramm im Datenpuffer und speichert den Endpunkt.
ReceiveFrom(Span<Byte>, SocketFlags, EndPoint)	Empfängt mithilfe der angegebenen SocketFlags ein Datagramm im Datenpuffer und speichert den Endpunkt.
ReceiveFromAsync(ArraySegment<Byte>, SocketFlags, EndPoint)	Empfängt Daten und gibt den Endpunkt des sendenden Hosts zurück.
ReceiveFromAsync(Memory<Byte>, SocketFlags, EndPoint, CancellationToken)	Empfängt Daten und gibt den Endpunkt des sendenden Hosts zurück.
ReceiveFromAsync(SocketAsyncEventArgs)	Beginnt den asynchronen Datenempfang aus dem angegebenen Netzwerkgerät.
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.
ReceiveMessageFrom(Span<Byte>, 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.
ReceiveMessageFromAsync(ArraySegment<Byte>, SocketFlags, EndPoint)	Empfängt Daten und gibt zusätzliche Informationen zum Absender der Nachricht zurück.
ReceiveMessageFromAsync(Memory<Byte>, SocketFlags, EndPoint, CancellationToken)	Empfängt Daten und gibt zusätzliche Informationen zum Absender der Nachricht zurück.
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.
Select(IList, IList, IList, Int32)	Bestimmt den Status von einem oder mehreren Sockets.
Send(Byte[])	Sendet Daten an einen verbundenen Socket.
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.
Send(Byte[], Int32, Int32, SocketFlags, SocketError)	Sendet die angegebene Anzahl von Datenbytes an einen verbundenen Socket, beginnend bei einem angegebenen Offset und unter Verwendung der angegebenen SocketFlags.
Send(Byte[], Int32, SocketFlags)	Sendet die angegebene Anzahl von Datenbytes an einen verbundenen Socket, wobei die angegebenen SocketFlags verwendet werden.
Send(Byte[], SocketFlags)	Sendet Daten mithilfe der angegebenen Socket an einen verbundenen SocketFlags.
Send(IList<ArraySegment<Byte>>)	Sendet den Satz der Puffer in der Liste an einen verbundenen Socket.
Send(IList<ArraySegment<Byte>>, SocketFlags)	Sendet den Satz von Puffern in der Liste unter Verwendung der angegebenen Socket an einen verbundenen SocketFlags.
Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError)	Sendet den Satz von Puffern in der Liste unter Verwendung der angegebenen Socket an einen verbundenen SocketFlags.
Send(ReadOnlySpan<Byte>)	Sendet Daten an einen verbundenen Socket.
Send(ReadOnlySpan<Byte>, SocketFlags)	Sendet Daten mithilfe der angegebenen Socket an einen verbundenen SocketFlags.
Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)	Sendet Daten mithilfe der angegebenen Socket an einen verbundenen SocketFlags.
SendAsync(ArraySegment<Byte>, SocketFlags)	Sendet Daten an einen verbundenen Socket.
SendAsync(IList<ArraySegment<Byte>>, SocketFlags)	Sendet Daten an einen verbundenen Socket.
SendAsync(ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)	Sendet Daten an einen verbundenen Socket.
SendAsync(SocketAsyncEventArgs)	Sendet Daten asynchron an ein verbundenes Socket-Objekt.
SendFile(String)	Sendet die Datei `fileName` mit dem Socket-Übertragungsflag an ein verbundenes UseDefaultWorkerThread-Objekt.
SendFile(String, Byte[], Byte[], TransmitFileOptions)	Sendet die Datei `fileName` und puffert Daten mit dem angegebenen TransmitFileOptions-Wert in einem verbundenen Socket-Objekt.
SendFile(String, ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, TransmitFileOptions)	Sendet die Datei `fileName` und puffert Daten mit dem angegebenen TransmitFileOptions-Wert in einem verbundenen Socket-Objekt.
SendFileAsync(String, CancellationToken)	Sendet die Datei `fileName` an ein verbundenes Socket Objekt.
SendFileAsync(String, ReadOnlyMemory<Byte>, ReadOnlyMemory<Byte>, TransmitFileOptions, CancellationToken)	Sendet die Datei `fileName` und puffert Daten mit dem angegebenen TransmitFileOptions-Wert in einem verbundenen Socket-Objekt.
SendPacketsAsync(SocketAsyncEventArgs)	Sendet eine Auflistung von Dateien oder Datenpuffern im Speicher asynchron an ein verbundenes Socket-Objekt.
SendTo(Byte[], EndPoint)	Sendet Daten an den angegebenen Endpunkt.
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.
SendTo(Byte[], Int32, SocketFlags, EndPoint)	Sendet die angegebene Anzahl von Datenbytes an den angegebenen Endpunkt, wobei die angegebenen SocketFlags verwendet werden.
SendTo(Byte[], SocketFlags, EndPoint)	Sendet Daten an einen bestimmten Endpunkt unter Verwendung der angegebenen SocketFlags.
SendTo(ReadOnlySpan<Byte>, EndPoint)	Sendet Daten an den angegebenen Endpunkt.
SendTo(ReadOnlySpan<Byte>, SocketFlags, EndPoint)	Sendet Daten an einen bestimmten Endpunkt unter Verwendung der angegebenen SocketFlags.
SendToAsync(ArraySegment<Byte>, SocketFlags, EndPoint)	Sendet Daten an den angegebenen Remotehost.
SendToAsync(ReadOnlyMemory<Byte>, SocketFlags, EndPoint, CancellationToken)	Sendet Daten an den angegebenen Remotehost.
SendToAsync(SocketAsyncEventArgs)	Sendet asynchron Daten an einen angegebenen Remotehost.
SetIPProtectionLevel(IPProtectionLevel)	Legt die IP-Schutzebene für einen Socket fest.
SetRawSocketOption(Int32, Int32, ReadOnlySpan<Byte>)	Legt einen Socketoptionswert unter Verwendung plattformspezifischer Ebenen- und Namensbezeichner fest.
SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean)	Legt die angegebene Socket-Option auf den angegebenen Boolean-Wert fest.
SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])	Legt die angegebene Socket-Option auf den angegebenen, als Bytearray dargestellten Wert fest.
SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)	Legt die angegebene Socket-Option auf den angegebenen ganzzahligen Wert fest.
SetSocketOption(SocketOptionLevel, SocketOptionName, Object)	Legt die angegebene Socket-Option auf den angegebenen, als Objekt dargestellten Wert fest.
Shutdown(SocketShutdown)	Deaktiviert Senden und Empfangen für einen Socket.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht.

Gibt alle vom Socket verwendeten Ressourcen frei.

Erweiterungsmethoden

AcceptAsync(Socket)	Führt einen asynchronen Vorgang aus, um einen eingehenden Verbindungsversuch auf dem Socket anzunehmen.
AcceptAsync(Socket, Socket)	Führt einen asynchronen Vorgang aus, um einen eingehenden Verbindungsversuch auf dem Socket anzunehmen.
ConnectAsync(Socket, EndPoint)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(Socket, EndPoint, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her.
ConnectAsync(Socket, IPAddress, Int32)	Stellt eine Verbindung mit einem Remotehost her. Der Host wird mit einer IP-Adresse und einer Portnummer angegeben.
ConnectAsync(Socket, IPAddress, Int32, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her, der durch eine IP-Adresse und eine Portnummer angegeben wird.
ConnectAsync(Socket, IPAddress[], Int32)	Stellt eine Verbindung mit einem Remotehost her. Der Host wird durch ein Array von IP-Adressen und eine Portnummer angegeben.
ConnectAsync(Socket, IPAddress[], Int32, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her, der durch ein Array von IP-Adressen und eine Portnummer angegeben wird.
ConnectAsync(Socket, String, Int32)	Stellt eine Verbindung mit einem Remotehost her. Der Host wird durch einen Hostnamen und eine Portnummer angegeben.
ConnectAsync(Socket, String, Int32, CancellationToken)	Stellt eine Verbindung mit einem Remotehost her, der durch einen Hostnamen und eine Portnummer angegeben wird.
ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags)	Empfängt Daten aus einem verbundenen Socket.
ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)	Empfängt Daten aus einem verbundenen Socket.
ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken)	Empfängt Daten aus einem verbundenen Socket.
ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)	Empfängt Daten von einem angegebenen Netzwerkgerät.
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.
SendAsync(Socket, ArraySegment<Byte>, SocketFlags)	Sendet Daten an einen verbundenen Socket.
SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)	Sendet Daten an einen verbundenen Socket.
SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)	Sendet Daten an einen verbundenen Socket.
SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)	Sendet asynchron Daten an einen angegebenen Remotehost.

Gilt für

Threadsicherheit

Instanzen dieser Klasse sind threadsicher.