¿Cómo paso valores al constructor en mi servicio wcf?

Question

Me gustaría pasar valores al constructor en la clase que implementa mi servicio.

Sin embargo, ServiceHost solo me permite pasar el nombre del tipo para crear, no los argumentos para pasar a su contrstructor.

Me gustaría poder pasar en una fábrica que crea mi objeto de servicio.

Lo que he encontrado hasta ahora:

• WCF Dependency Injection Behavior que es más de lo que yo estoy buscando y parece ser demasiado complejo para mis necesidades.

Answer 1

Tendrá que aplicar una combinación de costumbre ServiceHostFactory, ServiceHost y IInstanceProvider.

dado un servicio con este constructor firma:

public MyService(IDependency dep) 

Aquí hay un ejemplo que puede girar MyService:

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 
} 

Registro MyServiceHostFactory en su archivo MyService.svc, o utilizar directamente en el código MyServiceHost para escenarios de autohospedaje.

Puede generalizar fácilmente este enfoque, y de hecho algunos Contenedores DI ya lo han hecho por usted (cue: Facilidad WCF de Windsor).

Answer 2

La respuesta de Mark con el IInstanceProvider es correcta.

En lugar de utilizar la función personalizada ServiceHostFactory, también podría usar un atributo personalizado (digamos MyInstanceProviderBehaviorAttribute). Derivarla de Attribute, lo convierten en implementar IServiceBehavior y poner en práctica el método IServiceBehavior.ApplyDispatchBehavior como

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

A continuación, aplicar el atributo a la clase de implementación del servicio

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

La tercera opción: también se puede aplicar un comportamiento en servicio usando el archivo de configuración.

Answer 3

He trabajado a partir de la respuesta de Mark, pero (para mi escenario al menos), fue innecesariamente complejo. Uno de los constructores ServiceHost acepta una instancia del servicio, que puede pasar directamente desde la implementación ServiceHostFactory.

llevar a cuestas fuera ejemplo de Marcos, que se vería así:

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

Answer 4

Estábamos frente a este mismo problema y lo han resuelto de la siguiente manera. Es una solución simple.

En Visual Studio simplemente cree una aplicación de servicio WCF normal y elimine su interfaz. Deje el archivo .cs en su lugar (simplemente renómbrelo) y abra ese archivo cs y reemplace el nombre de la interfaz con su nombre de clase original que implementa la lógica del servicio (de esta forma, la clase de servicio usa la herencia y reemplaza su implementación real).Añadir un constructor predeterminado que llama a los constructores de la clase base, como esto: la clase base

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

El MyService es la implementación real del servicio. Esta clase base no debe tener un constructor sin parámetros, sino solo constructores con parámetros que acepten las dependencias.

El servicio debe utilizar esta clase en lugar del MyService original.

Es una solución simple y funciona como un encanto: -D

Answer 5

utilizo variables estáticas de mi tipo. No estoy seguro si esta es la mejor manera, pero funciona para mí:

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

Cuando crear una instancia de host de servicio hago lo siguiente:

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

    ... 

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

    .... 
} 

Answer 6

Usted puede simplemente crear y instancia de su Service y pase esa instancia al objeto ServiceHost. Lo único que debe hacer es agregar un atributo [ServiceBehaviour] para su servicio y marcar todos los objetos devueltos con el atributo [DataContract].

Aquí es una maqueta:

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

y el uso:

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

host.Open(); 

espero que esto hará más fácil la vida a alguien.

Answer 7

Esta fue una solución muy útil, especialmente para alguien que es un programador novato de WCF. Quise publicar un pequeño consejo para los usuarios que podrían estar usando esto para un servicio hospedado por IIS. MyServiceHost necesita heredar WebServiceHost, no solo ServiceHost.

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

Esto creará todos los enlaces necesarios, etc. para sus puntos finales en IIS.

Answer 8

Tornillo ... Mezclé los patrones de inyección de dependencia y localizador de servicio (pero sobre todo sigue siendo inyección de dependencia e incluso tiene lugar en el constructor, lo que significa que puede tener estado de solo lectura).

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

Las dependencias del servicio, claramente especificados en el contrato de está anidado Dependencies clase. Si está utilizando un contenedor IoC (uno que aún no soluciona el desastre de WCF), puede configurarlo para crear la instancia Dependencies en lugar del servicio. De esta forma obtienes la cálida sensación difusa que te proporciona tu contenedor sin tener que saltar demasiados aros impuestos por WCF.

No voy a perder el sueño con este enfoque. Tampoco nadie más. Después de todo, tu contenedor de IoC es una gran colección de delegados estáticos que crean cosas para ti. ¿Qué está agregando uno más?