如何将值传递给 wcf 服务上的构造函数？

You'll need to implement a combination of custom ServiceHostFactory, ServiceHost and IInstanceProvider.

Given a service with this constructor signature:

public MyService(IDependency dep)

Here's an example that can spin up 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
}

Register MyServiceHostFactory in your MyService.svc file, or use MyServiceHost directly in code for self-hosting scenarios.

You can easily generalize this approach, and in fact some DI Containers have already done this for you (cue: Windsor's WCF Facility).

Mark's answer with the IInstanceProvider is correct.

Instead of using the custom ServiceHostFactory you could also use a custom attribute (say MyInstanceProviderBehaviorAttribute). Derive it from Attribute, make it implement IServiceBehavior and implement the IServiceBehavior.ApplyDispatchBehavior method like

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

Then, apply the attribute to your service implementation class

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

The third option: you can also apply a service behavior using the configuration file.

I worked from Mark's answer, but (for my scenario at least), it was needlessly complex. One of the ServiceHost constructors accepts an instance of the service, which you can pass in directly from the ServiceHostFactory implementation.

To piggyback off Mark's example, it would look like this:

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

We were facing this same problem and have solved it in the following manner. It is a simple solution.

In Visual Studio just create a normal WCF service application and remove it's interface. Leave the .cs file in place (just rename it) and open that cs file and replace the name of the interface with your original class name which implements the service logic (this way the service class uses inheritance and replaces your actual implementation). Add a default constructor that calls the base class's constructors, like this:

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

The MyService base class is the actual implementation of the service. This base class should not have a parameterless constructor, but only constructors with parameters that accept the dependencies.

The service should use this class instead of the original MyService.

It's a simple solution and works like a charm :-D

I use static variables of my type. Not sure if this is the best way, but it works for me:

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

When I instantiate service host I do the following:

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


...


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


....
}

You can simply create and instance of your Service and pass that instance to the ServiceHost object. The only thing you have to do is to add a [ServiceBehaviour] attribute for your service and mark all returned objects with [DataContract] attribute.

Here is a mock up:

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

and the usage:

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


host.Open();

I hope this will make life easier for someone.

This was a very helpful solution - especially for someone who is a novice WCF coder. I did want to post a little tip for any users who might be using this for an IIS-hosted service. MyServiceHost needs to inherit WebServiceHost, not just ServiceHost.

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

This will create all the necessary bindings, etc for your endpoints in IIS.

Screw it… I blended the dependency injection and service locator patterns (but mostly it's still dependency injection and it even takes place in the constructor which means you can have read-only state).

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

The dependencies of the service are clearly specified in the contract of it's nested Dependencies class. If you are using an IoC container (one that doesn't already fix the WCF mess for you), you can configure it to create the Dependencies instance instead of the service. This way you get the warm fuzzy feeling that your container gives you while also not having to jump through too many hoops imposed by WCF.

I'm not going to lose any sleep over this approach. Neither should anyone else. After all, you're IoC container is a big, fat, static collection of delegates that creates stuff for you. What's adding one more?

Create your instanced service with its dependencies (let's call it myService), then open up your ServiceHost like so:

var myService = new Service(argumentOne, argumentTwo, . . . etc.);
var host = new WebServiceHost(myService, new Uri("http://localhost:80"));
var behavior = host.Description.Behaviors.Find<ServiceBehaviorAttribute>();
behavior.InstanceContextMode = InstanceContextMode.Single;
host.Open();