Socket Classe

Définition

Espace de noms:: System.Net.Sockets

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

Assembly:: System.dll

Assembly:: System.Net.Sockets.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Implémente l’interface de sockets Berkeley.

public ref class Socket : IDisposable

public class Socket : IDisposable

type Socket = class
    interface IDisposable

Public Class Socket
Implements IDisposable

Héritage: Object
Socket

Implémente: IDisposable

Exemples

L’exemple suivant montre comment la Socket classe peut être utilisée pour envoyer des données à un serveur HTTP, en imprimant la réponse ASCII à la sortie standard. Cet exemple montre comment bloquer le thread appelant jusqu’à ce que la page entière soit reçue.

private static void SendHttpRequest(Uri? uri = null, int port = 80)
{
    uri ??= new Uri("http://example.com");

    // Construct a minimalistic HTTP/1.1 request
    byte[] requestBytes = Encoding.ASCII.GetBytes(@$"GET {uri.AbsoluteUri} HTTP/1.0
Host: {uri.Host}
Connection: Close

");

    // Create and connect a dual-stack socket
    using Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
    socket.Connect(uri.Host, port);

    // Send the request.
    // For the tiny amount of data in this example, the first call to Send() will likely deliver the buffer completely,
    // however this is not guaranteed to happen for larger real-life buffers.
    // The best practice is to iterate until all the data is sent.
    int bytesSent = 0;
    while (bytesSent < requestBytes.Length)
    {
        bytesSent += socket.Send(requestBytes, bytesSent, requestBytes.Length - bytesSent, SocketFlags.None);
    }

    // Do minimalistic buffering assuming ASCII response
    byte[] responseBytes = new byte[256];
    char[] responseChars = new char[256];

    while (true)
    {
        int bytesReceived = socket.Receive(responseBytes);

        // Receiving 0 bytes means EOF has been reached
        if (bytesReceived == 0) break;

        // Convert byteCount bytes to ASCII characters using the 'responseChars' buffer as destination
        int charCount = Encoding.ASCII.GetChars(responseBytes, 0, bytesReceived, responseChars, 0);

        // Print the contents of the 'responseChars' buffer to Console.Out
        Console.Out.Write(responseChars, 0, charCount);
    }
}

L’exemple suivant illustre le même scénario HTTP GET, à l’aide d’API asynchrones basées sur des tâches, tout en transférant une CancellationToken vers les méthodes asynchrones, ce qui rend l’opération entière annulable.

Tip

Socketles méthodes asynchrones qui ne retournent généralement pas un CancellationToken Task, qui est alloué sur le tas. Les surcharges pouvant être annulées sont toujours ValueTaskretournées ; l’utilisation de ces surcharges permet de réduire les allocations dans du code hautes performances.

private static async Task SendHttpRequestAsync(Uri? uri = null, int port = 80, CancellationToken cancellationToken = default)
{
    uri ??= new Uri("http://example.com");

    // Construct a minimalistic HTTP/1.1 request
    byte[] requestBytes = Encoding.ASCII.GetBytes(@$"GET {uri.AbsoluteUri} HTTP/1.1
Host: {uri.Host}
Connection: Close

");

    // Create and connect a dual-stack socket
    using Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
    await socket.ConnectAsync(uri.Host, port, cancellationToken);

    // Send the request.
    // For the tiny amount of data in this example, the first call to SendAsync() will likely deliver the buffer completely,
    // however this is not guaranteed to happen for larger real-life buffers.
    // The best practice is to iterate until all the data is sent.
    int bytesSent = 0;
    while (bytesSent < requestBytes.Length)
    {
        bytesSent += await socket.SendAsync(requestBytes.AsMemory(bytesSent), SocketFlags.None);
    }

    // Do minimalistic buffering assuming ASCII response
    byte[] responseBytes = new byte[256];
    char[] responseChars = new char[256];

    while (true)
    {
        int bytesReceived = await socket.ReceiveAsync(responseBytes, SocketFlags.None, cancellationToken);

        // Receiving 0 bytes means EOF has been reached
        if (bytesReceived == 0) break;

        // Convert byteCount bytes to ASCII characters using the 'responseChars' buffer as destination
        int charCount = Encoding.ASCII.GetChars(responseBytes, 0, bytesReceived, responseChars, 0);

        // Print the contents of the 'responseChars' buffer to Console.Out
        await Console.Out.WriteAsync(responseChars.AsMemory(0, charCount), cancellationToken);
    }
}

Remarques

Pour plus d’informations sur cette API, consultez les remarques d’API supplémentaires pour Socket.

Constructeurs

Nom	Description
Socket(AddressFamily, SocketType, ProtocolType)	Initialise une nouvelle instance de la Socket classe à l’aide de la famille d’adresses, du type de socket et du protocole spécifiés.
Socket(SocketInformation)	Initialise une nouvelle instance de la Socket classe à l’aide de la valeur spécifiée retournée par DuplicateAndClose(Int32).
Socket(SocketType, ProtocolType)	Initialise une nouvelle instance de la Socket classe à l’aide du type et du protocole de socket spécifiés. Si le système d’exploitation prend en charge IPv6, ce constructeur crée un socket double mode ; sinon, il crée un socket IPv4.

Propriétés

Nom	Description
AddressFamily	Obtient la famille d’adresses du Socket.
Available	Obtient la quantité de données qui ont été reçues du réseau et qui sont disponibles pour être lues.
Blocking	Obtient ou définit une valeur qui indique si l’objet Socket est en mode bloquant.
Connected	Obtient une valeur qui indique si un Socket hôte distant est connecté à partir de la dernière Send ou Receive de l’opération.
DontFragment	Obtient ou définit une valeur qui spécifie si les Socket datagrammes de protocole Internet (IP) peuvent être fragmentés.
DualMode	Obtient ou définit une valeur qui spécifie si le Socket socket en mode double est utilisé pour IPv4 et IPv6.
EnableBroadcast	Obtient ou définit une Boolean valeur qui spécifie si le Socket conteneur peut envoyer des paquets de diffusion.
ExclusiveAddressUse	Obtient ou définit une valeur qui indique si le Socket seul processus autorise la liaison à un port.
Handle	Obtient le handle du système d’exploitation pour le Socket.
IsBound	Obtient une valeur qui indique si l’objet Socket est lié à un port local spécifique.
LingerState	Obtient ou définit une valeur qui spécifie si le Socket délai de fermeture d’un socket dans une tentative d’envoi de toutes les données en attente.
LocalEndPoint	Obtient le point de terminaison local.
MulticastLoopback	Obtient ou définit une valeur qui spécifie si les paquets de multidiffusion sortants sont remis à l’application d’envoi.
NoDelay	Obtient ou définit une Boolean valeur qui spécifie si le flux Socket utilise l’algorithme Nagle.
OSSupportsIPv4	Indique si le système d’exploitation et les adaptateurs réseau sous-jacents prennent en charge le protocole Internet version 4 (IPv4).
OSSupportsIPv6	Indique si le système d’exploitation et les adaptateurs réseau sous-jacents prennent en charge le protocole Internet version 6 (IPv6).
ProtocolType	Obtient le type de protocole du Socket.
ReceiveBufferSize	Obtient ou définit une valeur qui spécifie la taille de la mémoire tampon de réception du Socket.
ReceiveTimeout	Obtient ou définit une valeur qui spécifie la durée après laquelle un appel synchrone Receive expire.
RemoteEndPoint	Obtient le point de terminaison distant.
SendBufferSize	Obtient ou définit une valeur qui spécifie la taille de la mémoire tampon d’envoi du Socket.
SendTimeout	Obtient ou définit une valeur qui spécifie la durée après laquelle un appel synchrone Send expire.
SocketType	Obtient le type du Socket.
SupportsIPv4	Obsolète. Obsolète. Obtient une valeur indiquant si la prise en charge IPv4 est disponible et activée sur l’hôte actuel.
SupportsIPv6	Obsolète. Obsolète. Obtient une valeur qui indique si le framework prend en charge IPv6 pour certains membres obsolètes Dns .
Ttl	Obtient ou définit une valeur qui spécifie la valeur durée de vie (TTL) des paquets IP (Internet Protocol) envoyés par le Socket.
UseOnlyOverlappedIO	Obtient ou définit une valeur qui spécifie si le socket doit utiliser uniquement le mode D/S superposé. Sur .NET 5+ (y compris les versions .NET Core), la valeur est toujours `false`.

Méthodes

Nom	Description
Accept()	Crée une Socket nouvelle connexion pour une connexion nouvellement créée.
AcceptAsync(SocketAsyncEventArgs)	Commence une opération asynchrone pour accepter une tentative de connexion entrante.
BeginAccept(AsyncCallback, Object)	Commence une opération asynchrone pour accepter une tentative de connexion entrante.
BeginAccept(Int32, AsyncCallback, Object)	Commence une opération asynchrone pour accepter une tentative de connexion entrante et reçoit le premier bloc de données envoyé par l’application cliente.
BeginAccept(Socket, Int32, AsyncCallback, Object)	Commence une opération asynchrone pour accepter une tentative de connexion entrante à partir d’un socket spécifié et reçoit le premier bloc de données envoyé par l’application cliente.
BeginConnect(EndPoint, AsyncCallback, Object)	Commence une demande asynchrone pour une connexion hôte distante.
BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Commence une demande asynchrone pour une connexion hôte distante. L’hôte est spécifié par un IPAddress numéro de port et un numéro de port.
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Commence une demande asynchrone pour une connexion hôte distante. L’hôte est spécifié par un IPAddress tableau et un numéro de port.
BeginConnect(String, Int32, AsyncCallback, Object)	Commence une demande asynchrone pour une connexion hôte distante. L’hôte est spécifié par un nom d’hôte et un numéro de port.
BeginDisconnect(Boolean, AsyncCallback, Object)	Commence une requête asynchrone pour se déconnecter d’un point de terminaison distant.
BeginReceive(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)	Commence à recevoir de manière asynchrone des données à partir d’un objet connecté Socket.
BeginReceive(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)	Commence à recevoir de manière asynchrone des données à partir d’un objet connecté Socket.
BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)	Commence à recevoir de manière asynchrone des données à partir d’un objet connecté Socket.
BeginReceive(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)	Commence à recevoir de manière asynchrone des données à partir d’un objet connecté Socket.
BeginReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)	Commence à recevoir de façon asynchrone des données à partir d’un appareil réseau spécifié.
BeginReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)	Commence à recevoir de façon asynchrone le nombre spécifié d’octets de données à l’emplacement spécifié de la mémoire tampon de données, à l’aide du point de terminaison et des informations de paquet spécifiées SocketFlags.
BeginSend(Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object)	Envoie des données de manière asynchrone à un connecté Socket.
BeginSend(Byte[], Int32, Int32, SocketFlags, SocketError, AsyncCallback, Object)	Envoie des données de manière asynchrone à un connecté Socket.
BeginSend(IList<ArraySegment<Byte>>, SocketFlags, AsyncCallback, Object)	Envoie des données de manière asynchrone à un connecté Socket.
BeginSend(IList<ArraySegment<Byte>>, SocketFlags, SocketError, AsyncCallback, Object)	Envoie des données de manière asynchrone à un connecté Socket.
BeginSendFile(String, AsyncCallback, Object)	Envoie le fichier `fileName` à un objet connecté Socket à l’aide de l’indicateur UseDefaultWorkerThread .
BeginSendFile(String, Byte[], Byte[], TransmitFileOptions, AsyncCallback, Object)	Envoie un fichier et des mémoires tampons de données de manière asynchrone à un objet connecté Socket .
BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object)	Envoie des données de manière asynchrone à un hôte distant spécifique.
Bind(EndPoint)	Associe un Socket point de terminaison local.
CancelConnectAsync(SocketAsyncEventArgs)	Annule une demande asynchrone pour une connexion hôte distante.
Close()	Ferme la Socket connexion et libère toutes les ressources associées.
Close(Int32)	Ferme la Socket connexion et libère toutes les ressources associées avec un délai d’expiration spécifié pour permettre l’envoi de données en file d’attente.
Connect(EndPoint)	Établit une connexion à un hôte distant.
Connect(IPAddress, Int32)	Établit une connexion à un hôte distant. L’hôte est spécifié par une adresse IP et un numéro de port.
Connect(IPAddress[], Int32)	Établit une connexion à un hôte distant. L’hôte est spécifié par un tableau d’adresses IP et un numéro de port.
Connect(String, Int32)	Établit une connexion à un hôte distant. L’hôte est spécifié par un nom d’hôte et un numéro de port.
ConnectAsync(SocketAsyncEventArgs)	Commence une requête asynchrone pour une connexion à un hôte distant.
ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs)	Commence une requête asynchrone pour une connexion à un hôte distant.
Disconnect(Boolean)	Ferme la connexion de socket et autorise la réutilisation du socket.
DisconnectAsync(SocketAsyncEventArgs)	Commence une requête asynchrone pour se déconnecter d’un point de terminaison distant.
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la Socket classe.
Dispose(Boolean)	Libère les ressources non managées utilisées par le Socket, et supprime éventuellement les ressources gérées.
DuplicateAndClose(Int32)	Dupliquer la référence de socket pour le processus cible et ferme le socket pour ce processus.
EndAccept(Byte[], IAsyncResult)	Accepte de façon asynchrone une tentative de connexion entrante et crée un Socket objet pour gérer la communication de l’hôte distant. Cette méthode retourne une mémoire tampon qui contient les données initiales transférées.
EndAccept(Byte[], Int32, IAsyncResult)	Accepte de façon asynchrone une tentative de connexion entrante et crée un Socket objet pour gérer la communication de l’hôte distant. Cette méthode retourne une mémoire tampon qui contient les données initiales et le nombre d’octets transférés.
EndAccept(IAsyncResult)	Accepte de façon asynchrone une tentative de connexion entrante et crée un nouveau Socket pour gérer la communication de l’hôte distant.
EndConnect(IAsyncResult)	Termine une demande de connexion asynchrone en attente.
EndDisconnect(IAsyncResult)	Termine une demande de déconnexion asynchrone en attente.
EndReceive(IAsyncResult, SocketError)	Termine une lecture asynchrone en attente.
EndReceive(IAsyncResult)	Termine une lecture asynchrone en attente.
EndReceiveFrom(IAsyncResult, EndPoint)	Met fin à une lecture asynchrone en attente à partir d’un point de terminaison spécifique.
EndReceiveMessageFrom(IAsyncResult, SocketFlags, EndPoint, IPPacketInformation)	Met fin à une lecture asynchrone en attente à partir d’un point de terminaison spécifique. Cette méthode révèle également plus d’informations sur le paquet que EndReceiveFrom(IAsyncResult, EndPoint).
EndSend(IAsyncResult, SocketError)	Met fin à un envoi asynchrone en attente.
EndSend(IAsyncResult)	Met fin à un envoi asynchrone en attente.
EndSendFile(IAsyncResult)	Met fin à un envoi asynchrone en attente d’un fichier.
EndSendTo(IAsyncResult)	Met fin à un envoi asynchrone en attente vers un emplacement spécifique.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Finalize()	Libère les ressources utilisées par la Socket classe.
GetHashCode()	Retourne une valeur de hachage pour une Socket instance.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])	Retourne le paramètre d’option spécifié Socket , représenté sous la forme d’un tableau d’octets.
GetSocketOption(SocketOptionLevel, SocketOptionName, Int32)	Retourne la valeur de l’option spécifiée Socket dans un tableau.
GetSocketOption(SocketOptionLevel, SocketOptionName)	Retourne la valeur d’une option spécifiée Socket , représentée en tant qu’objet.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
IOControl(Int32, Byte[], Byte[])	Définit les modes d’exploitation de bas niveau pour l’utilisation Socket des codes de contrôle numérique.
IOControl(IOControlCode, Byte[], Byte[])	Définit les modes d’exploitation de bas niveau pour l’utilisation de l’énumération Socket IOControlCode pour spécifier des codes de contrôle.
Listen(Int32)	Place un Socket état d’écoute dans un état d’écoute.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
Poll(Int32, SelectMode)	Détermine l’état du Socket.
Receive(Byte[], Int32, Int32, SocketFlags, SocketError)	Reçoit des données d’une limite Socket dans une mémoire tampon de réception, à l’aide de l’élément spécifié SocketFlags.
Receive(Byte[], Int32, Int32, SocketFlags)	Reçoit le nombre spécifié d’octets d’une limite Socket à la position de décalage spécifiée de la mémoire tampon de réception, à l’aide de l’objet spécifié SocketFlags.
Receive(Byte[], Int32, SocketFlags)	Reçoit le nombre spécifié d’octets de données d’une limite Socket dans une mémoire tampon de réception, à l’aide de l’objet spécifié SocketFlags.
Receive(Byte[], SocketFlags)	Reçoit des données d’une limite Socket dans une mémoire tampon de réception, à l’aide de l’élément spécifié SocketFlags.
Receive(Byte[])	Reçoit des données d’une limite Socket dans une mémoire tampon de réception.
Receive(IList<ArraySegment<Byte>>, SocketFlags, SocketError)	Reçoit des données d’une limite Socket dans la liste des mémoires tampons de réception, à l’aide de l’élément spécifié SocketFlags.
Receive(IList<ArraySegment<Byte>>, SocketFlags)	Reçoit des données d’une limite Socket dans la liste des mémoires tampons de réception, à l’aide de l’élément spécifié SocketFlags.
Receive(IList<ArraySegment<Byte>>)	Reçoit des données d’une limite Socket dans la liste des mémoires tampons de réception.
Receive(Span<Byte>, SocketFlags, SocketError)	Reçoit des données d’une limite Socket dans une mémoire tampon de réception, à l’aide de l’élément spécifié SocketFlags.
Receive(Span<Byte>, SocketFlags)	Reçoit des données d’une limite Socket dans une mémoire tampon de réception, à l’aide de l’élément spécifié SocketFlags.
Receive(Span<Byte>)	Reçoit des données d’une limite Socket dans une mémoire tampon de réception.
ReceiveAsync(SocketAsyncEventArgs)	Commence une requête asynchrone pour recevoir des données d’un objet connecté Socket .
ReceiveFrom(Byte[], EndPoint)	Reçoit un datagramme dans la mémoire tampon de données et stocke le point de terminaison.
ReceiveFrom(Byte[], Int32, Int32, SocketFlags, EndPoint)	Reçoit le nombre spécifié d’octets de données dans l’emplacement spécifié de la mémoire tampon de données, à l’aide du point de terminaison spécifié SocketFlagset stocke le point de terminaison.
ReceiveFrom(Byte[], Int32, SocketFlags, EndPoint)	Reçoit le nombre spécifié d’octets dans la mémoire tampon de données, à l’aide du point de terminaison spécifié SocketFlagset stocke le point de terminaison.
ReceiveFrom(Byte[], SocketFlags, EndPoint)	Reçoit un datagramme dans la mémoire tampon de données, à l’aide du point de terminaison spécifié SocketFlagset stocke le point de terminaison.
ReceiveFromAsync(SocketAsyncEventArgs)	Commence à recevoir de façon asynchrone des données à partir d’un appareil réseau spécifié.
ReceiveMessageFrom(Byte[], Int32, Int32, SocketFlags, EndPoint, IPPacketInformation)	Reçoit le nombre spécifié d’octets de données dans l’emplacement spécifié de la mémoire tampon de données, en utilisant le point de terminaison et les informations de paquet.SocketFlags
ReceiveMessageFromAsync(SocketAsyncEventArgs)	Commence à recevoir de manière asynchrone le nombre spécifié d’octets de données dans l’emplacement spécifié dans la mémoire tampon de données, à l’aide du point de terminaison et des informations de paquet spécifiées SocketFlags.
Select(IList, IList, IList, Int32)	Détermine l’état d’un ou plusieurs sockets.
Send(Byte[], Int32, Int32, SocketFlags, SocketError)	Envoie le nombre spécifié d’octets de données à un décalage connecté Socket, en commençant au décalage spécifié et en utilisant le paramètre spécifié SocketFlags.
Send(Byte[], Int32, Int32, SocketFlags)	Envoie le nombre spécifié d’octets de données à un décalage connecté Socket, en commençant au décalage spécifié et en utilisant le paramètre spécifié SocketFlags.
Send(Byte[], Int32, SocketFlags)	Envoie le nombre spécifié d’octets de données à un objet connecté Socketà l’aide de l’objet spécifié SocketFlags.
Send(Byte[], SocketFlags)	Envoie des données à un connecté Socket à l’aide du fichier spécifié SocketFlags.
Send(Byte[])	Envoie des données à un objet connecté Socket.
Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError)	Envoie l’ensemble de mémoires tampons de la liste à un objet connecté Socket, à l’aide de l’objet spécifié SocketFlags.
Send(IList<ArraySegment<Byte>>, SocketFlags)	Envoie l’ensemble de mémoires tampons de la liste à un objet connecté Socket, à l’aide de l’objet spécifié SocketFlags.
Send(IList<ArraySegment<Byte>>)	Envoie l’ensemble de mémoires tampons de la liste à un objet connecté Socket.
Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)	Envoie des données à un connecté Socket à l’aide du fichier spécifié SocketFlags.
Send(ReadOnlySpan<Byte>, SocketFlags)	Envoie des données à un connecté Socket à l’aide du fichier spécifié SocketFlags.
Send(ReadOnlySpan<Byte>)	Envoie des données à un objet connecté Socket.
SendAsync(SocketAsyncEventArgs)	Envoie des données de manière asynchrone à un objet connecté Socket .
SendFile(String, Byte[], Byte[], TransmitFileOptions)	Envoie le fichier `fileName` et les mémoires tampons de données à un objet connecté Socket à l’aide de la valeur spécifiée TransmitFileOptions .
SendFile(String)	Envoie le fichier `fileName` à un objet connecté Socket avec l’indicateur UseDefaultWorkerThread de transmission.
SendPacketsAsync(SocketAsyncEventArgs)	Envoie une collection de fichiers ou dans des mémoires tampons de données de manière asynchrone à un objet connecté Socket .
SendTo(Byte[], EndPoint)	Envoie des données au point de terminaison spécifié.
SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)	Envoie le nombre spécifié d’octets de données au point de terminaison spécifié, en commençant à l’emplacement spécifié dans la mémoire tampon et en utilisant le point de terminaison spécifié SocketFlags.
SendTo(Byte[], Int32, SocketFlags, EndPoint)	Envoie le nombre spécifié d’octets de données au point de terminaison spécifié à l’aide de l’objet spécifié SocketFlags.
SendTo(Byte[], SocketFlags, EndPoint)	Envoie des données à un point de terminaison spécifique à l’aide de l’élément spécifié SocketFlags.
SendToAsync(SocketAsyncEventArgs)	Envoie des données de manière asynchrone à un hôte distant spécifique.
SetIPProtectionLevel(IPProtectionLevel)	Définit le niveau de protection IP sur un socket.
SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean)	Définit l’option spécifiée Socket sur la valeur spécifiée Boolean .
SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])	Définit l’option spécifiée Socket sur la valeur spécifiée, représentée sous la forme d’un tableau d’octets.
SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)	Définit l’option spécifiée Socket sur la valeur entière spécifiée.
SetSocketOption(SocketOptionLevel, SocketOptionName, Object)	Définit l’option spécifiée Socket sur la valeur spécifiée, représentée en tant qu’objet.
Shutdown(SocketShutdown)	Désactive les envois et les réceptions sur un Socket.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

Nom	Description
IDisposable.Dispose()	Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code. Libère toutes les ressources utilisées par le Socket.

Nom

Description

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Libère toutes les ressources utilisées par le Socket.

Méthodes d’extension

Nom	Description
AcceptAsync(Socket, Socket)	Effectue une opération asynchrone sur laquelle accepter une tentative de connexion entrante sur le socket.
AcceptAsync(Socket)	Effectue une opération asynchrone sur laquelle accepter une tentative de connexion entrante sur le socket.
ConnectAsync(Socket, EndPoint)	Établit une connexion à un hôte distant.
ConnectAsync(Socket, IPAddress, Int32)	Établit une connexion à un hôte distant. L’hôte est spécifié par une adresse IP et un numéro de port.
ConnectAsync(Socket, IPAddress[], Int32)	Établit une connexion à un hôte distant. L’hôte est spécifié par un tableau d’adresses IP et un numéro de port.
ConnectAsync(Socket, String, Int32)	Établit une connexion à un hôte distant. L’hôte est spécifié par un nom d’hôte et un numéro de port.
ReceiveAsync(Socket, ArraySegment<Byte>, SocketFlags)	Reçoit des données d’un socket connecté.
ReceiveAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)	Reçoit des données d’un socket connecté.
ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken)	Reçoit des données d’un socket connecté.
ReceiveFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)	Reçoit les données d’un appareil réseau spécifié.
ReceiveMessageFromAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)	Reçoit le nombre spécifié d’octets de données dans l’emplacement spécifié de la mémoire tampon de données, en utilisant le point de terminaison et les informations de paquet.SocketFlags
SendAsync(Socket, ArraySegment<Byte>, SocketFlags)	Envoie des données à un socket connecté.
SendAsync(Socket, IList<ArraySegment<Byte>>, SocketFlags)	Envoie des données à un socket connecté.
SendAsync(Socket, ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)	Envoie des données à un socket connecté.
SendToAsync(Socket, ArraySegment<Byte>, SocketFlags, EndPoint)	Envoie des données de manière asynchrone à un hôte distant spécifique.

S’applique à

Cohérence de thread

Il est sûr d’effectuer une opération d’envoi et de réception simultanément sur une Socket instance, mais il n’est pas recommandé d’émettre simultanément plusieurs appels d’envoi ou de réception multiples. Selon l’implémentation de la plateforme sous-jacente, cela peut entraîner un interlacement involontaire des données pour les envois ou réceptions volumineux ou multi-tampons.

Voir aussi

Commentaires

Cette page a-t-elle été utile ?