Wcf hizmetimde kurucuya nasıl değer iletirim?

Hizmetimi uygulayan sınıftaki kurucuya değerler iletmek istiyorum.

Ancak ServiceHost, oluşturucusuna hangi bağımsız değişkenlerin iletileceğini değil, yalnızca oluşturulacak türün adını iletmeme izin veriyor.

Hizmet nesnemi oluşturan bir fabrikaya geçebilmek istiyorum.

Şimdiye kadar bulduklarım:

• Aradığımdan daha fazlası olan ve ihtiyaçlarım için aşırı karmaşık görünen WCF Bağımlılık Enjeksiyon Davranışı .

Sen özel bir kombinasyonunu uygulamak gerekir ServiceHostFactory, ServiceHostve IInstanceProvider.

Bu yapıcı imzasına sahip bir hizmet verildiğinde:

public MyService(IDependency dep)

İşte MyService'i çalıştırabilecek bir örnek:

public class MyServiceHostFactory : ServiceHostFactory
{
    private readonly IDependency dep;

    public MyServiceHostFactory()
    {
        this.dep = new MyClass();
    }

    protected override ServiceHost CreateServiceHost(Type serviceType,
        Uri[] baseAddresses)
    {
        return new MyServiceHost(this.dep, serviceType, baseAddresses);
    }
}

public class MyServiceHost : ServiceHost
{
    public MyServiceHost(IDependency dep, Type serviceType, params Uri[] baseAddresses)
        : base(serviceType, baseAddresses)
    {
        if (dep == null)
        {
            throw new ArgumentNullException("dep");
        }

        foreach (var cd in this.ImplementedContracts.Values)
        {
            cd.Behaviors.Add(new MyInstanceProvider(dep));
        }
    }
}

public class MyInstanceProvider : IInstanceProvider, IContractBehavior
{
    private readonly IDependency dep;

    public MyInstanceProvider(IDependency dep)
    {
        if (dep == null)
        {
            throw new ArgumentNullException("dep");
        }

        this.dep = dep;
    }

    #region IInstanceProvider Members

    public object GetInstance(InstanceContext instanceContext, Message message)
    {
        return this.GetInstance(instanceContext);
    }

    public object GetInstance(InstanceContext instanceContext)
    {
        return new MyService(this.dep);
    }

    public void ReleaseInstance(InstanceContext instanceContext, object instance)
    {
        var disposable = instance as IDisposable;
        if (disposable != null)
        {
            disposable.Dispose();
        }
    }

    #endregion

    #region IContractBehavior Members

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

    public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
    }

    public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
    {
        dispatchRuntime.InstanceProvider = this;
    }

    public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
    {
    }

    #endregion
}

MyService.svc dosyanıza MyServiceHostFactory'yi kaydedin veya MyServiceHost'u kendi kendine barındırma senaryoları için doğrudan kodda kullanın.

Bu yaklaşımı kolayca genelleştirebilirsiniz ve aslında bazı DI Container'lar bunu sizin için zaten yaptı (işaret: Windsor'un WCF Tesisi).

Basitçe kendi örneğinizi oluşturabilir ve Servicebu örneği ServiceHostnesneye aktarabilirsiniz . Yapmanız gereken tek şey [ServiceBehaviour], hizmetinize bir öznitelik eklemek ve döndürülen tüm nesneleri [DataContract]öznitelik ile işaretlemektir .

İşte bir model:

namespace Service
{
    [ServiceContract]
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class MyService
    {
        private readonly IDependency _dep;

        public MyService(IDependency dep)
        {
            _dep = dep;
        }

        public MyDataObject GetData()
        {
            return _dep.GetData();
        }
    }

    [DataContract]
    public class MyDataObject
    {
        public MyDataObject(string name)
        {
            Name = name;
        }

        public string Name { get; private set; }
    }

    public interface IDependency
    {
        MyDataObject GetData();
    }
}

ve kullanım:

var dep = new Dependecy();
var myService = new MyService(dep);
var host = new ServiceHost(myService);

host.Open();

Umarım bu, birileri için hayatı kolaylaştırır.

Mark'ın cevabı IInstanceProviderdoğru.

Özel ServiceHostFactory'yi kullanmak yerine özel bir öznitelik de kullanabilirsiniz (örneğin MyInstanceProviderBehaviorAttribute). Aşağıdakilerden türetin Attribute, uygulamasını sağlayın IServiceBehaviorve aşağıdaki IServiceBehavior.ApplyDispatchBehaviorgibi uygulayın

// YourInstanceProvider implements IInstanceProvider
var instanceProvider = new YourInstanceProvider(<yourargs>);

foreach (ChannelDispatcher dispatcher in serviceHostBase.ChannelDispatchers)
{
    foreach (var epDispatcher in dispatcher.Endpoints)
    {
        // this registers your custom IInstanceProvider
        epDispatcher.DispatchRuntime.InstanceProvider = instanceProvider;
    }
}

Ardından, özniteliği hizmet uygulama sınıfınıza uygulayın

[ServiceBehavior]
[MyInstanceProviderBehavior(<params as you want>)]
public class MyService : IMyContract

Üçüncü seçenek: Yapılandırma dosyasını kullanarak bir servis davranışı da uygulayabilirsiniz.

Mark'ın cevabına göre çalıştım, ancak (en azından benim senaryom için) gereksiz derecede karmaşıktı. Yapıcılardan biri, ServiceHostdoğrudan ServiceHostFactoryuygulamadan aktarabileceğiniz bir hizmet örneğini kabul eder .

Mark'ın örneğini üstlenmek için şöyle görünecektir:

public class MyServiceHostFactory : ServiceHostFactory
{
    private readonly IDependency _dep;

    public MyServiceHostFactory()
    {
        _dep = new MyClass();
    }

    protected override ServiceHost CreateServiceHost(Type serviceType,
        Uri[] baseAddresses)
    {
        var instance = new MyService(_dep);
        return new MyServiceHost(instance, serviceType, baseAddresses);
    }
}

public class MyServiceHost : ServiceHost
{
    public MyServiceHost(MyService instance, Type serviceType, params Uri[] baseAddresses)
        : base(instance, baseAddresses)
    {
    }
}

Vidala… Bağımlılık enjeksiyonu ve servis bulma modellerini harmanladım (ama çoğunlukla bağımlılık enjeksiyonu ve hatta kurucuda gerçekleşiyor, bu da salt okunur duruma sahip olabileceğiniz anlamına geliyor).

public class MyService : IMyService
{
    private readonly Dependencies _dependencies;

    // set this before creating service host. this can use your IOC container or whatever.
    // if you don't like the mutability shown here (IoC containers are usually immutable after being configured)
    // you can use some sort of write-once object
    // or more advanced approach like authenticated access
    public static Func<Dependencies> GetDependencies { get; set; }     
    public class Dependencies
    {
        // whatever your service needs here.
        public Thing1 Thing1 {get;}
        public Thing2 Thing2 {get;}

        public Dependencies(Thing1 thing1, Thing2 thing2)
        {
            Thing1 = thing1;
            Thing2 = thing2;
        }
    }

    public MyService ()
    {
        _dependencies = GetDependencies(); // this will blow up at run time in the exact same way your IoC container will if it hasn't been properly configured up front. NO DIFFERENCE
    }
}

Hizmetin bağımlılıkları, iç içe geçmiş Dependenciessınıfının sözleşmesinde açıkça belirtilmiştir . Bir IoC konteyneri kullanıyorsanız (WCF karmaşasını sizin için halihazırda düzeltmeyen bir konteynır), Dependenciesservis yerine örnek oluşturmak için onu yapılandırabilirsiniz . Bu şekilde, WCF tarafından empoze edilen çok fazla çemberden atlamak zorunda kalmazken, kabınızın size verdiği sıcak bulanık hissi elde edersiniz.

Bu yaklaşım yüzünden hiç uykumu kaybetmeyeceğim. Başkası da olmamalı. Sonuçta, IoC konteyneriniz, sizin için şeyler oluşturan büyük, şişman, statik bir delege koleksiyonudur. Bir tane daha eklemek ne?

Aynı problemle karşı karşıyaydık ve aşağıdaki şekilde çözdük. Bu basit bir çözüm.

Visual Studio'da normal bir WCF servis uygulaması oluşturun ve arayüzünü kaldırın. .Cs dosyasını yerinde bırakın (sadece yeniden adlandırın) ve o cs dosyasını açın ve arayüzün adını, hizmet mantığını uygulayan orijinal sınıf adınızla değiştirin (bu şekilde, hizmet sınıfı, kalıtımı kullanır ve gerçek uygulamanızı değiştirir). Aşağıdaki gibi temel sınıfın yapıcılarını çağıran varsayılan bir kurucu ekleyin:

public class Service1 : MyLogicNamespace.MyService
{
    public Service1() : base(new MyDependency1(), new MyDependency2()) {}
}

MyService temel sınıfı, hizmetin gerçek uygulamasıdır. Bu temel sınıf, parametresiz bir kurucuya sahip olmamalı, yalnızca bağımlılıkları kabul eden parametrelere sahip oluşturuculara sahip olmalıdır.

Hizmet, orijinal MyService yerine bu sınıfı kullanmalıdır.

Bu basit bir çözüm ve bir cazibe gibi çalışıyor: -D

Bu çok yararlı bir çözümdü - özellikle acemi bir WCF kodlayıcı olan biri için. Bunu IIS tarafından barındırılan bir hizmet için kullanıyor olabilecek tüm kullanıcılar için küçük bir ipucu göndermek istedim. MyServiceHost'un yalnızca ServiceHost'u değil, WebServiceHost'u devralması gerekir .

public class MyServiceHost : WebServiceHost
{
    public MyServiceHost(MyService instance, Type serviceType, params Uri[] baseAddresses)
        : base(instance, baseAddresses)
    {
    }
}

Bu, IIS'deki uç noktalarınız için gerekli tüm bağlamaları vb. Oluşturacaktır.

Türümün statik değişkenlerini kullanıyorum. Bunun en iyi yol olduğundan emin değilim, ama benim için çalışıyor:

public class MyServer
{   
    public static string CustomerDisplayName;
    ...
}

Hizmet ana bilgisayarını örneklediğimde şunları yapıyorum:

protected override void OnStart(string[] args)
{
    MyServer.CustomerDisplayName = "Test customer";

    ...

    selfHost = new ServiceHost(typeof(MyServer), baseAddress);

    ....
}