有人可以解释Microsoft Unity吗?


157

我一直在阅读MSDN上有关Unity(依赖注入,控制反转)的文章,但我认为我需要用简单的术语(或简单的示例)进行解释。我对MVPC模式很熟悉(我们在这里使用了它),但是我还不能真正掌握Unity的知识,我认为这是我们应用程序设计的下一步。


12
我喜欢它与“ Unity”同名的名字,因此当我搜索Unity Game Engine素材时,我会叹息这项古老的技术。我猜所有好乐队的名字都被拿走了。
汤姆·舒尔茨

2
@ tom-schulz旧技术? nuget.org/packages/Unity-最近更新于5天前。
罗杰·威尔考克斯

Answers:


174

Unity只是一个IoC“容器”。Google StructureMap,然后尝试一下。我想,当IoC东西对您来说是新手时,我会更容易理解。

基本上,如果您了解IoC,那么您就会知道您正在做的事情是在创建对象时反转控件。

没有IoC:

public class MyClass
{
   IMyService _myService; 

   public MyClass()
   {
      _myService = new SomeConcreteService();    
   }
}

使用IoC容器:

public class MyClass
{
   IMyService _myService; 

   public MyClass(IMyService myService)
   {
      _myService = myService;    
   }
}

如果没有IoC,则依赖IMyService的类必须更新要使用的服务的具体版本。但这有很多原因,这很糟糕(您已将类与IMyService的特定具体版本耦合,无法轻松对其进行单元测试,无法轻松进行更改,等等)。

使用IoC容器,您可以“配置”容器来为您解决这些依赖性。因此,使用基于构造函数的注入方案,只需将IMyService依赖项的接口传递给构造函数。使用容器创建MyClass时,容器将为您解决IMyService依赖项。

使用StructureMap,配置容器如下所示:

StructureMapConfiguration.ForRequestedType<MyClass>().TheDefaultIsConcreteType<MyClass>();
StructureMapConfiguration.ForRequestedType<IMyService>().TheDefaultIsConcreteType<SomeConcreteService>();

因此,您完成的工作将告诉容器:“当有人请求IMyService时,请给他们一份SomeConcreteService的副本。” 并且您还指定了,当有人要求MyClass时,他们会得到一个具体的MyClass。

这就是IoC容器的全部工作。他们可以做更多的事情,但这就是重点-他们为您解决依赖关系,因此您不必这样做(也不必在整个代码中使用“ new”关键字)。

最后一步:创建MyClass时,您将执行以下操作:

var myClass = ObjectFactory.GetInstance<MyClass>();

希望有帮助。随时给我发电子邮件。


2
我想这就像一个工厂吗?如果我正确地遵循了此步骤,那么在最后一个示例中,您是否会使用<IMyClass>而不是<MyClass>?因此它将是var myClass = ObjectFactory.GetInstance <IMyClass>()吗?感谢您的帮助,这对我来说是一个好的开始!
Ryan Abbott

3
在某种程度上,它就像一家工厂。您的应用程序的主工厂。但是,可以将其配置为返回很多不同的类型,包括单例。至于MyClass的接口-如果它是业务对象,则不会提取接口。对于其他所有事情,我通常都会这样做。
克里斯·霍尔姆斯

如果仅调用ObjectFactory.GetInstance <MyClass>()怎么办?并且您没有配置SomeConcreteClass?在这种情况下,您会出错吗?
RayLoveless

1
@Ray:这取决于容器。编写某些容器是为了使它们在默认情况下使用命名约定,例如,如果一个类名为MyClass且该接口名为IMyInterface,则该容器将自动为该接口配置该类。因此,在这种情况下,如果您不手动配置它,则容器的默认“约定”还是会选择它。但是,如果您的类和接口未遵循约定,并且未为该类配置容器,则可以,在运行时会出错。
克里斯·霍尔姆斯

1
@saravanan我认为StructureMap现在执行基于名称的约定。我不确定;我们已经有很长时间没有使用它了(我为我们的业务写了一个自定义代码;它对接口和类使用了相同的名称约定)。
克里斯·福尔摩斯

39

我刚刚看了大卫·海顿(David Hayden)进行的30分钟的Unity Dependency Injection IoC Screencast,觉得这是一个很好的例子说明。这是显示笔记的摘录:

该截屏视频显示了Unity IoC的几种常见用法,例如:

  • 创建不在容器中的类型
  • 注册和解析类型映射
  • 注册和解析命名类型映射
  • 单例,LifetimeManager和ContainerControlledLifetimeManager
  • 注册现有实例
  • 将依赖项注入到现有实例中
  • 通过App.config / Web.config填充UnityContainer
  • 通过Injection API指定依赖关系,而不是依赖关系属性
  • 使用嵌套的(父子)容器

32

Unity是一个像许多其他库一样的库,它使您无需自己创建就可以获取所请求类型的实例。所以给。

public interface ICalculator
{
    void Add(int a, int b);
}

public class Calculator : ICalculator
{
    public void Add(int a, int b)
    {
        return a + b;
    }
}

您将使用类似Unity的库来注册当请求ICalculator类型又称为IoC(控制反转)时返回的计算器(此示例是理论上的,在技术上不正确)。

IoCLlibrary.Register<ICalculator>.Return<Calculator>();

因此,现在当您想要ICalculator的实例时,您只需...

Calculator calc = IoCLibrary.Resolve<ICalculator>();

通常,每次解析类型时,通常都可以将IoC库配置为容纳单例或创建新实例。

现在,假设您有一个依赖于ICalculator的类,该类可以存在。

public class BankingSystem
{
    public BankingSystem(ICalculator calc)
    {
        _calc = calc;
    }

    private ICalculator _calc;
}

而且,您可以设置该库以在创建对象时将其注入到构造函数中。

因此,DI或依赖注入意味着注入其他对象可能需要的任何对象。


应该是ICalculator calc = IoCLibrary.Resolve <ICalculator>();
Shukhrat Raimov


10

Unity是一个IoC。IoC的重点是抽象类型本身之外的类型之间的依赖关系。这有两个优点。首先,它是集中完成的,这意味着当依赖项发生更改时,您不必更改很多代码(单元测试可能就是这种情况)。

此外,如果使用配置数据而不是代码进行连接,则实际上可以在部署后重新连接依赖项,从而无需更改代码即可更改应用程序的行为。



1

我将介绍ASP.NET Web API 2中的依赖注入的大多数示例

public interface IShape
{
    string Name { get; set; }
}

public class NoShape : IShape
{
    public string Name { get; set; } = "I have No Shape";
}

public class Circle : IShape
{
    public string Name { get; set; } = "Circle";
}

public class Rectangle : IShape
{
    public Rectangle(string name)
    {
        this.Name = name;
    }

    public string Name { get; set; } = "Rectangle";
}

在DIAutoV2Controller.cs中使用自动注入机制

[RoutePrefix("api/v2/DIAutoExample")]
public class DIAutoV2Controller : ApiController
{
    private string ConstructorInjected;
    private string MethodInjected1;
    private string MethodInjected2;
    private string MethodInjected3;

    [Dependency]
    public IShape NoShape { get; set; }

    [Dependency("Circle")]
    public IShape ShapeCircle { get; set; }

    [Dependency("Rectangle")]
    public IShape ShapeRectangle { get; set; }

    [Dependency("PiValueExample1")]
    public double PiValue { get; set; }

    [InjectionConstructor]
    public DIAutoV2Controller([Dependency("Circle")]IShape shape1, [Dependency("Rectangle")]IShape shape2, IShape shape3)
    {
        this.ConstructorInjected = shape1.Name + " & " + shape2.Name + " & " + shape3.Name;
    }

    [NonAction]
    [InjectionMethod]
    public void Initialize()
    {
        this.MethodInjected1 = "Default Initialize done";
    }

    [NonAction]
    [InjectionMethod]
    public void Initialize2([Dependency("Circle")]IShape shape1)
    {
        this.MethodInjected2 = shape1.Name;
    }

    [NonAction]
    [InjectionMethod]
    public void Initialize3(IShape shape1)
    {
        this.MethodInjected3 = shape1.Name;
    }

    [HttpGet]
    [Route("constructorinjection")]
    public string constructorinjection()
    {
        return "Constructor Injected: " + this.ConstructorInjected;
    }

    [HttpGet]
    [Route("GetNoShape")]
    public string GetNoShape()
    {
        return "Property Injected: " + this.NoShape.Name;
    }

    [HttpGet]
    [Route("GetShapeCircle")]
    public string GetShapeCircle()
    {
        return "Property Injected: " + this.ShapeCircle.Name;
    }

    [HttpGet]
    [Route("GetShapeRectangle")]
    public string GetShapeRectangle()
    {
        return "Property Injected: " + this.ShapeRectangle.Name;
    }

    [HttpGet]
    [Route("GetPiValue")]
    public string GetPiValue()
    {
        return "Property Injected: " + this.PiValue;
    }

    [HttpGet]
    [Route("MethodInjected1")]
    public string InjectionMethod1()
    {
        return "Method Injected: " + this.MethodInjected1;
    }

    [HttpGet]
    [Route("MethodInjected2")]
    public string InjectionMethod2()
    {
        return "Method Injected: " + this.MethodInjected2;
    }

    [HttpGet]
    [Route("MethodInjected3")]
    public string InjectionMethod3()
    {
        return "Method Injected: " + this.MethodInjected3;
    }
}

在DIV2Controller.cs中,所有内容将从Dependency Configuration Resolver类注入

[RoutePrefix("api/v2/DIExample")]
public class DIV2Controller : ApiController
{
    private string ConstructorInjected;
    private string MethodInjected1;
    private string MethodInjected2;
    public string MyPropertyName { get; set; }
    public double PiValue1 { get; set; }
    public double PiValue2 { get; set; }
    public IShape Shape { get; set; }

    // MethodInjected
    [NonAction]
    public void Initialize()
    {
        this.MethodInjected1 = "Default Initialize done";
    }

    // MethodInjected
    [NonAction]
    public void Initialize2(string myproperty1, IShape shape1, string myproperty2, IShape shape2)
    {
        this.MethodInjected2 = myproperty1 + " & " + shape1.Name + " & " + myproperty2 + " & " + shape2.Name;
    }

    public DIV2Controller(string myproperty1, IShape shape1, string myproperty2, IShape shape2)
    {
        this.ConstructorInjected = myproperty1 + " & " + shape1.Name + " & " + myproperty2 + " & " + shape2.Name;
    }

    [HttpGet]
    [Route("constructorinjection")]
    public string constructorinjection()
    {
        return "Constructor Injected: " + this.ConstructorInjected;
    }

    [HttpGet]
    [Route("PropertyInjected")]
    public string InjectionProperty()
    {
        return "Property Injected: " + this.MyPropertyName;
    }

    [HttpGet]
    [Route("GetPiValue1")]
    public string GetPiValue1()
    {
        return "Property Injected: " + this.PiValue1;
    }

    [HttpGet]
    [Route("GetPiValue2")]
    public string GetPiValue2()
    {
        return "Property Injected: " + this.PiValue2;
    }

    [HttpGet]
    [Route("GetShape")]
    public string GetShape()
    {
        return "Property Injected: " + this.Shape.Name;
    }

    [HttpGet]
    [Route("MethodInjected1")]
    public string InjectionMethod1()
    {
        return "Method Injected: " + this.MethodInjected1;
    }

    [HttpGet]
    [Route("MethodInjected2")]
    public string InjectionMethod2()
    {
        return "Method Injected: " + this.MethodInjected2;
    }
}

配置依赖关系解析器

public static void Register(HttpConfiguration config)
{
    var container = new UnityContainer();
    RegisterInterfaces(container);
    config.DependencyResolver = new UnityResolver(container);

    // Other Web API configuration not shown.
}

private static void RegisterInterfaces(UnityContainer container)
{
    var dbContext = new SchoolDbContext();
    // Registration with constructor injection
    container.RegisterType<IStudentRepository, StudentRepository>(new InjectionConstructor(dbContext));
    container.RegisterType<ICourseRepository, CourseRepository>(new InjectionConstructor(dbContext));

    // Set constant/default value of Pi = 3.141 
    container.RegisterInstance<double>("PiValueExample1", 3.141);
    container.RegisterInstance<double>("PiValueExample2", 3.14);

    // without a name
    container.RegisterInstance<IShape>(new NoShape());

    // with circle name
    container.RegisterType<IShape, Circle>("Circle", new InjectionProperty("Name", "I am Circle"));

    // with rectangle name
    container.RegisterType<IShape, Rectangle>("Rectangle", new InjectionConstructor("I am Rectangle"));

    // Complex type like Constructor, Property and method injection
    container.RegisterType<DIV2Controller, DIV2Controller>(
        new InjectionConstructor("Constructor Value1", container.Resolve<IShape>("Circle"), "Constructor Value2", container.Resolve<IShape>()),
        new InjectionMethod("Initialize"),
        new InjectionMethod("Initialize2", "Value1", container.Resolve<IShape>("Circle"), "Value2", container.Resolve<IShape>()),
        new InjectionProperty("MyPropertyName", "Property Value"),
        new InjectionProperty("PiValue1", container.Resolve<double>("PiValueExample1")),
        new InjectionProperty("Shape", container.Resolve<IShape>("Rectangle")),
        new InjectionProperty("PiValue2", container.Resolve<double>("PiValueExample2")));
}

由于多种原因,这并不是一个特别有用的答案。这是一个不必要的复杂示例,其中的代码太多,不足以提供对IOC的简单说明。除此之外,在您实际需要的地方并没有清楚地记录代码。
Dan Atkinson
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.