Comment ajouter un en-tête HTTP personnalisé à chaque appel WCF?

J'ai un service WCF qui est hébergé dans un service Windows. Les clients qui utilisent ce service doivent transmettre un identifiant à chaque fois qu'ils appellent des méthodes de service (car cet identifiant est important pour ce que la méthode appelée doit faire). J'ai pensé que c'était une bonne idée de mettre cet identifiant dans les informations d'en-tête WCF.

Si c'est une bonne idée, comment puis-je ajouter automatiquement l'identifiant aux informations d'en-tête. En d'autres termes, chaque fois que l'utilisateur appelle la méthode WCF, l'identificateur doit être automatiquement ajouté à l'en-tête.

MISE À JOUR: les clients qui utilisent le service WCF sont à la fois des applications Windows et des applications Windows Mobile (utilisant Compact Framework).

L'avantage de ceci est qu'il est appliqué à chaque appel.

Créez une classe qui implémente IClientMessageInspector . Dans la méthode BeforeSendRequest, ajoutez votre en-tête personnalisé au message sortant. Cela pourrait ressembler à ceci:

    public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request,  System.ServiceModel.IClientChannel channel)
{
    HttpRequestMessageProperty httpRequestMessage;
    object httpRequestMessageObject;
    if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
    {
        httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
        if (string.IsNullOrEmpty(httpRequestMessage.Headers[USER_AGENT_HTTP_HEADER]))
        {
            httpRequestMessage.Headers[USER_AGENT_HTTP_HEADER] = this.m_userAgent;
        }
    }
    else
    {
        httpRequestMessage = new HttpRequestMessageProperty();
        httpRequestMessage.Headers.Add(USER_AGENT_HTTP_HEADER, this.m_userAgent);
        request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
    }
    return null;
}

Créez ensuite un comportement de point de terminaison qui applique l'inspecteur de messages à l'environnement d'exécution du client. Vous pouvez appliquer le comportement via un attribut ou via une configuration à l'aide d'un élément d'extension de comportement.

Voici un excellent exemple de la façon d'ajouter un en-tête d'agent utilisateur HTTP à tous les messages de requête. J'utilise ceci dans quelques-uns de mes clients. Vous pouvez également faire de même du côté des services en implémentant IDispatchMessageInspector .

Est-ce ce que vous aviez en tête?

Mise à jour: j'ai trouvé cette liste de fonctionnalités WCF prises en charge par le framework compact. Je crois que les inspecteurs de messages classés comme «extensibilité des canaux» qui, selon ce post, sont pris en charge par le cadre compact.

Vous l'ajoutez à l'appel en utilisant:

using (OperationContextScope scope = new OperationContextScope((IContextChannel)channel))
{
    MessageHeader<string> header = new MessageHeader<string>("secret message");
    var untyped = header.GetUntypedHeader("Identity", "http://www.my-website.com");
    OperationContext.Current.OutgoingMessageHeaders.Add(untyped);

    // now make the WCF call within this using block
}

Et puis, côté serveur, vous le récupérez en utilisant:

MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders;
string identity = headers.GetHeader<string>("Identity", "http://www.my-website.com");

Si vous souhaitez simplement ajouter le même en-tête à toutes les demandes du service, vous pouvez le faire sans aucun codage!
Ajoutez simplement le nœud d'en-têtes avec les en-têtes requis sous le nœud de point de terminaison dans votre fichier de configuration client

<client>  
  <endpoint address="http://localhost/..." >  
    <headers>  
      <HeaderName>Value</HeaderName>  
    </headers>   
 </endpoint>  

Voici une autre solution utile pour ajouter manuellement des en-têtes HTTP personnalisés à votre demande WCF client en utilisant le ChannelFactorycomme proxy. Cela devrait être fait pour chaque requête, mais cela suffit comme une simple démonstration si vous avez juste besoin de tester unitaire votre proxy en préparation pour les plates-formes non.NET.

// create channel factory / proxy ...
using (OperationContextScope scope = new OperationContextScope(proxy))
{
    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = new HttpRequestMessageProperty()
    {
        Headers = 
        { 
            { "MyCustomHeader", Environment.UserName },
            { HttpRequestHeader.UserAgent, "My Custom Agent"}
        }
    };    
    // perform proxy operations... 
}

Ceci est similaire à la réponse NimsDotNet mais montre comment le faire par programme.

Ajoutez simplement l'en-tête à la reliure

var cl = new MyServiceClient();

var eab = new EndpointAddressBuilder(cl.Endpoint.Address);

eab.Headers.Add( 
      AddressHeader.CreateAddressHeader("ClientIdentification",  // Header Name
                                         string.Empty,           // Namespace
                                         "JabberwockyClient"));  // Header Value

cl.Endpoint.Address = eab.ToEndpointAddress();

var endpoint = new EndpointAddress(new Uri(RemoteAddress),
               new[] { AddressHeader.CreateAddressHeader(
                       "APIKey", 
                       "",
                       "bda11d91-7ade-4da1-855d-24adfe39d174") 
                     });

C'est ce qui a fonctionné pour moi, adapté de l' ajout d'en-têtes HTTP aux appels WCF

// Message inspector used to add the User-Agent HTTP Header to the WCF calls for Server
public class AddUserAgentClientMessageInspector : IClientMessageInspector
{
    public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, IClientChannel channel)
    {
        HttpRequestMessageProperty property = new HttpRequestMessageProperty();

        var userAgent = "MyUserAgent/1.0.0.0";

        if (request.Properties.Count == 0 || request.Properties[HttpRequestMessageProperty.Name] == null)
        {
            var property = new HttpRequestMessageProperty();
            property.Headers["User-Agent"] = userAgent;
            request.Properties.Add(HttpRequestMessageProperty.Name, property);
        }
        else
        {
            ((HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name]).Headers["User-Agent"] = userAgent;
        }
        return null;
    }

    public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
    {
    }
}

// Endpoint behavior used to add the User-Agent HTTP Header to WCF calls for Server
public class AddUserAgentEndpointBehavior : IEndpointBehavior
{
    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
        clientRuntime.MessageInspectors.Add(new AddUserAgentClientMessageInspector());
    }

    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
    {
    }

    public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
    {
    }

    public void Validate(ServiceEndpoint endpoint)
    {
    }
}

Après avoir déclaré ces classes, vous pouvez ajouter le nouveau comportement à votre client WCF comme ceci:

client.Endpoint.Behaviors.Add(new AddUserAgentEndpointBehavior());

Cela fonctionne pour moi

TestService.ReconstitutionClient _serv = new TestService.TestClient();

using (OperationContextScope contextScope = new OperationContextScope(_serv.InnerChannel))
{
   HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();

   requestMessage.Headers["apiKey"] = ConfigurationManager.AppSettings["apikey"]; 
   OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = 
      requestMessage;
   _serv.Method(Testarg);
}

Les liaisons de contexte dans .NET 3.5 peuvent être exactement ce que vous recherchez. Il y en a trois prêts à l'emploi: BasicHttpContextBinding, NetTcpContextBinding et WSHttpContextBinding. Le protocole de contexte transmet essentiellement des paires clé-valeur dans l'en-tête du message. Consultez l'article Managing State With Durable Services sur le magazine MSDN.

Si je comprends bien votre exigence, la réponse simple est: vous ne pouvez pas.

En effet, le client du service WCF peut être généré par tout tiers qui utilise votre service.

SI vous avez le contrôle des clients de votre service, vous pouvez créer une classe client de base qui ajoute l'en-tête souhaité et hérite du comportement sur les classes de travail.

Vous pouvez spécifier des en-têtes personnalisés dans MessageContract .

Vous pouvez également utiliser des en - têtes <endpoint> qui sont stockés dans le fichier de configuration et qui seront copiés dans l'en-tête de tous les messages envoyés par le client / service. Ceci est utile pour ajouter facilement un en-tête statique.

Si vous souhaitez ajouter des en-têtes HTTP personnalisés à chaque appel WCF d'une manière orientée objet, ne cherchez pas plus loin.

Tout comme dans la réponse de Mark Good et paulwhit, nous devons créer une sous-classe IClientMessageInspectorpour injecter les en-têtes HTTP personnalisés dans la requête WCF. Cependant, rendons l'inspecteur plus générique en acceptant un dictionnaire contenant les en-têtes que nous voulons ajouter:

public class HttpHeaderMessageInspector : IClientMessageInspector
{
    private Dictionary<string, string> Headers;

    public HttpHeaderMessageInspector(Dictionary<string, string> headers)
    {
        Headers = headers;
    }

    public object BeforeSendRequest(ref Message request, IClientChannel channel)
    {
        // ensure the request header collection exists
        if (request.Properties.Count == 0 || request.Properties[HttpRequestMessageProperty.Name] == null)
        {
            request.Properties.Add(HttpRequestMessageProperty.Name, new HttpRequestMessageProperty());
        }

        // get the request header collection from the request
        var HeadersCollection = ((HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name]).Headers;

        // add our headers
        foreach (var header in Headers) HeadersCollection[header.Key] = header.Value;

        return null;
    }

    // ... other unused interface methods removed for brevity ...
}

Tout comme dans la réponse de Mark Good et paulwhit, nous devons créer une sous-classe IEndpointBehaviorpour l'injecter HttpHeaderMessageInspectordans notre client WCF.

public class AddHttpHeaderMessageEndpointBehavior : IEndpointBehavior
{
    private IClientMessageInspector HttpHeaderMessageInspector;

    public AddHttpHeaderMessageEndpointBehavior(Dictionary<string, string> headers)
    {
        HttpHeaderMessageInspector = new HttpHeaderMessageInspector(headers);
    }

    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
        clientRuntime.ClientMessageInspectors.Add(HttpHeaderMessageInspector);
    }

    // ... other unused interface methods removed for brevity ...
}

La dernière partie nécessaire pour terminer notre approche orientée objet consiste à créer une sous-classe de notre client généré automatiquement WCF (j'ai utilisé le guide de référence du service Web WCF de Microsoft pour générer un client WCF).

Dans mon cas, je dois attacher une clé API à l'en- x-api-keytête HTML.

La sous-classe effectue les opérations suivantes:

• appelle le constructeur de la classe de base avec les paramètres requis (dans mon cas un EndpointConfiguration énumération a été générée pour passer au constructeur - peut-être que votre implémentation ne l'aura pas)
• Définit les en-têtes qui doivent être attachés à chaque demande
• S'attache AddHttpHeaderMessageEndpointBehavioraux Endpointcomportements du client

public class Client : MySoapClient
{
    public Client(string apiKey) : base(EndpointConfiguration.SomeConfiguration)
    {
        var headers = new Dictionary<string, string>
        {
            ["x-api-key"] = apiKey
        };

        var behaviour = new AddHttpHeaderMessageEndpointBehavior(headers);
        Endpoint.EndpointBehaviors.Add(behaviour);
    }
}

Enfin, utilisez votre client!

var apiKey = 'XXXXXXXXXXXXXXXXXXXXXXXXX';
var client = new Client (apiKey);
var result = client.SomeRequest()

La requête HTTP résultante doit contenir vos en-têtes HTTP et ressembler à ceci:

POST http://localhost:8888/api/soap HTTP/1.1
Cache-Control: no-cache, max-age=0
Connection: Keep-Alive
Content-Type: text/xml; charset=utf-8
Accept-Encoding: gzip, deflate
x-api-key: XXXXXXXXXXXXXXXXXXXXXXXXX
SOAPAction: "http://localhost:8888/api/ISoapService/SomeRequest"
Content-Length: 144
Host: localhost:8888

<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
  <s:Body>
    <SomeRequestxmlns="http://localhost:8888/api/"/>
  </s:Body>
</s:Envelope>

Un peu tard à la fête mais Juval Lowy aborde ce scénario exact dans son livre et le ServiceModelEx associé bibliothèque .

Fondamentalement, il définit les spécialisations ClientBase et ChannelFactory qui permettent de spécifier des valeurs d'en-tête de type sécurisé. Je suggère de télécharger la source et de regarder les classes HeaderClientBase et HeaderChannelFactory.

John