Socket Socket Socket Socket Class

Définition

Implémente l'interface de sockets Berkeley.Implements the Berkeley sockets interface.

public ref class Socket : IDisposable
public class Socket : IDisposable
type Socket = class
    interface IDisposable
Public Class Socket
Implements IDisposable
Héritage
SocketSocketSocketSocket
Implémente

Exemples

Le code suivant montre l’exemple comment la Socket classe peut être utilisée pour envoyer des données à un serveur HTTP et recevoir la réponse.The following code example shows how the Socket class can be used to send data to an HTTP server and receive the response. Cet exemple bloque jusqu'à ce que la page entière est reçue.This example blocks until the entire page is received.

#using <System.dll>

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

   return s;
}

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

   return strRetPage;
}

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

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

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

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

            tempSocket.Connect(ipe);

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

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

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

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

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

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

Imports System
Imports System.Text
Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports Microsoft.VisualBasic

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 'Main
End Class  

Remarques

Le Socket classe fournit un ensemble complet de méthodes et propriétés pour les communications réseau.The Socket class provides a rich set of methods and properties for network communications. Le Socket classe vous permet d’effectuer à la fois synchrone et transfert de données asynchrones à l’aide d’un des protocoles de communication répertoriées dans le ProtocolType énumération.The Socket class allows you to perform both synchronous and asynchronous data transfer using any of the communication protocols listed in the ProtocolType enumeration.

Le Socket classe suit le modèle d’affectation de noms .NET Framework pour les méthodes asynchrones.The Socket class follows the .NET Framework naming pattern for asynchronous methods. Par exemple, synchrones Receive méthode correspond à asynchrone BeginReceive et EndReceive méthodes.For example, the synchronous Receive method corresponds to the asynchronous BeginReceive and EndReceive methods.

Si votre application requiert uniquement un seul thread pendant l’exécution, utilisez les méthodes suivantes, qui sont conçues pour le mode de fonctionnement synchrone.If your application only requires one thread during execution, use the following methods, which are designed for synchronous operation mode.

  • Si vous utilisez un protocole orienté connexion, tels que TCP, votre serveur peut écouter les connexions à l’aide de la Listen (méthode).If you are using a connection-oriented protocol such as TCP, your server can listen for connections using the Listen method. Le Accept méthode traite toute connexion entrante demande et retourne un Socket que vous pouvez utiliser pour communiquer des données avec l’hôte distant.The Accept method processes any incoming connection requests and returns a Socket that you can use to communicate data with the remote host. Utilisez cette retourné Socket pour appeler le Send ou Receive (méthode).Use this returned Socket to call the Send or Receive method. Appelez le Bind méthode avant d’appeler le Listen méthode si vous souhaitez spécifier le numéro d’adresse et le port IP local.Call the Bind method prior to calling the Listen method if you want to specify the local IP address and port number. Utiliser un numéro de port zéro si vous souhaitez que le fournisseur de services sous-jacent pour affecter un port disponible pour vous.Use a port number of zero if you want the underlying service provider to assign a free port for you. Si vous souhaitez vous connecter à un hôte à l’écoute, appelez le Connect (méthode).If you want to connect to a listening host, call the Connect method. Pour communiquer des données, appelez le Send ou Receive (méthode).To communicate data, call the Send or Receive method.

  • Si vous utilisez un protocole sans connexion tel que UDP, il est inutile écouter les connexions du tout.If you are using a connectionless protocol such as UDP, you do not need to listen for connections at all. Appelez le ReceiveFrom méthode pour accepter tous les datagrammes entrants.Call the ReceiveFrom method to accept any incoming datagrams. Utilisez le SendTo méthode pour envoyer des datagrammes à un hôte distant.Use the SendTo method to send datagrams to a remote host.

Pour traiter les communications à l’aide de threads séparés pendant l’exécution, utilisez les méthodes suivantes, qui sont conçues pour le mode d’opération asynchrone.To process communications using separate threads during execution, use the following methods, which are designed for asynchronous operation mode.

Si vous effectuez plusieurs opérations asynchrones sur un socket, elles n’est pas nécessairement effectuez dans l’ordre dans lequel ils sont démarrés.If you perform multiple asynchronous operations on a socket, they do not necessarily complete in the order in which they are started.

Lorsque vous avez terminé d’envoyer et de recevoir des données, utilisez le Shutdown méthode permettant de désactiver le Socket.When you are finished sending and receiving data, use the Shutdown method to disable the Socket. Après avoir appelé Shutdown, appelez le Close méthode pour libérer toutes les ressources associées à la Socket.After calling Shutdown, call the Close method to release all resources associated with the Socket.

Le Socket classe vous permet de configurer votre Socket à l’aide de la SetSocketOption (méthode).The Socket class allows you to configure your Socket using the SetSocketOption method. Récupérez ces paramètres à l’aide de la GetSocketOption (méthode).Retrieve these settings using the GetSocketOption method.

Notes

Si vous écrivez une application relativement simple et ne nécessitent pas d’optimiser les performances, envisagez d’utiliser TcpClient, TcpListener, et UdpClient.If you are writing a relatively simple application and do not require maximum performance, consider using TcpClient, TcpListener, and UdpClient. Ces classes fournissent une interface plus simple et plus conviviale pour Socket communications.These classes provide a simpler and more user-friendly interface to Socket communications.

Constructeurs

Socket(AddressFamily, SocketType, ProtocolType) Socket(AddressFamily, SocketType, ProtocolType) Socket(AddressFamily, SocketType, ProtocolType) 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.Initializes a new instance of the Socket class using the specified address family, socket type and protocol.

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

Initialise une nouvelle instance de la classe Socket avec la valeur spécifiée retournée par DuplicateAndClose(Int32).Initializes a new instance of the Socket class using the specified value returned from DuplicateAndClose(Int32).

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

Initialise une nouvelle instance de la classe Socket à l'aide du type de socket et du protocole spécifiés.Initializes a new instance of the Socket class using the specified socket type and protocol.

Propriétés

AddressFamily AddressFamily AddressFamily AddressFamily

Obtient la famille d'adresses de Socket.Gets the address family of the Socket.

Available Available Available Available

Obtient la quantité de données reçues du réseau et disponibles pour la lecture.Gets the amount of data that has been received from the network and is available to be read.

Blocking Blocking Blocking Blocking

Obtient ou définit une valeur qui indique si Socket est en mode blocage.Gets or sets a value that indicates whether the Socket is in blocking mode.

Connected Connected Connected Connected

Obtient une valeur qui indique si Socket est connecté à un hôte distant depuis la dernière opération Send ou Receive.Gets a value that indicates whether a Socket is connected to a remote host as of the last Send or Receive operation.

DontFragment DontFragment DontFragment DontFragment

Obtient ou définit une valeur Boolean qui spécifie si Socket autorise la fragmentation des datagrammes IP (Internet Protocol).Gets or sets a Boolean value that specifies whether the Socket allows Internet Protocol (IP) datagrams to be fragmented.

DualMode DualMode DualMode DualMode

Obtient ou définit une valeur Boolean qui spécifie si Socket est un socket en mode double utilisé pour IPv4 et IPv6.Gets or sets a Boolean value that specifies whether the Socket is a dual-mode socket used for both IPv4 and IPv6.

EnableBroadcast EnableBroadcast EnableBroadcast EnableBroadcast

Obtient ou définit une valeur Boolean qui spécifie si Socket peut envoyer ou recevoir des paquets de diffusion.Gets or sets a Boolean value that specifies whether the Socket can send or receive broadcast packets.

ExclusiveAddressUse ExclusiveAddressUse ExclusiveAddressUse ExclusiveAddressUse

Obtient ou définit une valeur Boolean qui spécifie si Socket n'autorise qu'un seul processus à se lier à un port.Gets or sets a Boolean value that specifies whether the Socket allows only one process to bind to a port.

Handle Handle Handle Handle

Obtient le handle du système d'exploitation pour Socket.Gets the operating system handle for the Socket.

IsBound IsBound IsBound IsBound

Obtient une valeur qui indique si Socket est lié à un port local spécifique.Gets a value that indicates whether the Socket is bound to a specific local port.

LingerState LingerState LingerState 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.Gets or sets a value that specifies whether the Socket will delay closing a socket in an attempt to send all pending data.

LocalEndPoint LocalEndPoint LocalEndPoint LocalEndPoint

Obtient le point de terminaison local.Gets the local endpoint.

MulticastLoopback MulticastLoopback MulticastLoopback MulticastLoopback

Obtient ou définit une valeur spécifiant si les paquets multicast sortants sont remis à l'application émettrice.Gets or sets a value that specifies whether outgoing multicast packets are delivered to the sending application.

NoDelay NoDelay NoDelay NoDelay

Obtient ou définit une valeur Boolean spécifiant si le flux de données Socket utilise l'algorithme Nagle.Gets or sets a Boolean value that specifies whether the stream Socket is using the Nagle algorithm.

OSSupportsIPv4 OSSupportsIPv4 OSSupportsIPv4 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).Indicates whether the underlying operating system and network adaptors support Internet Protocol version 4 (IPv4).

OSSupportsIPv6 OSSupportsIPv6 OSSupportsIPv6 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).Indicates whether the underlying operating system and network adaptors support Internet Protocol version 6 (IPv6).

ProtocolType ProtocolType ProtocolType ProtocolType

Obtient le type de protocole de Socket.Gets the protocol type of the Socket.

ReceiveBufferSize ReceiveBufferSize ReceiveBufferSize ReceiveBufferSize

Obtient ou définit une valeur spécifiant la taille de la mémoire tampon de réception de Socket.Gets or sets a value that specifies the size of the receive buffer of the Socket.

ReceiveTimeout ReceiveTimeout ReceiveTimeout ReceiveTimeout

Obtient ou définit une valeur spécifiant la durée après laquelle un appel Receive synchrone doit expirer.Gets or sets a value that specifies the amount of time after which a synchronous Receive call will time out.

RemoteEndPoint RemoteEndPoint RemoteEndPoint RemoteEndPoint

Obtient le point de terminaison distant.Gets the remote endpoint.

SafeHandle SafeHandle SafeHandle SafeHandle
SendBufferSize SendBufferSize SendBufferSize SendBufferSize

Obtient ou définit une valeur spécifiant la taille de la mémoire tampon d'envoi de Socket.Gets or sets a value that specifies the size of the send buffer of the Socket.

SendTimeout SendTimeout SendTimeout SendTimeout

Obtient ou définit une valeur spécifiant la durée après laquelle un appel Send synchrone doit expirer.Gets or sets a value that specifies the amount of time after which a synchronous Send call will time out.

SocketType SocketType SocketType SocketType

Obtient le type de Socket.Gets the type of the Socket.

SupportsIPv4 SupportsIPv4 SupportsIPv4 SupportsIPv4

Obtient une valeur indiquant si la prise en charge d'IPv4 est disponible et active sur l'hôte en cours.Gets a value indicating whether IPv4 support is available and enabled on the current host.

SupportsIPv6 SupportsIPv6 SupportsIPv6 SupportsIPv6

Obtient une valeur qui indique si le Framework prend en charge le protocole IPv6 pour certains membres Dns obsolètes.Gets a value that indicates whether the Framework supports IPv6 for certain obsolete Dns members.

Ttl Ttl Ttl Ttl

Obtient ou définit une valeur qui spécifie la durée de vie des paquets IP (Internet Protocol) envoyés par Socket.Gets or sets a value that specifies the Time To Live (TTL) value of Internet Protocol (IP) packets sent by the Socket.

UseOnlyOverlappedIO UseOnlyOverlappedIO UseOnlyOverlappedIO UseOnlyOverlappedIO

Spécifie si le socket doit utiliser uniquement le mode d'E/S avec chevauchement.Specifies whether the socket should only use Overlapped I/O mode.

Méthodes

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

Crée un nouveau Socket pour une connexion nouvellement créée.Creates a new Socket for a newly created connection.

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

Démarre une opération asynchrone pour accepter une tentative de connexion entrante.Begins an asynchronous operation to accept an incoming connection attempt.

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

Démarre une opération asynchrone pour accepter une tentative de connexion entrante.Begins an asynchronous operation to accept an incoming connection attempt.

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

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.Begins an asynchronous operation to accept an incoming connection attempt and receives the first block of data sent by the client application.

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

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.Begins an asynchronous operation to accept an incoming connection attempt from a specified socket and receives the first block of data sent by the client application.

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

Démarre une demande asynchrone pour une connexion d'hôte distant.Begins an asynchronous request for a remote host connection.

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

Démarre une demande asynchrone pour une connexion d'hôte distant.Begins an asynchronous request for a remote host connection. L’hôte est spécifié par IPAddress et un numéro de port.The host is specified by an IPAddress and a port number.

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

Démarre une demande asynchrone pour une connexion d'hôte distant.Begins an asynchronous request for a remote host connection. L’hôte est spécifié par un tableau IPAddress et un numéro de port.The host is specified by an IPAddress array and a port number.

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

Démarre une demande asynchrone pour une connexion d'hôte distant.Begins an asynchronous request for a remote host connection. L’hôte est spécifié par un nom d’hôte et un numéro de port.The host is specified by a host name and a port number.

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

Lance une demande asynchrone de déconnexion d'un point de terminaison distant.Begins an asynchronous request to disconnect from a remote endpoint.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.Begins to asynchronously receive data from a connected Socket.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.Begins to asynchronously receive data from a connected Socket.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.Begins to asynchronously receive data from a connected Socket.

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

Démarre la réception asynchrone de données à partir d'un Socket connecté.Begins to asynchronously receive data from a connected Socket.

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

Démarre la réception asynchrone de données à partir d'un périphérique réseau spécifié.Begins to asynchronously receive data from a specified network device.

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

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.Begins to asynchronously receive the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

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

Envoie des données de façon asynchrone à un Socket connecté.Sends data asynchronously to a connected Socket.

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

Envoie des données de façon asynchrone à un Socket connecté.Sends data asynchronously to a connected Socket.

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

Envoie des données de façon asynchrone à un Socket connecté.Sends data asynchronously to a connected Socket.

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

Envoie des données de façon asynchrone à un Socket connecté.Sends data asynchronously to a connected Socket.

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

Envoie le fichier fileName à un objet Socket connecté à l'aide de l'indicateur UseDefaultWorkerThread.Sends the file fileName to a connected Socket object using the UseDefaultWorkerThread flag.

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

Envoie de façon asynchrone un fichier et des mémoires tampon de données à un objet Socket connecté.Sends a file and buffers of data asynchronously to a connected Socket object.

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

Envoie des données de façon asynchrone à un hôte distant spécifique.Sends data asynchronously to a specific remote host.

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

Associe Socket à un point de terminaison local.Associates a Socket with a local endpoint.

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

Annule une requête asynchrone pour une connexion d'hôte distant.Cancels an asynchronous request for a remote host connection.

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

Ferme la connexion Socket et libère toutes les ressources associées.Closes the Socket connection and releases all associated resources.

Close(Int32) Close(Int32) Close(Int32) 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.Closes the Socket connection and releases all associated resources with a specified timeout to allow queued data to be sent.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host. L’hôte est spécifié par une adresse IP et un numéro de port.The host is specified by an IP address and a port number.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host. L’hôte est spécifié par un tableau d’adresses IP et un numéro de port.The host is specified by an array of IP addresses and a port number.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host. L’hôte est spécifié par un nom d’hôte et un numéro de port.The host is specified by a host name and a port number.

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

Démarre une demande asynchrone pour une connexion à un hôte distant.Begins an asynchronous request for a connection to a remote host.

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

Démarre une demande asynchrone pour une connexion à un hôte distant.Begins an asynchronous request for a connection to a remote host.

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

Ferme la connexion de socket et autorise la réutilisation du socket.Closes the socket connection and allows reuse of the socket.

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

Lance une demande asynchrone de déconnexion d'un point de terminaison distant.Begins an asynchronous request to disconnect from a remote endpoint.

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

Libère toutes les ressources utilisées par l'instance actuelle de la classe Socket.Releases all resources used by the current instance of the Socket class.

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

Libère les ressources non managées utilisées par Socket et supprime éventuellement les ressources managées.Releases the unmanaged resources used by the Socket, and optionally disposes of the managed resources.

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

Duplique la référence de socket pour le processus cible et ferme le socket pour ce processus.Duplicates the socket reference for the target process, and closes the socket for this process.

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

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.Asynchronously accepts an incoming connection attempt and creates a new Socket object to handle remote host communication. Cette méthode retourne une mémoire tampon qui contient les données initiales transférées.This method returns a buffer that contains the initial data transferred.

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

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.Asynchronously accepts an incoming connection attempt and creates a new Socket object to handle remote host communication. Cette méthode retourne une mémoire tampon qui contient les données initiales et le nombre d'octets transférés.This method returns a buffer that contains the initial data and the number of bytes transferred.

EndAccept(IAsyncResult) EndAccept(IAsyncResult) EndAccept(IAsyncResult) 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.Asynchronously accepts an incoming connection attempt and creates a new Socket to handle remote host communication.

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

Met fin à une demande de connexion asynchrone en attente.Ends a pending asynchronous connection request.

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

Met fin à une demande de déconnexion asynchrone en attente.Ends a pending asynchronous disconnect request.

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

Met fin à une lecture asynchrone en attente.Ends a pending asynchronous read.

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

Met fin à une lecture asynchrone en attente.Ends a pending asynchronous read.

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

Met fin à une lecture asynchrone en attente à partir d'un point de terminaison spécifique.Ends a pending asynchronous read from a specific endpoint.

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

Met fin à une lecture asynchrone en attente à partir d'un point de terminaison spécifique.Ends a pending asynchronous read from a specific endpoint. Cette méthode révèle également davantage d'informations sur le paquet que EndReceiveFrom(IAsyncResult, EndPoint).This method also reveals more information about the packet than EndReceiveFrom(IAsyncResult, EndPoint).

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

Met fin à un envoi asynchrone en attente.Ends a pending asynchronous send.

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

Met fin à un envoi asynchrone en attente.Ends a pending asynchronous send.

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

Met fin à un envoi asynchrone en attente d'un fichier.Ends a pending asynchronous send of a file.

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

Met fin à un envoi asynchrone en attente vers un emplacement spécifique.Ends a pending asynchronous send to a specific location.

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

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

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

Libère les ressources utilisées par la classe Socket.Frees resources used by the Socket class.

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

Retourne une valeur de hachage pour une instance de Socket.Returns a hash value for a Socket instance.

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

Retourne la valeur d'une option Socket spécifiée, représentée sous la forme d'un objet.Returns the value of a specified Socket option, represented as an object.

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

Retourne la valeur de l'option Socket spécifiée sous la forme d'un tableau d'octets.Returns the specified Socket option setting, represented as a byte array.

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

Retourne la valeur de l'option Socket spécifiée dans un tableau.Returns the value of the specified Socket option in an array.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Définit les modes de fonctionnement de bas niveau de Socket à l'aide de codes de contrôle numériques.Sets low-level operating modes for the Socket using numerical control codes.

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

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.Sets low-level operating modes for the Socket using the IOControlCode enumeration to specify control codes.

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

Met Socket dans un état d'écoute.Places a Socket in a listening state.

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

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

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

Détermine l'état de Socket.Determines the status of the Socket.

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

Reçoit les données d'un Socket lié dans une mémoire tampon de réception.Receives data from a bound Socket into a receive buffer.

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

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é.Receives the specified number of bytes from a bound Socket into the specified offset position of the receive buffer, using the specified SocketFlags.

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

Reçoit les données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.Receives data from a bound Socket into a receive buffer, using the specified SocketFlags.

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

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é.Receives the specified number of bytes of data from a bound Socket into a receive buffer, using the specified SocketFlags.

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

Reçoit les données d'un Socket lié dans une mémoire tampon de réception, à l'aide du SocketFlags spécifié.Receives data from a bound Socket into a receive buffer, using the specified SocketFlags.

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

Reçoit les données d'un Socket lié dans la liste des mémoires tampon de réception.Receives data from a bound Socket into the list of receive buffers.

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

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é.Receives data from a bound Socket into the list of receive buffers, using the specified SocketFlags.

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

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é.Receives data from a bound Socket into the list of receive buffers, using the specified SocketFlags.

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

Démarre une demande asynchrone pour recevoir les données d'un objet Socket connecté.Begins an asynchronous request to receive data from a connected Socket object.

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

Reçoit un datagramme dans la mémoire tampon de données et stocke le point de terminaison.Receives a datagram into the data buffer and stores the endpoint.

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

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.Receives the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint.

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

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.Receives the specified number of bytes into the data buffer, using the specified SocketFlags, and stores the endpoint.

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

Reçoit un datagramme dans la mémoire tampon de données à l'aide du SocketFlags spécifié et stocke le point de terminaison.Receives a datagram into the data buffer, using the specified SocketFlags, and stores the endpoint.

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

Démarre la réception asynchrone de données à partir d'un périphérique réseau spécifié.Begins to asynchronously receive data from a specified network device.

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

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.Receives the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

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

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.Begins to asynchronously receive the specified number of bytes of data into the specified location in the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

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

Détermine l’état d’un ou plusieurs sockets.Determines the status of one or more sockets.

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

Envoie des données à un Socket connecté.Sends data to a connected Socket.

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

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é.Sends the specified number of bytes of data to a connected Socket, starting at the specified offset, and using the specified SocketFlags.

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

Envoie le nombre spécifié d'octets de données d'un Socket connecté, en démarrant à l'offset spécifié et en utilisant le SocketFlags spécifiéSends the specified number of bytes of data to a connected Socket, starting at the specified offset, and using the specified SocketFlags

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

Reçoit le nombre spécifié d'octets de données à un Socket connecté, à l'aide du SocketFlags spécifié.Sends the specified number of bytes of data to a connected Socket, using the specified SocketFlags.

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

Envoie des données à un Socket connecté à l'aide du SocketFlags spécifié.Sends data to a connected Socket using the specified SocketFlags.

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

Envoie le jeu de mémoires tampon dans la liste à un Socket connecté.Sends the set of buffers in the list to a connected Socket.

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

Envoie le jeu de mémoires tampon dans la liste à un Socket connecté, à l'aide du SocketFlags spécifié.Sends the set of buffers in the list to a connected Socket, using the specified SocketFlags.

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

Envoie le jeu de mémoires tampon dans la liste à un Socket connecté, à l'aide du SocketFlags spécifié.Sends the set of buffers in the list to a connected Socket, using the specified SocketFlags.

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

Envoie des données de façon asynchrone à un objet Socket connecté.Sends data asynchronously to a connected Socket object.

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

Envoie le fichier fileName à un objet Socket connecté avec l'indicateur de transmission UseDefaultWorkerThread.Sends the file fileName to a connected Socket object with the UseDefaultWorkerThread transmit flag.

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

Envoie le fileName et les tampons de données du fichier à un objet Socket connecté à l’aide de la valeur TransmitFileOptions spécifiée.Sends the file fileName and buffers of data to a connected Socket object using the specified TransmitFileOptions value.

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

Envoie une collection de fichiers ou des données mises en mémoire tampon de façon asynchrone à un objet Socket connecté.Sends a collection of files or in memory data buffers asynchronously to a connected Socket object.

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

Envoie les données au point de terminaison spécifié.Sends data to the specified endpoint.

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

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é.Sends the specified number of bytes of data to the specified endpoint, starting at the specified location in the buffer, and using the specified SocketFlags.

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

Envoie le nombre spécifié d'octets de données au point de terminaison spécifié à l'aide du SocketFlags spécifié.Sends the specified number of bytes of data to the specified endpoint using the specified SocketFlags.

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

Envoie des données à un point de terminaison spécifique à l'aide du SocketFlags spécifié.Sends data to a specific endpoint using the specified SocketFlags.

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

Envoie des données de façon asynchrone à un hôte distant spécifique.Sends data asynchronously to a specific remote host.

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

Définit le niveau de protection IP sur un socket.Set the IP protection level on a socket.

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

Affecte la valeur Socket spécifiée à l'option Boolean spécifiée.Sets the specified Socket option to the specified Boolean value.

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

Affecte la valeur spécifiée à l'option Socket spécifiée représentée sous la forme d'un tableau d'octets.Sets the specified Socket option to the specified value, represented as a byte array.

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

Affecte la valeur entière spécifiée à l'option Socket spécifiée.Sets the specified Socket option to the specified integer value.

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

Affecte la valeur spécifiée à l'option Socket spécifiée représentée sous la forme d'un objet.Sets the specified Socket option to the specified value, represented as an object.

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

Désactive les envois et les réceptions sur un Socket.Disables sends and receives on a Socket.

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

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Implémentations d’interfaces explicites

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

Libère toutes les ressources utilisées par Socket.Releases all resources used by the Socket.

Extension Methods

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

Effectue une opération asynchrone pour accepter une tentative de connexion entrante sur le socket.Performs an asynchronous operation on to accept an incoming connection attempt on the socket.

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

Effectue une opération asynchrone pour accepter une tentative de connexion entrante sur le socket.Performs an asynchronous operation on to accept an incoming connection attempt on the socket.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host. L’hôte est spécifié par une adresse IP et un numéro de port.The host is specified by an IP address and a port number.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host. L’hôte est spécifié par un tableau d’adresses IP et un numéro de port.The host is specified by an array of IP addresses and a port number.

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

Établit une connexion à un hôte distant.Establishes a connection to a remote host. L’hôte est spécifié par un nom d’hôte et un numéro de port.The host is specified by a host name and a port number.

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

Reçoit des données à partir d’un socket connecté.Receives data from a connected socket.

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

Reçoit des données à partir d’un socket connecté.Receives data from a connected socket.

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

Reçoit des données à partir d’un périphérique réseau spécifié.Receives data from a specified network device.

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

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.Receives the specified number of bytes of data into the specified location of the data buffer, using the specified SocketFlags, and stores the endpoint and packet information.

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

Envoie des données à un socket connecté.Sends data to a connected socket.

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

Envoie des données à un socket connecté.Sends data to a connected socket.

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

Envoie des données de façon asynchrone à un hôte distant spécifique.Sends data asynchronously to a specific remote host.

Sécurité

SocketPermission
Pour établir une connexion sortante ou accepter une demande entrante.To establish an outgoing connection or accept an incoming request.

S’applique à

Cohérence de thread

Instances de cette classe sont thread-safe.Instances of this class are thread safe.

Voir aussi