Jak dodać niestandardowy nagłówek HTTP do każdego połączenia WCF?

Dodajesz go do wywołania używając:

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
}

A potem po stronie serwera chwytasz go używając:

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

Jeśli chcesz dodać ten sam nagłówek do wszystkich żądań do serwisu, możesz to zrobić bez żadnego kodowania!
Po prostu Dodaj węzeł nagłówkowy z wymaganymi nagłówkami pod węzłem końcowym w pliku konfiguracyjnym klienta

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

Oto kolejne pomocne rozwiązanie do ręcznego dodawania niestandardowych nagłówków HTTP do żądania WCF klienta za pomocą ChannelFactory jako proxy. To musi być zrobione dla każdego żądania, ale wystarczy jako proste demo, jeśli po prostu trzeba przetestować swój serwer proxy w przygotowaniu do non-.NET perony.

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

Jest to podobne do NimsDotNet answer, ale pokazuje, jak to zrobić programowo.

Po prostu dodaj nagłówek do powiązania

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

Możesz określić własne nagłówki w MessageContract .

Możesz również użyć nagłówków, które są przechowywane w pliku konfiguracyjnym i będą kopiowane allong w nagłówku wszystkich wiadomości wysyłanych przez Klienta/usługę. Jest to przydatne, aby łatwo dodać statyczny nagłówek.

Context bindings W.NET 3.5 może być właśnie tym, czego szukasz. Istnieją trzy wyjścia: BasicHttpContextBinding, NetTcpContextBinding i WSHttpContextBinding. Protokół kontekstowy zasadniczo przekazuje pary klucz-wartość w nagłówku wiadomości. Zapoznaj się z artykułem zarządzanie państwem za pomocą trwałych usług W magazynie MSDN.

Jeśli dobrze rozumiem twoje wymagania, prosta odpowiedź brzmi: nie możesz.

Dzieje się tak dlatego, że klient usługi WCF może zostać wygenerowany przez dowolną stronę trzecią, która korzysta z Twojej usługi.

Jeśli masz kontrolę nad klientami swojej usługi, możesz utworzyć bazową klasę klienta, która dodaje żądany nagłówek i dziedziczy zachowanie na klasach worker.

To mi się udało, zaadaptowane z Dodawanie nagłówków HTTP do wywołań 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)
    {
    }
}

Po zadeklarowaniu tych klas możesz dodać nowe zachowanie do swojego klienta WCF w następujący sposób:

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

To działa dla mnie

TestService.Recostitionclient _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);
                }

Trochę za późno na imprezę, ale Juval Lowy omawia ten dokładny scenariusz w swojej książce i związanej z nią bibliotece ServiceModelEx.

Zasadniczo definiuje specjalizacje ClientBase i ChannelFactory, które pozwalają na określenie wartości nagłówków bezpiecznych dla typu. Proponuję pobrać źródło i zajrzeć do klas HeaderClientBase i HeaderChannelFactory.

John