依赖注入的惰性解析

发布于 2024-08-04 22:48:35 字数 92 浏览 4 评论 0 原文

我有 .net 课程 我使用 Unity 作为 IOC 来解决我们的依赖关系。 它尝试在开始时加载所有依赖项。 Unity中有没有一种方法(设置)允许在运行时加载依赖项?

I have .net classes
I am using unity as IOC for resolving our dependencies.
It tries to load all the dependencies at the beginning.
Is there a way (setting) in Unity which allows to load a dependency at runtime?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

黑寡妇 2024-08-11 22:48:35

还有更好的解决方案 - 对 Lazy 的本机支持和 IEnumerable>在Unity 2.0中。请查看此处

There's even better solution - native support for Lazy<T> and IEnumerable<Lazy<T>> in the Unity 2.0. Check it out here.

海的爱人是光 2024-08-11 22:48:35

我认为 Unity 应该懒惰地构建实例。您的意思是它正在加载包含其他依赖项的程序集吗?如果是这种情况,您可能需要看看 MEF - 它是专门为模块化应用程序设计的。

Unity should be lazily constructing instances, I believe. Do you mean that it is loading the assemblies containing the other dependencies? If that's the case, you might want to take a look at MEF - it's designed specifically for modular applications.

最单纯的乌龟 2024-08-11 22:48:35

我在博客中发布了一些代码这里 允许将“惰性”依赖项传递到您的类中。它允许您替换:

class MyClass(IDependency dependency)

with

class MyClass(ILazy<IDependency> lazyDependency)

这使您可以选择延迟依赖项的实际创建,直到您需要使用它为止。当需要时调用lazyDependency.Resolve()。

这是 ILazy 的实现:

public interface ILazy<T>
{
    T Resolve();
    T Resolve(string namedInstance);
}

public class Lazy<T> : ILazy<T>
{
    IUnityContainer container;

    public Lazy(IUnityContainer container)
    {
        this.container = container;
    }

    public T Resolve()
    {
        return container.Resolve<T>();
    }

    public T Resolve(string namedInstance)
    {
        return container.Resolve<T>(namedInstance);
    }
}

您需要在容器中注册它才能使用它:

container.RegisterType(typeof(ILazy<>),typeof(Lazy<>));

I have blogged some code here to allow passing 'lazy' dependencies into your classes. It allows you to replace:

class MyClass(IDependency dependency)

with

class MyClass(ILazy<IDependency> lazyDependency)

This gives you the option of delaying the actual creation of the dependency until you need to use it. Call lazyDependency.Resolve() when you need it.

Here's the implementation of ILazy:

public interface ILazy<T>
{
    T Resolve();
    T Resolve(string namedInstance);
}

public class Lazy<T> : ILazy<T>
{
    IUnityContainer container;

    public Lazy(IUnityContainer container)
    {
        this.container = container;
    }

    public T Resolve()
    {
        return container.Resolve<T>();
    }

    public T Resolve(string namedInstance)
    {
        return container.Resolve<T>(namedInstance);
    }
}

you will need to register it in your container to be able to use it:

container.RegisterType(typeof(ILazy<>),typeof(Lazy<>));
北斗星光 2024-08-11 22:48:35

在 .net core 中使用“延迟解析”:删除两个类的构造函数注入,并仅在需要使用时通过注入 .net IServiceProvider 命名空间来实例化其他类。
输入图片此处描述

serviceProvider.GetRequiredService<Service2>().Hi();

使用默认构造函数注入,并且在必要时使用延迟解析。

in .net core use "Lazy Resolution" : remove both constructor injection of both classes and instantiate other class only when need to use it by injecting the .net IServiceProvider namespace.
enter image description here

serviceProvider.GetRequiredService<Service2>().Hi();

Use constructor injection default and only use Lazy Resolution when you have to.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文