C# 在WCF ServiceHost中提供工厂而不是类型

有没有办法扩展

ServiceHost

，以便它接受工厂

我希望在不涉及服务实现的情况下，使用动态服务代理对WCF调用进行一些预处理

编辑

现在创建的

ServiceHost

如下所示

var host = new ServiceHost(typeof(MyService));

我想用这样的方法

var factory = new ServiceProxyFactory<MyService>();
var host = new MyServiceHost(typeof(MyService), factory);

var factory=new ServiceProxyFactory（）；
var host=新的MyServiceHost（typeof（MyService），工厂）；

您所描述的在.NET中是不可能实现的

您可以实现，它允许您自定义ServiceHost的行为和/或允许您检查/修改任何入站和出站消息。。。如果你真的想实现某种“动态路由”，那么总有

其他选项（尽管不是100%解决方案）：

编辑-我的立场得到纠正：

实际上不可能使用普通工厂，但WCF提供了在

服务

或

端点

级别插入

IInstanceProvider

的可能性

有关更多参考，请参阅以下链接

---

您所描述的在.NET中是不可能实现的
您可以实现，它允许您自定义ServiceHost的行为和/或允许您检查/修改任何入站和出站消息。。。如果你真的想实现某种“动态路由”，那么总有
其他选项（尽管不是100%解决方案）：

编辑-我的立场得到纠正：

实际上不可能使用普通工厂，但WCF提供了在

服务

或

端点

级别插入

IInstanceProvider

的可能性
有关更多参考，请参阅以下链接
---

我要找的界面是

公共类MyServiceInstanceProvider:IInstanceProvider其中TService:new（）
{
公共对象GetInstance（InstanceContext InstanceContext，System.ServiceModel.Channel.Message）
{
返回ServiceFactory.Create（）；
}
公共对象GetInstance（InstanceContext InstanceContext）
{
返回ServiceFactory.Create（）；
}
public void ReleaseInstance（InstanceContext InstanceContext，对象实例）
{
返回；
}
}
公共类MyEndpointBehavior:IEndpointBehavior，其中TService:new（）
{
public void AddBindingParameters（ServiceEndpoint端点、BindingParameterCollection bindingParameters）
{
返回；
}
public void ApplyClientBehavior（ServiceEndpoint端点、ClientRuntime ClientRuntime）
{
返回；
}
公共无效ApplyDispatchBehavior（ServiceEndpoint端点、EndpointDispatcher端点Dispatcher）
{
endpointDispatcher.DispatchRuntime.InstanceProvider=新的MyServiceInstanceProvider（）；
}
公共void验证（ServiceEndpoint）
{
返回；
}
}
公共类MyServiceHost:ServiceHost，其中TService:new（）
{
公共MyServiceHost（参数Uri[]基地址）
：base（typeof（TService），baseAddresses）
{            
}
公共重写System.Collections.ObjectModel.ReadOnlyCollection AddDefaultEndpoints（）
{
var endpoints=base.AddDefaultEndpoints（）；
foreach（端点中的var端点）
{
添加（新的MyEndpointBehavior（））；
}
返回端点；
}
公共覆盖无效AddServiceEndpoint（ServiceEndpoint端点）
{
base.AddServiceEndpoint（端点）；
添加（新的MyEndpointBehavior（））；
}
}

我要找的界面是

公共类MyServiceInstanceProvider:IInstanceProvider其中TService:new（）
{
公共对象GetInstance（InstanceContext InstanceContext，System.ServiceModel.Channel.Message）
{
返回ServiceFactory.Create（）；
}
公共对象GetInstance（InstanceContext InstanceContext）
{
返回ServiceFactory.Create（）；
}
public void ReleaseInstance（InstanceContext InstanceContext，对象实例）
{
返回；
}
}
公共类MyEndpointBehavior:IEndpointBehavior，其中TService:new（）
{
public void AddBindingParameters（ServiceEndpoint端点、BindingParameterCollection bindingParameters）
{
返回；
}
public void ApplyClientBehavior（ServiceEndpoint端点、ClientRuntime ClientRuntime）
{
返回；
}
公共无效ApplyDispatchBehavior（ServiceEndpoint端点、EndpointDispatcher端点Dispatcher）
{
endpointDispatcher.DispatchRuntime.InstanceProvider=新的MyServiceInstanceProvider（）；
}
公共void验证（ServiceEndpoint）
{
返回；
}
}
公共类MyServiceHost:ServiceHost，其中TService:new（）
{
公共MyServiceHost（参数Uri[]基地址）
：base（typeof（TService），baseAddresses）
{            
}
公共重写System.Collections.ObjectModel.ReadOnlyCollection AddDefaultEndpoints（）
{
var endpoints=base.AddDefaultEndpoints（）；
foreach（端点中的var端点）
{
添加（新的MyEndpointBehavior（））；
}
返回端点；
}
公共覆盖无效AddServiceEndpoint（ServiceEndpoint端点）
{
base.AddServiceEndpoint（端点）；
添加（新的MyEndpointBehavior（））；
}
}

不，这是不可能的。有一种机制可以为服务主机创建一个工厂，但是没有办法让服务主机在工厂中创建实际的服务instances@marc_s我也这么想，但是

public class MyServiceInstanceProvider<TService> : IInstanceProvider where TService : new()
{

    public object GetInstance(InstanceContext instanceContext, System.ServiceModel.Channels.Message message)
    {
        return ServiceFactory.Create<TService>();
    }

    public object GetInstance(InstanceContext instanceContext)
    {
        return ServiceFactory.Create<TService>();
    }

    public void ReleaseInstance(InstanceContext instanceContext, object instance)
    {
        return;
    }
}

public class MyEndpointBehavior<TService> : IEndpointBehavior where TService : new()
{

    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
    {
        return;
    }

    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
        return;
    }

    public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
    {
        endpointDispatcher.DispatchRuntime.InstanceProvider = new MyServiceInstanceProvider<TService>();
    }

    public void Validate(ServiceEndpoint endpoint)
    {
        return;
    }
}

public class MyServiceHost<TService> : ServiceHost where TService : new()
{
    public MyServiceHost(params Uri[] baseAddresses)
        :base(typeof(TService), baseAddresses)
    {            
    }

    public override System.Collections.ObjectModel.ReadOnlyCollection<ServiceEndpoint> AddDefaultEndpoints()
    {
        var endpoints = base.AddDefaultEndpoints();

        foreach (var endpoint in endpoints)
        {
            endpoint.Behaviors.Add(new MyEndpointBehavior<TService>());
        }

        return endpoints;
    }

    public override void AddServiceEndpoint(ServiceEndpoint endpoint)
    {
        base.AddServiceEndpoint(endpoint);
        endpoint.Behaviors.Add(new MyEndpointBehavior<TService>());
    }

}