Jak przekazać wartości do konstruktora w mojej usłudze wcf?

Możesz po prostu utworzyć i instancję swojego Service i przekazać tę instancję do obiektu ServiceHost. Jedyne, co musisz zrobić, to dodać atrybut [ServiceBehaviour] dla swojej usługi i oznaczyć wszystkie zwrócone obiekty atrybutem [DataContract].

Oto makieta:

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

I użycie:

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

host.Open();

Odpowiedź marka z {[2] } jest poprawna.

Zamiast używać niestandardowego ServiceHostFactory można również użyć niestandardowego atrybutu (powiedzmy MyInstanceProviderBehaviorAttribute). Wywołaj ją z Attribute, Wykonaj implementację IServiceBehavior i zaimplementuj metodę IServiceBehavior.ApplyDispatchBehavior Jak

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

Następnie zastosuj atrybut do klasy implementacji usługi

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

Trzecia opcja: możesz również zastosować zachowanie usługi za pomocą pliku konfiguracyjnego.

Pracowałem na podstawie odpowiedzi marka, ale (przynajmniej dla mojego scenariusza), było to niepotrzebnie skomplikowane. Jeden z konstruktorów ServiceHost akceptuje instancję usługi, którą można przekazać bezpośrednio z implementacji ServiceHostFactory.

Na przykładzie Marka wyglądałoby to tak:

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

Pieprzyć to ... zmieszałem wzorce dependency injection i service locator (ale głównie jest to wciąż dependency injection i nawet odbywa się w konstruktorze, co oznacza, że możesz mieć stan tylko do odczytu).

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

Zależności usługi są wyraźnie określone w umowie jej zagnieżdżonej klasy Dependencies. Jeśli używasz kontenera IoC (takiego, który nie naprawia za Ciebie bałaganu WCF), możesz skonfigurować go tak, aby utworzyć instancję Dependencies zamiast usługi. Tędy. otrzymujesz ciepłe, rozmyte uczucie, które daje twój pojemnik, a jednocześnie nie musisz przeskakiwać przez zbyt wiele obręczy nałożonych przez WCF.

To było bardzo pomocne rozwiązanie-szczególnie dla kogoś, kto jest początkującym programistą WCF. Chciałem opublikować małą wskazówkę dla użytkowników, którzy mogą używać tego w usłudze hostowanej przez IIS. MyServiceHost musi dziedziczyć WebServiceHost , a nie tylko ServiceHost.

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

Spowoduje to utworzenie wszystkich niezbędnych wiązań itp. dla punktów końcowych w IIS.

Używam zmiennych statycznych mojego typu. Nie wiem czy to najlepszy sposób, ale u mnie działa:

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

Kiedy uruchamiam host serwisu wykonuję następujące czynności:

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

    ...

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

    ....
}

Mieliśmy do czynienia z tym samym problemem i rozwiązaliśmy go w następujący sposób. Jest to proste rozwiązanie.

W Visual Studio wystarczy utworzyć zwykłą aplikację usługową WCF i usunąć jej interfejs. Zostawićplik cs na miejscu (po prostu zmień jego nazwę) i otwórz ten plik cs i zamień nazwę interfejsu na oryginalną nazwę klasy, która implementuje logikę usługi (w ten sposób Klasa service używa dziedziczenia i zastępuje rzeczywistą implementację). Dodaj domyślny konstruktor, który wywołuje konstruktory klasy bazowej, w następujący sposób:

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

Klasa bazowa MyService jest rzeczywistą implementacją usługi. Ta klasa bazowa nie powinna mieć konstruktora bez parametru, ale tylko konstruktory z parametrami, które akceptują zależności.

Usługa powinna używać tej klasy zamiast oryginalnego MyService.

To proste rozwiązanie i działa jak czar :-D