HttpListener Classe

Définition

Espace de noms:
System.Net
Assemblys:
netstandard.dll, System.Net.HttpListener.dll
Assembly:
System.Net.HttpListener.dll
Assembly:
System.dll
Assembly:
netstandard.dll
Source:
HttpListener.cs
Source:
HttpListener.cs
Source:
HttpListener.cs
Source:
HttpListener.cs
Source:
HttpListener.cs

Fournit un écouteur de protocole HTTP simple et contrôlé par programmation. Cette classe ne peut pas être héritée.

public ref class HttpListener sealed : IDisposable
public sealed class HttpListener : IDisposable
type HttpListener = class
    interface IDisposable
Public NotInheritable Class HttpListener
Implements IDisposable
Héritage
Object
HttpListener
Implémente
IDisposable

Exemples

// This example requires the System and System.Net namespaces.
public static void SimpleListenerExample(string[] prefixes)
{
    if (!HttpListener.IsSupported)
    {
        Console.WriteLine ("Windows XP SP2 or Server 2003 is required to use the HttpListener class.");
        return;
    }
    // URI prefixes are required,
    // for example "http://contoso.com:8080/index/".
    if (prefixes == null || prefixes.Length == 0)
      throw new ArgumentException("prefixes");

    // Create a listener.
    HttpListener listener = new HttpListener();
    // Add the prefixes.
    foreach (string s in prefixes)
    {
        listener.Prefixes.Add(s);
    }
    listener.Start();
    Console.WriteLine("Listening...");
    // Note: The GetContext method blocks while waiting for a request.
    HttpListenerContext context = listener.GetContext();
    HttpListenerRequest request = context.Request;
    // Obtain a response object.
    HttpListenerResponse response = context.Response;
    // Construct a response.
    string responseString = "<HTML><BODY> Hello world!</BODY></HTML>";
    byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
    // Get a response stream and write the response to it.
    response.ContentLength64 = buffer.Length;
    System.IO.Stream output = response.OutputStream;
    output.Write(buffer,0,buffer.Length);
    // You must close the output stream.
    output.Close();
    listener.Stop();
}

Public Shared Sub SimpleListenerExample(prefixes As String())
    If Not HttpListener.IsSupported Then
        Console.WriteLine("Windows XP SP2 or Server 2003 is required to use the HttpListener class.")
        Return
    End If
    ' URI prefixes are required,
    ' for example "http://contoso.com:8080/index/".
    If prefixes Is Nothing Or prefixes.Length = 0 Then
        Throw New ArgumentException("prefixes")
    End If

    ' Create a listener
    Dim listener = New HttpListener()

    For Each s As String In prefixes
        listener.Prefixes.Add(s)
    Next
    listener.Start()
    Console.WriteLine("Listening...")
    ' Note: The GetContext method blocks while waiting for a request.
    Dim context As HttpListenerContext = listener.GetContext()
    Console.WriteLine("Listening...")
    ' Obtain a response object
    Dim request As HttpListenerRequest = context.Request
    ' Construct a response.
    Dim response As HttpListenerResponse = context.Response
    Dim responseString As String = "<HTML><BODY> Hello world!</BODY></HTML>"
    Dim buffer As Byte() = System.Text.Encoding.UTF8.GetBytes(responseString)
    ' Get a response stream and write the response to it.
    response.ContentLength64 = buffer.Length
    Dim output As System.IO.Stream = response.OutputStream
    output.Write(buffer, 0, buffer.Length)
    'You must close the output stream.
    output.Close()
    listener.Stop()
End Sub

Remarques

À l’aide de la HttpListener classe, vous pouvez créer un écouteur de protocole HTTP simple qui répond aux requêtes HTTP. L’écouteur est actif pendant la durée de vie de l’objet HttpListener et s’exécute dans votre application avec ses autorisations.

Pour utiliser HttpListener, créez une instance de la classe à l’aide du HttpListener constructeur et utilisez la Prefixes propriété pour accéder à la collection qui contient les chaînes qui spécifient les préfixes URI (Uniform Resource Identifier) que le HttpListener processus doit traiter.

Une chaîne de préfixe d’URI est composée d’un schéma (http ou https), d’un hôte, d’un port facultatif et d’un chemin d’accès facultatif. Un exemple de chaîne de préfixe complète est http://www.contoso.com:8080/customerData/. Les préfixes doivent se terminer par une barre oblique (« / »). L’objet HttpListener avec le préfixe qui correspond le plus étroitement à un URI demandé répond à la requête. Plusieurs HttpListener objets ne peuvent pas ajouter le même préfixe ; une Win32Exception exception est levée si un HttpListener ajoute un préfixe qui est déjà en cours d'utilisation.

Lorsqu’un port est spécifié, l’élément hôte peut être remplacé par « * » pour indiquer que le HttpListener accepte les demandes envoyées au port si l’URI demandé ne correspond à aucun autre préfixe. Par exemple, pour recevoir toutes les demandes envoyées au port 8080 lorsque l’URI demandé n’est géré par aucun HttpListener, le préfixe est http ://* :8080/. De même, pour spécifier que HttpListener accepte toutes les demandes envoyées à un port, remplacez l’élément hôte par le caractère « + ». Par exemple : https://+:8080. Les caractères « * » et « + » peuvent être présents dans des préfixes qui incluent des chemins d’accès.

Les sous-domaines génériques sont pris en charge dans les préfixes d’URI gérés par un objet HttpListener. Pour spécifier un sous-domaine générique, utilisez le caractère « * » dans le cadre du nom d’hôte dans un préfixe d’URI. Par exemple, http ://*.foo.com/. Transmettez-le en tant qu’argument à la Add méthode.

Warning

Les liaisons génériques de niveau supérieur (http ://* :8080/ et http://+:8080) ne doivent pas être utilisées. Les liaisons génériques de niveau supérieur peuvent exposer votre application à des failles de sécurité. Cela s’applique aux caractères génériques forts et faibles. Utilisez des noms d’hôte explicites plutôt que des caractères génériques. Une liaison générique de sous-domaine (par exemple, *.mysub.com) ne présente pas ce risque de sécurité si vous contrôlez le domaine parent en entier (par opposition à *.com, qui est vulnérable). Pour plus d’informations, consultez la section rfc7230-5.4 .

Pour commencer à écouter les demandes des clients, ajoutez les préfixes d’URI à la collection et appelez la Start méthode. HttpListener offre à la fois des modèles synchrones et asynchrones pour le traitement des demandes clientes. Les requêtes et leurs réponses associées sont accessibles à l’aide de l’objet HttpListenerContext retourné par la méthode GetContext ou ses équivalents asynchrones, les méthodes BeginGetContext et EndGetContext.

Le modèle synchrone est approprié si votre application doit bloquer en attendant une demande cliente et si vous souhaitez traiter une seule requête à la fois. À l’aide du modèle synchrone, appelez la GetContext méthode, qui attend qu’un client envoie une demande. La méthode vous retourne un objet HttpListenerContext pour traitement lorsqu'il se produit.

Dans le modèle asynchrone plus complexe, votre application ne bloque pas en attendant les demandes et chaque requête est traitée dans son propre thread d’exécution. Utilisez la BeginGetContext méthode pour spécifier une méthode définie par l’application à appeler pour chaque requête entrante. Dans cette méthode, appelez la EndGetContext méthode pour obtenir la demande, la traiter et répondre.

Dans l’un ou l’autre modèle, les requêtes entrantes sont accessibles à l’aide de la HttpListenerContext.Request propriété et sont représentées par HttpListenerRequest des objets. De même, les réponses sont accessibles à l’aide de la HttpListenerContext.Response propriété et sont représentées par HttpListenerResponse des objets. Ces objets partagent certaines fonctionnalités avec les objets HttpWebRequest et HttpWebResponse, mais ces derniers ne peuvent pas être utilisés conjointement avec HttpListener car ils implémentent des comportements côté client, et non côté serveur.

Un HttpListener peut nécessiter l’authentification du client. Vous pouvez spécifier un schéma particulier à utiliser pour l’authentification, ou vous pouvez spécifier un délégué qui détermine le schéma à utiliser. Vous devez exiger une forme d’authentification pour obtenir des informations sur l’identité du client. Pour plus d’informations, consultez les propriétés User, AuthenticationSchemes, et AuthenticationSchemeSelectorDelegate.

Note

Si vous créez un HttpListener à l’aide de https, vous devez sélectionner un certificat de serveur pour cet écouteur. Dans le cas contraire, les demandes adressées à ce HttpListener échoueront avec une fermeture inattendue de la connexion.

Note

Vous pouvez configurer des certificats de serveur et d’autres options d’écouteur à l’aide de Network Shell (netsh.exe). Pour plus d’informations, consultez Network Shell (Netsh). L’exécutable a commencé à être expédié avec Windows Server 2008 et Windows Vista.

Note

Si vous spécifiez plusieurs schémas d’authentification pour l’écouteur HttpListener, l’écouteur défie les clients dans l’ordre suivant : Negotiate, NTLM, , Digestpuis Basic.

HTTP.sys

La HttpListener classe est basée sur HTTP.sys, qui est l’écouteur en mode noyau qui gère tout le trafic HTTP pour Windows. HTTP.sys fournit la gestion des connexions, la limitation de bande passante et la journalisation des serveurs web. Utilisez l’outil HttpCfg.exe pour ajouter des certificats SSL.

À compter de .NET 11, l’implémentation de Windows HTTP.sys prend en charge l’activation de la mise en mémoire tampon de réponse au niveau du noyau HttpListener. Lorsqu’elles sont activées, les données de réponse sont mises HTTP.sys en mémoire tampon avant d’être envoyées au client, ce qui peut améliorer le débit pour les connexions à latence élevée. Cela peut être activé en appelant la AppContext.SetSwitch méthode comme suit :

AppContext.SetSwitch("System.Net.HttpListener.EnableKernelResponseBuffering", true);

Constructeurs

Nom Description
HttpListener()

Initialise une nouvelle instance de la classe HttpListener.

Propriétés

Nom Description
AuthenticationSchemes

Obtient ou définit le schéma utilisé pour authentifier les clients.
AuthenticationSchemeSelectorDelegate

Obtient ou définit le délégué appelé pour déterminer le protocole utilisé pour authentifier les clients.
DefaultServiceNames

Obtient une liste par défaut des noms de fournisseurs de services (SPN) déterminés par les préfixes inscrits.
ExtendedProtectionPolicy

Obtient ou définit la valeur à utiliser pour une ExtendedProtectionPolicy protection étendue pour une session.
ExtendedProtectionSelectorDelegate

Obtient ou définit le délégué appelé pour déterminer l’utilisation ExtendedProtectionPolicy de chaque requête.
IgnoreWriteExceptions

Obtient ou définit une Boolean valeur qui spécifie si votre application reçoit des exceptions qui se produisent lorsqu’une HttpListener réponse envoie la réponse au client.
IsListening

Obtient une valeur qui indique si HttpListener elle a été démarrée.
IsSupported

Obtient une valeur qui indique si HttpListener vous pouvez utiliser le système d’exploitation actuel.
Prefixes

Obtient les préfixes URI (Uniform Resource Identifier) gérés par cet HttpListener objet.
Realm

Obtient ou définit le domaine ou la partition de ressources associé à cet HttpListener objet.
TimeoutManager

Gestionnaire de délai d’expiration pour cette HttpListener instance.
UnsafeConnectionNtlmAuthentication

Obtient ou définit une Boolean valeur qui contrôle si, lorsque NTLM est utilisé, des requêtes supplémentaires utilisant la même connexion TCP (Transmission Control Protocol) sont requises pour s’authentifier.

Méthodes

Nom Description
Abort()

Arrête immédiatement l’objet HttpListener , en ignorant toutes les demandes actuellement mises en file d’attente.
BeginGetContext(AsyncCallback, Object)

Commence à récupérer de façon asynchrone une requête entrante.
Close()

Arrête le HttpListener.
EndGetContext(IAsyncResult)

Termine une opération asynchrone pour récupérer une requête cliente entrante.
Equals(Object)

Détermine si l’objet spécifié est égal à l’objet actuel.

(Hérité de Object)
GetContext()

Attend une demande entrante et retourne une fois qu’une demande est reçue.
GetContextAsync()

Attend une requête entrante en tant qu’opération asynchrone.
GetHashCode()

Sert de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient la Type de l’instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Objectactuel.

(Hérité de Object)
Start()

Permet à cette instance de recevoir des demandes entrantes.
Stop()

Provoque l’arrêt de la réception de nouvelles demandes entrantes et met fin au traitement de toutes les demandes en cours.
ToString()

Retourne une chaîne qui représente l’objet actuel.

(Hérité de Object)

Implémentations d’interfaces explicites

Nom Description
IDisposable.Dispose()

Libère les ressources détenues par cet HttpListener objet.

S’applique à

Voir aussi