Como adicionar um cabeçalho HTTP personalizado a cada chamada do WCF?

Eu tenho um serviço WCF hospedado em um serviço do Windows. Os clientes que usam esse serviço devem passar um identificador toda vez que estão chamando métodos de serviço (porque esse identificador é importante para o que o método chamado deve fazer). Eu pensei que era uma boa idéia colocar esse identificador de alguma forma nas informações do cabeçalho do WCF.

Se for uma boa ideia, como posso adicionar o identificador automaticamente às informações do cabeçalho. Em outras palavras, sempre que o usuário chama o método WCF, o identificador deve ser adicionado automaticamente ao cabeçalho.

ATUALIZAÇÃO: os clientes que estão usando o serviço WCF são aplicativos Windows e Windows Mobile (usando o Compact Framework).

A vantagem disso é que ele é aplicado a todas as chamadas.

Crie uma classe que implemente IClientMessageInspector . No método BeforeSendRequest, adicione seu cabeçalho personalizado à mensagem de saída. Pode ser algo como isto:

    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;
}

Em seguida, crie um comportamento do nó de extremidade que aplique o inspetor de mensagens ao tempo de execução do cliente. Você pode aplicar o comportamento por meio de um atributo ou via configuração usando um elemento de extensão de comportamento.

Aqui está um ótimo exemplo de como adicionar um cabeçalho de agente do usuário HTTP a todas as mensagens de solicitação. Estou usando isso em alguns de meus clientes. Você também pode fazer o mesmo no lado do serviço implementando o IDispatchMessageInspector .

É isso que você tinha em mente?

Atualização: Encontrei esta lista de recursos do WCF suportados pela estrutura compacta. Acredito que os inspetores de mensagens classificados como 'Extensibilidade do canal', que, de acordo com este post, sejam suportados pela estrutura compacta.

Você o adiciona à chamada usando:

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
}

E então, no lado do servidor, você o pega usando:

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

Se você quiser adicionar o mesmo cabeçalho a todas as solicitações do serviço, poderá fazê-lo sem qualquer codificação!
Basta adicionar o nó de cabeçalhos com os cabeçalhos necessários no nó do nó de extremidade no arquivo de configuração do cliente

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

Aqui está outra solução útil para adicionar manualmente cabeçalhos HTTP personalizados à sua solicitação WCF do cliente usando o ChannelFactoryproxy. Isso teria que ser feito para cada solicitação, mas é suficiente como uma demonstração simples se você só precisar testar seu proxy de unidade em preparação para plataformas que não sejam do .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... 
}

Isso é semelhante à resposta do NimsDotNet, mas mostra como fazê-lo programaticamente.

Basta adicionar o cabeçalho à encadernação

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") 
                     });

Isso é o que funcionou para mim, adaptado de Adicionando cabeçalhos HTTP a chamadas 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)
    {
    }
}

Depois de declarar essas classes, você pode adicionar o novo comportamento ao seu cliente WCF assim:

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

Isso funciona para mim

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);
}

As ligações de contexto no .NET 3.5 podem ser exatamente o que você está procurando. Existem três prontos para uso: BasicHttpContextBinding, NetTcpContextBinding e WSHttpContextBinding. O protocolo de contexto basicamente passa pares de valores-chave no cabeçalho da mensagem. Confira o artigo Gerenciando Estado com Serviços Duráveis na revista MSDN.

Se entendi corretamente sua exigência, a resposta simples é: você não pode.

Isso ocorre porque o cliente do serviço WCF pode ser gerado por terceiros que usam seu serviço.

Se você tiver controle dos clientes do seu serviço, poderá criar uma classe de cliente base que adicione o cabeçalho desejado e herda o comportamento nas classes de trabalho.

Você pode especificar cabeçalhos personalizados no MessageContract .

Você também pode usar os cabeçalhos <endpoint> armazenados no arquivo de configuração e serão copiados o tempo todo no cabeçalho de todas as mensagens enviadas pelo cliente / serviço. Isso é útil para adicionar algum cabeçalho estático facilmente.

Se você deseja adicionar cabeçalhos HTTP personalizados a todas as chamadas WCF de maneira orientada a objetos, não procure mais.

Assim como na resposta de Mark Good e paulwhit, precisamos subclasses IClientMessageInspectorpara injetar os cabeçalhos HTTP personalizados na solicitação do WCF. No entanto, vamos tornar o inspetor mais genérico, aceitando um dicionário contendo os cabeçalhos que queremos adicionar:

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

Assim como na resposta de Mark Good e paulwhit, precisamos subclasses IEndpointBehaviorpara injetar nossa HttpHeaderMessageInspectorno nosso cliente 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 ...
}

A última parte necessária para concluir nossa abordagem orientada a objetos é criar uma subclasse de nosso cliente gerado automaticamente pelo WCF (usei o Guia de Referência de Serviços da Web WCF da Microsoft para gerar um cliente WCF).

No meu caso, preciso anexar uma chave de API ao diretório x-api-key cabeçalho HTML.

A subclasse faz o seguinte:

• chama o construtor da classe base com os parâmetros necessários (no meu caso, um EndpointConfiguration enum foi gerado para passar para o construtor - talvez sua implementação não tenha isso)
• Define os cabeçalhos que devem ser anexados a todas as solicitações
• Anexa-se AddHttpHeaderMessageEndpointBehavioraos Endpointcomportamentos do cliente

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);
    }
}

Por fim, use seu cliente!

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

A solicitação HTTP resultante deve conter seus cabeçalhos HTTP e ter a seguinte aparência:

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>

Um pouco atrasado para a festa, mas Juval Lowy aborda esse cenário exato em seu livro e na biblioteca ServiceModelEx associada .

Basicamente, ele define as especializações ClientBase e ChannelFactory que permitem especificar valores de cabeçalho seguros para tipos. Sugiro baixar o código-fonte e examinar as classes HeaderClientBase e HeaderChannelFactory.

John