Dependency injection LightWebRequest拦截

这是特定于LightInject的拦截。是否可以基于PerWebRequest生存期应用拦截逻辑，以便根据用户输入有条件地打开/关闭拦截逻辑？像这样的东西

    public static void Configure()
    {
        var serviceContainer = new ServiceContainer();
        serviceContainer.EnablePerWebRequestScope();
        serviceContainer.Register<ITraceSwitcher, TraceSwitcher>(new PerScopeLifetime());
        serviceContainer.Register<IMyService, MyService>(new PerScopeLifetime());
        serviceContainer.Intercept(x => x.ServiceType == typeof(IMyService), (y, z) => DefineProxyType(z, IsTracingEnabled));

        ServiceLocator.SetLocatorProvider(() => new LightInjectServiceLocator(serviceContainer));
    }

    private static void DefineProxyType(ProxyDefinition proxyDefinition, Func<bool> isTracingEnabled)
    {
        if (isTracingEnabled())
            proxyDefinition.Implement(() => new MyServiceInterceptor(), m => m.Name == "SomeMethod");
    }

    private static bool IsTracingEnabled()
    {
        var traceSwitcher = ServiceLocator.Current.GetInstance<ITraceSwitcher>();
        return traceSwitcher.IsTracingEnabled();
    }

publicstaticvoidconfigure（）
{
var serviceContainer=新serviceContainer（）；
serviceContainer.EnablePerWebRequestScope（）；
Register（newPerscopeLifetime（））；
Register（newPerscopeLifetime（））；
截取（x=>x.ServiceType==typeof（IMyService），（y，z）=>defineProxy类型（z，Istracinabled））；
setLocator提供程序（（）=>新的LightInjectServiceLocator（serviceContainer））；
}
私有静态void DefineProxyType（ProxyDefinition ProxyDefinition，Func IstracinEnabled）
{
if（IstracinEnabled（））
proxyDefinition.Implement（（）=>newmyServiceInterceptor（），m=>m.Name==“SomeMethod”）；
}
私有静态布尔IstracinEnabled（）
{
var traceSwitcher=ServiceLocator.Current.GetInstance（）；
返回traceSwitcher.IsTracingEnabled（）；
}

现在，因为IMyService life被定义为PerWebRequest，所以它是为每个web请求创建的，我的印象是，它每次创建MyService实例时都会调用Intercept方法，这样它就可以根据用户启用还是禁用跟踪来动态地决定应用拦截逻辑。然而，当IMyService实例被请求时，它第一次似乎只调用一次Intercept方法，并且对于所有后续请求，它重用相同的拦截机制

我还知道我可以在MyServiceInterceptor中使用ITraceSwitcher逻辑，然后决定在那里使用或绕过拦截逻辑，但如果禁用跟踪以避免通过反射进行代理调用的开销，我想避免首先创建代理，但这只有在为每个web请求调用拦截方法时才可能。请让我知道这是可行的还是有更好的方法

谢谢

---

Syed Danish。

您可以将Istracinabled方法调用直接放入谓词中，该谓词决定是否应该拦截服务。仅当代理类型与谓词匹配时，才会创建代理类型

using LightInject;
using LightInject.Interception;

class Program
{
    static void Main(string[] args)
    {

        var container = new ServiceContainer();
        container.Register<IFoo, Foo>();
        container.Intercept(sr => sr.ServiceType == typeof(IFoo) && IsTracingEnabled(), (factory, definition) => DefineProxyType(definition));

        var foo = container.GetInstance<IFoo>();
    }

    private static void DefineProxyType(ProxyDefinition proxyDefinition)
    {            
        proxyDefinition.Implement(() => new SampleInterceptor(), m => m.Name == "SomeMethod");
    }

    private static bool IsTracingEnabled()
    {
        return true;
    }
}

public class SampleInterceptor : IInterceptor
{
    public object Invoke(IInvocationInfo invocationInfo)
    {
        return invocationInfo.Proceed();
    }
}

public interface IFoo { }

public class Foo : IFoo { }

使用LightInject；
使用LightInject.拦截；
班级计划
{
静态void Main（字符串[]参数）
{
var container=新的ServiceContainer（）；
container.Register（）；
container.Intercept（sr=>sr.ServiceType==typeof（IFoo）和&IsTracingEnabled（），（工厂，定义）=>defineProxy类型（定义））；
var foo=container.GetInstance（）；
}
私有静态void DefineProxyType（ProxyDefinition ProxyDefinition）
{            
proxyDefinition.Implement（（）=>newsampleinterceptor（），m=>m.Name==“SomeMethod”）；
}
私有静态布尔IstracinEnabled（）
{
返回true；
}
}
公共类样本拦截器：IInterceptor
{
公共对象调用（IInvocationInfo调用信息）
{
返回invocationInfo.procedure（）；
}
}
公共接口IFoo{}
公共类Foo:IFoo{}

致意

---

Bernhard Richter

您可以将Istracinabled方法调用直接放入谓词中，该谓词决定是否应该拦截服务。仅当代理类型与谓词匹配时，才会创建代理类型

using LightInject;
using LightInject.Interception;

class Program
{
    static void Main(string[] args)
    {

        var container = new ServiceContainer();
        container.Register<IFoo, Foo>();
        container.Intercept(sr => sr.ServiceType == typeof(IFoo) && IsTracingEnabled(), (factory, definition) => DefineProxyType(definition));

        var foo = container.GetInstance<IFoo>();
    }

    private static void DefineProxyType(ProxyDefinition proxyDefinition)
    {            
        proxyDefinition.Implement(() => new SampleInterceptor(), m => m.Name == "SomeMethod");
    }

    private static bool IsTracingEnabled()
    {
        return true;
    }
}

public class SampleInterceptor : IInterceptor
{
    public object Invoke(IInvocationInfo invocationInfo)
    {
        return invocationInfo.Proceed();
    }
}

public interface IFoo { }

public class Foo : IFoo { }

使用LightInject；
使用LightInject.拦截；
班级计划
{
静态void Main（字符串[]参数）
{
var container=新的ServiceContainer（）；
container.Register（）；
container.Intercept（sr=>sr.ServiceType==typeof（IFoo）和&IsTracingEnabled（），（工厂，定义）=>defineProxy类型（定义））；
var foo=container.GetInstance（）；
}
私有静态void DefineProxyType（ProxyDefinition ProxyDefinition）
{            
proxyDefinition.Implement（（）=>newsampleinterceptor（），m=>m.Name==“SomeMethod”）；
}
私有静态布尔IstracinEnabled（）
{
返回true；
}
}
公共类样本拦截器：IInterceptor
{
公共对象调用（IInvocationInfo调用信息）
{
返回invocationInfo.procedure（）；
}
}
公共接口IFoo{}
公共类Foo:IFoo{}

致意

---

Bernhard Richter

您可以将Istracinabled方法调用直接放入谓词中，该谓词决定是否应该拦截服务。仅当代理类型与谓词匹配时，才会创建代理类型

using LightInject;
using LightInject.Interception;

class Program
{
    static void Main(string[] args)
    {

        var container = new ServiceContainer();
        container.Register<IFoo, Foo>();
        container.Intercept(sr => sr.ServiceType == typeof(IFoo) && IsTracingEnabled(), (factory, definition) => DefineProxyType(definition));

        var foo = container.GetInstance<IFoo>();
    }

    private static void DefineProxyType(ProxyDefinition proxyDefinition)
    {            
        proxyDefinition.Implement(() => new SampleInterceptor(), m => m.Name == "SomeMethod");
    }

    private static bool IsTracingEnabled()
    {
        return true;
    }
}

public class SampleInterceptor : IInterceptor
{
    public object Invoke(IInvocationInfo invocationInfo)
    {
        return invocationInfo.Proceed();
    }
}

public interface IFoo { }

public class Foo : IFoo { }

使用LightInject；
使用LightInject.拦截；
班级计划
{
静态void Main（字符串[]参数）
{
var container=新的ServiceContainer（）；
container.Register（）；
container.Intercept（sr=>sr.ServiceType==typeof（IFoo）和&IsTracingEnabled（），（工厂，定义）=>defineProxy类型（定义））；
var foo=container.GetInstance（）；
}
私有静态void DefineProxyType（ProxyDefinition ProxyDefinition）
{            
proxyDefinition.Implement（（）=>newsampleinterceptor（），m=>m.Name==“SomeMethod”）；
}
私有静态布尔IstracinEnabled（）
{
返回true；
}
}
公共类样本拦截器：IInterceptor
{
公共对象调用（IInvocationInfo调用信息）
{
返回invocationInfo.procedure（）；
}
}
公共接口IFoo{}
公共类Foo:IFoo{}

致意

---

Bernhard Richter

您可以将Istracinabled方法调用直接放入谓词中，该谓词决定是否应该拦截服务。仅当代理类型与谓词匹配时，才会创建代理类型

using LightInject;
using LightInject.Interception;

class Program
{
    static void Main(string[] args)
    {

        var container = new ServiceContainer();
        container.Register<IFoo, Foo>();
        container.Intercept(sr => sr.ServiceType == typeof(IFoo) && IsTracingEnabled(), (factory, definition) => DefineProxyType(definition));

        var foo = container.GetInstance<IFoo>();
    }

    private static void DefineProxyType(ProxyDefinition proxyDefinition)
    {            
        proxyDefinition.Implement(() => new SampleInterceptor(), m => m.Name == "SomeMethod");
    }

    private static bool IsTracingEnabled()
    {
        return true;
    }
}

public class SampleInterceptor : IInterceptor
{
    public object Invoke(IInvocationInfo invocationInfo)
    {
        return invocationInfo.Proceed();
    }
}

public interface IFoo { }

public class Foo : IFoo { }

使用LightInject；
使用LightInject.拦截；
班级计划
{
静态void Main（字符串[]参数）
{
var container=新的ServiceContainer（）；
container.Register（）；
container.Intercept（sr=>sr.ServiceType==typeof（IFoo）&&IsTracingEnabled(