¿Cómo agregar un encabezado HTTP personalizado a cada llamada WCF?

Tengo un servicio WCF que está alojado en un servicio de Windows. Los clientes que usan este servicio deben pasar un identificador cada vez que llaman a métodos de servicio (porque ese identificador es importante para lo que debe hacer el método llamado). Pensé que es una buena idea poner este identificador de alguna manera en la información del encabezado WCF.

Si es una buena idea, ¿cómo puedo agregar el identificador automáticamente a la información del encabezado? En otras palabras, cada vez que el usuario llama al método WCF, el identificador debe agregarse automáticamente al encabezado.

ACTUALIZACIÓN: Los clientes que usan el servicio WCF son aplicaciones de Windows y aplicaciones de Windows Mobile (usando Compact Framework).

La ventaja de esto es que se aplica a todas las llamadas.

Cree una clase que implemente IClientMessageInspector . En el método BeforeSendRequest, agregue su encabezado personalizado al mensaje saliente. Podría verse más o menos así:

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

Luego, cree un comportamiento de punto final que aplique el inspector de mensajes al tiempo de ejecución del cliente. Puede aplicar el comportamiento mediante un atributo o mediante la configuración utilizando un elemento de extensión de comportamiento.

Aquí hay un gran ejemplo de cómo agregar un encabezado de agente de usuario HTTP a todos los mensajes de solicitud. Estoy usando esto en algunos de mis clientes. También puede hacer lo mismo en el lado del servicio implementando IDispatchMessageInspector .

¿Es esto lo que tenías en mente?

Actualización: encontré esta lista de características de WCF que son compatibles con el marco compacto. Creo que los inspectores de mensajes clasificados como 'Extensibilidad de canal' que, según esta publicación, son compatibles con el marco compacto.

Lo agrega a la llamada 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
}

Y luego, del lado del servidor, lo agarras usando:

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

Si solo desea agregar el mismo encabezado a todas las solicitudes al servicio, ¡puede hacerlo sin ninguna codificación!
Simplemente agregue el nodo de encabezados con los encabezados requeridos debajo del nodo de punto final en el archivo de configuración de su cliente

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

Aquí hay otra solución útil para agregar manualmente encabezados HTTP personalizados a la solicitud WCF de su cliente utilizando ChannelFactorycomo proxy. Esto tendría que hacerse para cada solicitud, pero es suficiente como una demostración simple si solo necesita probar unitariamente su proxy en preparación para plataformas que no sean .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... 
}

Esto es similar a la respuesta de NimsDotNet, pero muestra cómo hacerlo mediante programación.

Simplemente agregue el encabezado al enlace

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

Esto es lo que funcionó para mí, adaptado de Agregar encabezados HTTP a llamadas 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)
    {
    }
}

Después de declarar estas clases, puede agregar el nuevo comportamiento a su cliente WCF de esta manera:

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

Esto funciona para mi

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

Los enlaces de contexto en .NET 3.5 pueden ser justo lo que está buscando. Hay tres listos para usar: BasicHttpContextBinding, NetTcpContextBinding y WSHttpContextBinding. El protocolo de contexto básicamente pasa pares clave-valor en el encabezado del mensaje. Consulte el artículo Gestión del estado con servicios duraderos en la revista MSDN.

Si entiendo su requisito correctamente, la respuesta simple es: no puede.

Esto se debe a que el cliente del servicio WCF puede ser generado por cualquier tercero que use su servicio.

SI tiene el control de los clientes de su servicio, puede crear una clase de cliente base que agregue el encabezado deseado y herede el comportamiento en las clases de trabajo.

Puede especificar encabezados personalizados en MessageContract .

También puede usar encabezados <endpoint> que se almacenan en el archivo de configuración y se copiarán en el encabezado de todos los mensajes enviados por el cliente / servicio. Esto es útil para agregar un encabezado estático fácilmente.

Si desea agregar encabezados HTTP personalizados a cada llamada WCF de una manera orientada a objetos, no busque más.

Al igual que en la respuesta de Mark Good y paulwhit, necesitamos una subclase IClientMessageInspectorpara inyectar los encabezados HTTP personalizados en la solicitud WCF. Sin embargo, hagamos que el inspector sea más genérico al aceptar un diccionario que contiene los encabezados que queremos agregar:

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

Al igual que en la respuesta de Mark Good y Paulwhit, necesitamos subclase IEndpointBehaviorpara inyectar nuestro HttpHeaderMessageInspectoren nuestro 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 ...
}

La última parte necesaria para finalizar nuestro enfoque orientado a objetos es crear una subclase de nuestro cliente generado automáticamente por WCF (utilicé la Guía de referencia del servicio web WCF de Microsoft para generar un cliente WCF).

En mi caso, necesito adjuntar una clave API al x-api-keyencabezado HTML.

La subclase hace lo siguiente:

• llama al constructor de la clase base con los parámetros requeridos (en mi caso, EndpointConfigurationse generó una enumeración para pasar al constructor; tal vez su implementación no tendrá esto)
• Define los encabezados que se deben adjuntar a cada solicitud
• Se adhiere AddHttpHeaderMessageEndpointBehaviora los Endpointcomportamientos del 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);
    }
}

¡Finalmente, usa tu cliente!

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

La solicitud HTTP resultante debe contener sus encabezados HTTP y tener un aspecto similar a este:

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 poco tarde para la fiesta, pero Juval Lowy aborda este escenario exacto en su libro y la biblioteca ServiceModelEx asociada .

Básicamente, define las especializaciones de ClientBase y ChannelFactory que permiten especificar valores de encabezado de tipo seguro. Sugiero descargar la fuente y mirar las clases HeaderClientBase y HeaderChannelFactory.

Juan