Socket Classe

Définition

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
Socket
Implémente

Exemples

L’exemple de code suivant montre comment la Socket classe peut être utilisée pour envoyer des données à un serveur http et recevoir la réponse. Cet exemple se bloque jusqu’à la réception de la page entière.

#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

Remarques

La Socket classe fournit un ensemble complet de méthodes et de propriétés pour les communications réseau. La Socket classe vous permet d’effectuer des transferts de données synchrones et asynchrones à l’aide de l’un des protocoles de communication indiqués dans l' ProtocolType énumération.

la Socket classe suit le modèle d’affectation de noms .NET Framework pour les méthodes asynchrones. Par exemple, la Receive méthode synchrone correspond aux BeginReceive méthodes et asynchrones EndReceive .

Si votre application n’a besoin que d’un seul thread au cours de l’exécution, utilisez les méthodes suivantes, qui sont conçues pour le mode de fonctionnement synchrone.

  • Si vous utilisez un protocole orienté connexion, tel que TCP, votre serveur peut écouter les connexions à l’aide de la Listen méthode. La Accept méthode traite toutes les demandes de connexion entrantes et retourne un Socket que vous pouvez utiliser pour communiquer des données avec l’hôte distant. Utilisez ce retourné Socket pour appeler la Send Receive méthode ou. Appelez la Bind méthode avant d’appeler la Listen méthode si vous souhaitez spécifier l’adresse IP locale et le numéro de port. Utilisez un numéro de port égal à zéro si vous souhaitez que le fournisseur de services sous-jacent affecte un port gratuit pour vous. Si vous souhaitez vous connecter à un hôte d’écoute, appelez la Connect méthode. Pour communiquer des données, appelez Send la Receive méthode ou.

  • Si vous utilisez un protocole sans connexion, tel que UDP, vous n’avez pas besoin d’écouter les connexions. Appelez la ReceiveFrom méthode pour accepter tous les datagrammes entrants. Utilisez la SendTo méthode pour envoyer des datagrammes à un hôte distant.

Pour traiter les communications à l’aide de threads distincts au cours de l’exécution, utilisez les méthodes suivantes, qui sont conçues pour le mode d’opération asynchrone.

Si vous effectuez plusieurs opérations asynchrones sur un socket, elles ne se terminent pas nécessairement dans l’ordre dans lequel elles sont démarrées.

Lorsque vous avez terminé d’envoyer et de recevoir des données, utilisez la Shutdown méthode pour désactiver le Socket . Après l’appel de Shutdown , appelez la Close méthode pour libérer toutes les ressources associées au Socket .

La Socket classe vous permet de configurer votre Socket à l’aide de la SetSocketOption méthode. Récupérez ces paramètres à l’aide de la GetSocketOption méthode.

Notes

Si vous écrivez une application relativement simple et que vous n’avez pas besoin de performances maximales, envisagez d’utiliser TcpClient , TcpListener et UdpClient . Ces classes fournissent une interface plus simple et plus conviviale aux Socket communications.

Constructeurs

Socket(AddressFamily, SocketType, ProtocolType)

Initialise une nouvelle instance de la classe Socket en utilisant la famille d'adresses, le type de socket et le protocole spécifiés.

Socket(SafeSocketHandle)

Initialise une nouvelle instance de la classe Socket pour le handle de socket spécifié.

Socket(SocketInformation)

Initialise une nouvelle instance de la classe Socket avec la valeur spécifiée retournée par DuplicateAndClose(Int32).

Socket(SocketType, ProtocolType)

Initialise une nouvelle instance de la classe Socket à l'aide du type de socket et du protocole spécifiés. Si le système d’exploitation prend en charge le protocole IPv6, ce constructeur crée un socket en mode double ; dans le cas contraire, il crée un socket IPv4.

Propriétés

AddressFamily

Obtient la famille d'adresses de Socket.

Available

Obtient la quantité de données reçues du réseau et disponibles pour la lecture.

Blocking

Obtient ou définit une valeur qui indique si Socket est en mode blocage.

Connected

Obtient une valeur qui indique si Socket est connecté à un hôte distant depuis la dernière opération Send ou Receive.

DontFragment

Récupère ou définit une valeur qui spécifie si Socket autorise la fragmentation des datagrammes IP (protocole Internet).

DualMode

Obtient ou définit une valeur qui spécifie si Socket est un socket en mode double utilisé pour IPv4 et IPv6.

EnableBroadcast

Obtient ou définit une valeur Boolean qui spécifie si Socket peut envoyer ou recevoir des paquets de diffusion.

ExclusiveAddressUse

Obtient ou définit une valeur Boolean qui spécifie si Socket n'autorise qu'un seul processus à se lier à un port.

Handle

Obtient le handle du système d'exploitation pour Socket.

IsBound

Obtient une valeur qui indique si Socket est lié à un port local spécifique.

LingerState

Obtient ou définit une valeur qui spécifie si Socket doit différer la fermeture d'un socket lors d'une tentative d'envoi de l'ensemble des données en attente.

LocalEndPoint

Obtient le point de terminaison local.

MulticastLoopback

Obtient ou définit une valeur spécifiant si les paquets multicast sortants sont remis à l'application émettrice.

NoDelay

Obtient ou définit une valeur Boolean spécifiant si le flux de données Socket utilise l'algorithme Nagle.

OSSupportsIPv4

Indique si le système d'exploitation et les cartes réseau sous-jacents prennent en charge le protocole IPv4 (Internet Protocol version 4).

OSSupportsIPv6

Indique si le système d'exploitation et les cartes réseau sous-jacents prennent en charge le protocole IPv6 (Internet Protocol version 6).

OSSupportsUnixDomainSockets

Indique si le système d’exploitation sous-jacent prend en charge les sockets de domaine UNIX.

ProtocolType

Obtient le type de protocole de Socket.

ReceiveBufferSize

Obtient ou définit une valeur spécifiant la taille de la mémoire tampon de réception de Socket.

ReceiveTimeout

Obtient ou définit une valeur spécifiant la durée après laquelle un appel Receive synchrone doit expirer.

RemoteEndPoint

Obtient le point de terminaison distant.

SafeHandle

Obtient un SafeSocketHandle qui représente le descripteur de socket que l’objet Socket actuel encapsule.

SendBufferSize

Obtient ou définit une valeur spécifiant la taille de la mémoire tampon d'envoi de Socket.

SendTimeout

Obtient ou définit une valeur spécifiant la durée après laquelle un appel Send synchrone doit expirer.

SocketType

Obtient le type de Socket.

SupportsIPv4
Obsolète.
Obsolète.
Obsolète.
Obsolète.

Obtient une valeur indiquant si la prise en charge d'IPv4 est disponible et active sur l'hôte en cours.

SupportsIPv6
Obsolète.
Obsolète.
Obsolète.
Obsolète.

Obtient une valeur qui indique si le Framework prend en charge le protocole IPv6 pour certains membres Dns obsolètes.

Ttl

Obtient ou définit une valeur qui spécifie la durée de vie des paquets IP (Internet Protocol) envoyés par Socket.

UseOnlyOverlappedIO
Obsolète.

Obtient ou définit une valeur qui spécifie si le socket doit utiliser uniquement le mode e/s avec chevauchement. Sur .NET 5 + (y compris les versions .NET Core), la valeur est toujours false .

Méthodes

Accept()

Crée un nouveau Socket pour une connexion nouvellement créée.

AcceptAsync()

Accepte une connexion entrante.

AcceptAsync(CancellationToken)

Accepte une connexion entrante.

AcceptAsync(Socket)

Accepte une connexion entrante.

AcceptAsync(Socket, CancellationToken)

Accepte une connexion entrante.

AcceptAsync(SocketAsyncEventArgs)

Démarre une opération asynchrone pour accepter une tentative de connexion entrante.

BeginAccept(AsyncCallback, Object)

Démarre une opération asynchrone pour accepter une tentative de connexion entrante.

BeginAccept(Int32, AsyncCallback, Object)

Lance une opération asynchrone d'acceptation d'une tentative de connexion entrante et reçoit le premier bloc de données envoyé par l'application cliente.

BeginAccept(Socket, Int32, AsyncCallback, Object)

Lance une opération asynchrone d'acceptation d'une tentative de connexion entrante provenant d'un socket spécifié et reçoit le premier bloc de données envoyé par l'application cliente.

BeginConnect(EndPoint, AsyncCallback, Object)

Démarre une demande asynchrone pour une connexion d'hôte distant.

BeginConnect(IPAddress, Int32, AsyncCallback, Object)

Démarre une demande asynchrone pour une connexion d'hôte distant. L’hôte est spécifié par IPAddress et un numéro de port.

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

Démarre une demande asynchrone pour une connexion d'hôte distant. L’hôte est spécifié par un tableau IPAddress et un numéro de port.

BeginConnect(String, Int32, AsyncCallback, Object)

Démarre une demande asynchrone pour une connexion d'hôte distant. L’hôte est spécifié par un nom d’hôte et un numéro de port.

BeginDisconnect(Boolean, AsyncCallback, Object)

Lance une demande asynchrone de déconnexion d'un point de terminaison distant.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.

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

Démarre la réception asynchrone de données à partir d'un périphérique réseau spécifié.

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

Démarre la réception asynchrone du nombre spécifié d’octets de données dans l’emplacement spécifié de la mémoire tampon de données, à l’aide du SocketFlags spécifié et stocke le point de terminaison ainsi que les informations sur le paquet.

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

Envoie des données de façon asynchrone à un Socket connecté.

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

Envoie des données de façon asynchrone à un Socket connecté.

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

Envoie des données de façon asynchrone à un Socket connecté.

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

Envoie des données de façon asynchrone à un Socket connecté.

BeginSendFile(String, AsyncCallback, Object)

Envoie le fichier fileName à un objet Socket connecté à l'aide de l'indicateur UseDefaultWorkerThread.

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

Envoie de façon asynchrone un fichier et des mémoires tampon de données à un objet Socket connecté.

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

Envoie des données de façon asynchrone à un hôte distant spécifique.

Bind(EndPoint)

Associe Socket à un point de terminaison local.

CancelConnectAsync(SocketAsyncEventArgs)

Annule une requête asynchrone pour une connexion d'hôte distant.

Close()

Ferme la connexion Socket et libère toutes les ressources associées.

Close(Int32)

Ferme la connexion Socket et libère toutes les ressources associées avec un délai d’attente spécifié pour permettre l’envoi des 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(EndPoint)

Établit une connexion à un hôte distant.

ConnectAsync(EndPoint, CancellationToken)

Établit une connexion à un hôte distant.

ConnectAsync(IPAddress, Int32)

Établit une connexion à un hôte distant.

ConnectAsync(IPAddress, Int32, CancellationToken)

Établit une connexion à un hôte distant.

ConnectAsync(IPAddress[], Int32)

Établit une connexion à un hôte distant.

ConnectAsync(IPAddress[], Int32, CancellationToken)

Établit une connexion à un hôte distant.

ConnectAsync(SocketAsyncEventArgs)

Démarre une demande asynchrone pour une connexion à un hôte distant.

ConnectAsync(SocketType, ProtocolType, SocketAsyncEventArgs)

Démarre une demande asynchrone pour une connexion à un hôte distant.

ConnectAsync(String, Int32)

Établit une connexion à un hôte distant.

ConnectAsync(String, Int32, CancellationToken)

Établit une connexion à un hôte distant.

Disconnect(Boolean)

Ferme la connexion de socket et autorise la réutilisation du socket.

DisconnectAsync(Boolean, CancellationToken)

Déconnecte un socket connecté de l’hôte distant.

DisconnectAsync(SocketAsyncEventArgs)

Lance une demande asynchrone de déconnexion d'un point de terminaison distant.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe Socket.

Dispose(Boolean)

Libère les ressources non managées utilisées par Socket et supprime éventuellement les ressources managées.

DuplicateAndClose(Int32)

Duplique la référence de socket pour le processus cible et ferme le socket pour ce processus.

EndAccept(Byte[], IAsyncResult)

Accepte de manière asynchrone une tentative de connexion entrante et crée un nouvel objet Socket pour gérer les communications 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 manière asynchrone une tentative de connexion entrante et crée un nouvel objet Socket pour gérer les communications 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 manière asynchrone une tentative de connexion entrante et crée un nouveau Socket pour gérer les communications de l'hôte distant.

EndConnect(IAsyncResult)

Met fin à une demande de connexion asynchrone en attente.

EndDisconnect(IAsyncResult)

Met fin à une demande de déconnexion asynchrone en attente.

EndReceive(IAsyncResult)

Met fin à une lecture asynchrone en attente.

EndReceive(IAsyncResult, SocketError)

Met fin à 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 davantage d'informations sur le paquet que EndReceiveFrom(IAsyncResult, EndPoint).

EndSend(IAsyncResult)

Met fin à un envoi asynchrone en attente.

EndSend(IAsyncResult, SocketError)

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 classe Socket.

GetHashCode()

Retourne une valeur de hachage pour une instance de Socket.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetRawSocketOption(Int32, Int32, Span<Byte>)

Obtient une valeur d’option de socket à l’aide d’identificateurs de nom et de niveau propres à la plateforme.

GetSocketOption(SocketOptionLevel, SocketOptionName)

Retourne la valeur d'une option Socket spécifiée, représentée sous la forme d'un objet.

GetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

Retourne la valeur de l'option Socket spécifiée sous la forme d'un tableau d'octets.

GetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Retourne la valeur de l'option Socket spécifiée dans un tableau.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
IOControl(Int32, Byte[], Byte[])

Définit les modes de fonctionnement de bas niveau de Socket à l'aide de codes de contrôle numériques.

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

Définit les modes de fonctionnement de bas niveau de Socket à l'aide de l'énumération IOControlCode afin de spécifier les codes de contrôle.

Listen()

Met Socket dans un état d'écoute.

Listen(Int32)

Met Socket dans un état d'écoute.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
Poll(Int32, SelectMode)

Détermine l'état de Socket.

Receive(Byte[])

Reçoit les données d'un Socket lié dans une mémoire tampon de réception.

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

Reçoit le nombre spécifié d'octets d'un Socket lié dans la position d'offset spécifiée de la mémoire tampon de réception, à l'aide du SocketFlags spécifié.

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

Reçoit les données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.

Receive(Byte[], Int32, SocketFlags)

Reçoit le nombre spécifié d'octets de données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.

Receive(Byte[], SocketFlags)

Reçoit les données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.

Receive(IList<ArraySegment<Byte>>)

Reçoit les données d'un Socket lié dans la liste des mémoires tampon de réception.

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

Reçoit les données d'un Socket lié dans la liste des mémoires tampon de réception, à l'aide du SocketFlags spécifié.

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

Reçoit les données d'un Socket lié dans la liste des mémoires tampon de réception, à l'aide du SocketFlags spécifié.

Receive(Span<Byte>)

Reçoit les données d'un Socket lié dans une mémoire tampon de réception.

Receive(Span<Byte>, SocketFlags)

Reçoit les données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.

Receive(Span<Byte>, SocketFlags, SocketError)

Reçoit les données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.

ReceiveAsync(ArraySegment<Byte>, SocketFlags)

Reçoit des données à partir d’un socket connecté.

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

Reçoit des données à partir d’un socket connecté.

ReceiveAsync(Memory<Byte>, SocketFlags, CancellationToken)

Reçoit des données à partir d’un socket connecté.

ReceiveAsync(SocketAsyncEventArgs)

Démarre une demande asynchrone pour recevoir les données d'un objet Socket connecté.

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 d’octets de données spécifié dans l’emplacement de la mémoire tampon spécifié à l’aide des SocketFlags et 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 SocketFlags spécifié et stocke le point de terminaison.

ReceiveFrom(Byte[], SocketFlags, EndPoint)

Reçoit un datagramme dans la mémoire tampon de données à l'aide du SocketFlags spécifié et stocke le point de terminaison.

ReceiveFrom(Span<Byte>, EndPoint)

Reçoit un datagramme dans la mémoire tampon de données et stocke le point de terminaison.

ReceiveFrom(Span<Byte>, SocketFlags, EndPoint)

Reçoit un datagramme dans la mémoire tampon de données à l'aide du SocketFlags spécifié et stocke le point de terminaison.

ReceiveFromAsync(ArraySegment<Byte>, SocketFlags, EndPoint)

Reçoit des données et retourne le point de terminaison de l’hôte d’envoi.

ReceiveFromAsync(Memory<Byte>, SocketFlags, EndPoint, CancellationToken)

Reçoit des données et retourne le point de terminaison de l’hôte d’envoi.

ReceiveFromAsync(SocketAsyncEventArgs)

Démarre la réception asynchrone de données à partir d'un périphérique réseau spécifié.

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

Reçoit le nombre d’octets de données spécifié à l’emplacement de la mémoire tampon spécifié à l’aide des SocketFlags spécifiés, puis stocke les informations de paquet et de point de terminaison.

ReceiveMessageFrom(Span<Byte>, SocketFlags, EndPoint, IPPacketInformation)

Reçoit le nombre d’octets de données spécifié à l’emplacement de la mémoire tampon spécifié à l’aide des socketFlags spécifiés, puis stocke les informations de paquet et de point de terminaison.

ReceiveMessageFromAsync(ArraySegment<Byte>, SocketFlags, EndPoint)

Reçoit des données et retourne des informations supplémentaires sur l’expéditeur du message.

ReceiveMessageFromAsync(Memory<Byte>, SocketFlags, EndPoint, CancellationToken)

Reçoit des données et retourne des informations supplémentaires sur l’expéditeur du message.

ReceiveMessageFromAsync(SocketAsyncEventArgs)

Démarre la réception asynchrone du nombre spécifié d'octets de données dans l'emplacement spécifié de la mémoire tampon de données, à l'aide du SocketFlags spécifié et stocke le point de terminaison ainsi que les informations sur le paquet.

Select(IList, IList, IList, Int32)

Détermine l’état d’un ou plusieurs sockets.

Send(Byte[])

Envoie des données à un Socket connecté.

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

Envoie le nombre spécifié d’octets de données à un Socket connecté, à part de l’offset spécifié et avec le SocketFlags spécifié.

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

Envoie le nombre spécifié d’octets de données à un Socket connecté, à part de l’offset spécifié et avec le SocketFlags spécifié.

Send(Byte[], Int32, SocketFlags)

Reçoit le nombre spécifié d'octets de données à un Socket connecté, à l'aide du SocketFlags spécifié.

Send(Byte[], SocketFlags)

Envoie des données à un Socket connecté à l'aide du SocketFlags spécifié.

Send(IList<ArraySegment<Byte>>)

Envoie le jeu de mémoires tampon dans la liste à un Socket connecté.

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

Envoie le jeu de mémoires tampon dans la liste à un Socket connecté, à l'aide du SocketFlags spécifié.

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

Envoie le jeu de mémoires tampon dans la liste à un Socket connecté, à l'aide du SocketFlags spécifié.

Send(ReadOnlySpan<Byte>)

Envoie des données à un Socket connecté.

Send(ReadOnlySpan<Byte>, SocketFlags)

Envoie des données à un Socket connecté à l'aide du SocketFlags spécifié.

Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)

Envoie des données à un Socket connecté à l'aide du SocketFlags spécifié.

SendAsync(ArraySegment<Byte>, SocketFlags)

Envoie des données sur un socket connecté.

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

Envoie des données sur un socket connecté.

SendAsync(ReadOnlyMemory<Byte>, SocketFlags, CancellationToken)

Envoie des données sur un socket connecté.

SendAsync(SocketAsyncEventArgs)

Envoie des données de façon asynchrone à un objet Socket connecté.

SendFile(String)

Envoie le fichier fileName à un objet Socket connecté avec l'indicateur de transmission UseDefaultWorkerThread.

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

Envoie le fileName et les tampons de données du fichier à un objet Socket connecté à l’aide de la valeur TransmitFileOptions spécifiée.

SendFile(String, ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, TransmitFileOptions)

Envoie le fileName et les tampons de données du fichier à un objet Socket connecté à l’aide de la valeur TransmitFileOptions spécifiée.

SendFileAsync(String, CancellationToken)

Envoie le fichier fileName à un Socket objet connecté.

SendFileAsync(String, ReadOnlyMemory<Byte>, ReadOnlyMemory<Byte>, TransmitFileOptions, CancellationToken)

Envoie le fileName et les tampons de données du fichier à un objet Socket connecté à l’aide de la valeur TransmitFileOptions spécifiée.

SendPacketsAsync(SocketAsyncEventArgs)

Envoie une collection de fichiers ou des données mises en mémoire tampon de façon asynchrone à un objet Socket connecté.

SendTo(Byte[], EndPoint)

Envoie les 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 SocketFlags spécifié.

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

Envoie le nombre spécifié d'octets de données au point de terminaison spécifié à l'aide du SocketFlags spécifié.

SendTo(Byte[], SocketFlags, EndPoint)

Envoie des données à un point de terminaison spécifique à l'aide du SocketFlags spécifié.

SendTo(ReadOnlySpan<Byte>, EndPoint)

Envoie les données au point de terminaison spécifié.

SendTo(ReadOnlySpan<Byte>, SocketFlags, EndPoint)

Envoie des données à un point de terminaison spécifique à l'aide du SocketFlags spécifié.

SendToAsync(ArraySegment<Byte>, SocketFlags, EndPoint)

Envoie des données à l’hôte distant spécifié.

SendToAsync(ReadOnlyMemory<Byte>, SocketFlags, EndPoint, CancellationToken)

Envoie des données à l’hôte distant spécifié.

SendToAsync(SocketAsyncEventArgs)

Envoie des données de façon asynchrone à un hôte distant spécifique.

SetIPProtectionLevel(IPProtectionLevel)

Définit le niveau de protection IP sur un Socket.

SetRawSocketOption(Int32, Int32, ReadOnlySpan<Byte>)

Définit une valeur d’option de socket à l’aide d’identificateurs de nom et de niveau propres à la plateforme.

SetSocketOption(SocketOptionLevel, SocketOptionName, Boolean)

Affecte la valeur Socket spécifiée à l'option Boolean spécifiée.

SetSocketOption(SocketOptionLevel, SocketOptionName, Byte[])

Affecte la valeur spécifiée à l'option Socket spécifiée représentée sous la forme d'un tableau d'octets.

SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Affecte la valeur entière spécifiée à l'option Socket spécifiée.

SetSocketOption(SocketOptionLevel, SocketOptionName, Object)

Affecte la valeur spécifiée à l'option Socket spécifiée représentée sous la forme d'un 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

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 Socket.

Méthodes d’extension

AcceptAsync(Socket)

Effectue une opération asynchrone pour accepter une tentative de connexion entrante sur le socket.

AcceptAsync(Socket, Socket)

Effectue une opération asynchrone pour accepter une tentative de connexion entrante sur le socket.

ConnectAsync(Socket, EndPoint)

Établit une connexion à un hôte distant.

ConnectAsync(Socket, EndPoint, CancellationToken)

É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, CancellationToken)

Établit une connexion à un hôte distant, qui 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, IPAddress[], Int32, CancellationToken)

Établit une connexion à un hôte distant, qui 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.

ConnectAsync(Socket, String, Int32, CancellationToken)

Établit une connexion à un hôte distant, qui 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 à partir d’un socket connecté.

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

Reçoit des données à partir d’un socket connecté.

ReceiveAsync(Socket, Memory<Byte>, SocketFlags, CancellationToken)

Reçoit des données à partir d’un socket connecté.

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

Reçoit des données à partir d’un périphérique réseau spécifié.

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

Reçoit le nombre d’octets de données spécifié à l’emplacement de la mémoire tampon spécifié à l’aide des SocketFlags spécifiés, puis stocke les informations de paquet et de point de terminaison.

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 façon asynchrone à un hôte distant spécifique.

S’applique à

Cohérence de thread

Les instances de cette classe sont thread-safe.

Voir aussi