c#实现依赖注入

最新推荐文章于 2024-06-04 21:47:17 发布
最新推荐文章于 2024-06-04 21:47:17 发布
阅读量1.9w 收藏 11
点赞数 2
分类专栏： 设计模式 C# 文章标签： c# class constructor interface attributes string

 

1. 问题的提出 
开发中，尤其是大型项目的开发中，为了降低模块间、类间的耦合关系，比较提倡基于接口开发，但在实现中也必须面临最终是“谁”提供实体类的问题。Martin Fowler在《Inversion of Control Containers and the Dependency Injection pattern》中也提到了标准的三种实现方式——Constructor Injection、Setter Injection和Interface Injection，很全面的阐释了这个问题。 
对于C#而言，由于语法元素上本身要比Java丰富，如何实施注入还有些技巧和特色之处。这方面微软的ObjectBuilder是个不错的教科书，对三种标准方式的实现也都很到位，但就是有些庞大了。 
本文中，笔者借鉴Martin Fowler的撰文，也通过一些精简的代码片断向读者介绍C#实现依赖注入的基本技巧。 
我有个习惯，每天晚上要看天气预报，就以这个开始好了，先定义待注入对象的抽象行为描述，然后增加一个假的实体类，相关代码和单元测试如下： 
C# 
using System; 
namespace VisionLogic.Training.DependencyInjection.Scenario 
{ 
/// <summary> 
/// 抽象注入对象接口 
/// </summary> 
public interface IWeatherReader 
{ 
string Current { get;} 
} 
} 
C# 
using System; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Raw 
{ 
/// <summary> 
/// 伪造的一个实现类 
/// </summary> 
class FakeWeatherReader : IWeatherReader 
{ 
public string Current { get { return string.Empty; } } 
} 
/// <summary> 
/// 客户程序 
/// </summary> 
public class Client 
{ 
protected IWeatherReader reader = new FakeWeatherReader(); 
public virtual string Weather 
{ 
get 
{ 
string current = reader.Current; 
switch (current) 
{ 
case "s": return "sunny"; 
case "r": return "rainy"; 
case "c": return "cloudy"; 
default: 
return "unknown"; 
} 
} 
} 
} 
} 
Unit Test 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
using VisionLogic.Training.DependencyInjection.Scenario.Raw; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest.Raw 
{ 
[TestClass] 
public class WeatherReaderTest 
{ 
[TestMethod] 
public void Test() 
{ 
Client client = new Client(); 
Assert.AreEqual<string>("unknown", client.Weather); 
} 
} 
} 
    问题就出现了，虽然美好的愿望是Client仅仅依赖抽象的IWeatherReader，但之前总要和一个实体类“轧”一道，那么实际的效果就是实体类作了修改、重新编译了，Client也要处理，没有真正达到隔离的目的。依赖注入通过引入第三方责任者的方法，相对好的梳理了这个关系，这位重要的角色就是一个Assembler类，他和实体类型打交道，对Client而言他总是可以根据约定，加工出需要的IWeatherReader。
2.进一步的分析 
    看上去，Client被解放了，但又套住了Assembler，为了尽量让他与实体类间松散些需要做什么呢？ 
? 首先要完成自己的职责：可以找到合适的实现类实例，不管是重新构造一个还是找个现成的。 
? 既要根据需要加工接口IWeatherReader，又要让自己尽量不与大量的实体类纠缠在一起，最好的办法就是从.Net Framework中再找到一个“第三方”，这里选中了System.Activator。 
? 还有就是当客户程序调用Assembler的时候，它需要知道需要通过哪个实现类的实例返回，该项工作一方面可以通过一个字典完成，也可以通过配置解决，两者应用都很普遍，怎么选择呢——抽象，提取一个接口，然后都实现。 
由于本文主要介绍依赖注入的实现，为了简单起见，采用一个伪造的内存字典方式，而非基于System.Configuration的配置系统实现一个Assembler的协同类。
    C# 新增一个用于管理抽象类型——实体类型映射关系的类型ITypeMap 
using System; 
using System.Collections.Generic; 
namespace VisionLogic.Training.DependencyInjection.Scenario 
{ 
/// <summary> 
/// 考虑到某些类型没有无参的构造函数，增加了描述构造信息的专门结构 
/// </summary> 
public class TypeConstructor 
{ 
private Type type; 
private object[] constructorParameters; 
public TypeConstructor(Type type, params object[] constructorParameters) 
{ 
this.type = type; 
this.constructorParameters = constructorParameters; 
} 
public TypeConstructor(Type type) : this(type, null) { } 
public Type Type { get { return type; } } 
public object[] ConstructorParameters { get { return constructorParameters; } } 
} 
/// <summary> 
/// 管理抽象类型与实体类型的字典类型 
/// </summary> 
public interface ITypeMap 
{ 
TypeConstructor this[Type target]{get;} 
} 
} 
C# 实现一个Assembler类型，为了示例方便，同时实现了一个ITypeMap和IWeatherReader 
using System; 
using System.Collections.Generic; 
namespace VisionLogic.Training.DependencyInjection.Scenario 
{ 
/// <summary> 
/// 测试用的实体类 
/// </summary> 
public class WeatherReaderImpl : IWeatherReader 
{ 
private string weather; 
public WeatherReaderImpl(string weather) 
{ 
this.weather = weather; 
} 
public string Current 
{ 
get { return weather; } 
} 
} 
/// <summary> 
/// 管理抽象类型与实际实体类型映射关系，实际工程中应该从配置系统、参数系统获得。 
/// 这里为了示例方便，采用了一个纯内存字典的方式。 
/// </summary> 
public class MemoryTypeMap : ITypeMap 
{ 
private Dictionary<Type, TypeConstructor> dictionary = 
new Dictionary<Type, TypeConstructor>(); 
public static readonly ITypeMap Instance; 
/// <summary> 
/// Singleton 
/// </summary> 
private MemoryTypeMap(){} 
static MemoryTypeMap() 
{ 
MemoryTypeMap singleton = new MemoryTypeMap(); 
// 注册抽象类型需要使用的实体类型 
// 该类型实体具有构造参数，实际的配置信息可以从外层机制获得。 
singleton.dictionary.Add(typeof(IWeatherReader), new TypeConstructor( 
typeof(WeatherReaderImpl), "s")); 
Instance = singleton; 
} 
/// <summary> 
/// 根据注册的目标抽象类型，返回一个实体类型及其构造参数数组 
/// </summary> 
/// <param name="type"></param> 
/// <returns></returns> 
public TypeConstructor this[Type type] 
{ 
get 
{ 
TypeConstructor result; 
if (!dictionary.TryGetValue(type, out result)) 
return null; 
else 
return result; 
} 
} 
} 
public class Assembler<T> 
where T : class 
{ 
/// <summary> 
/// 其实TypeMap工程上本身就是个需要注入的类型，可以通过访问配置系统获得， 
/// 这里为了示例的方便，手工配置了一些类型映射信息。 
/// </summary> 
private static ITypeMap map = MemoryTypeMap.Instance; 
public T Create() 
{ 
TypeConstructor constructor = map[typeof(T)]; 
if (constructor != null) 
{ 
if (constructor.ConstructorParameters == null) 
return (T)Activator.CreateInstance(constructor.Type); 
else 
return (T)Activator.CreateInstance( 
constructor.Type, constructor.ConstructorParameters); 
} 
else 
return null; 
} 
} 
} 
Unit Test 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest 
{ 
[TestClass()] 
public class AssemblerTest 
{ 
[TestMethod] 
public void Test() 
{ 
IWeatherReader reader = new Assembler<IWeatherReader>().Create(); 
Assert.IsNotNull(reader); 
Assert.AreEqual<System.Type>(typeof(WeatherReaderImpl), reader.GetType()); 
} 
} 
} 
 
 
3.经典方式下的注入实现 
    在完成了Assembler这个基础环境后，就是怎么注入的问题了，下面是对三种方式的经典方法实现： 
    3.1 Constructor Injection方式 
Unit Test - Constructor 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest 
{ 
[TestClass] 
public class ConstructorInjectionTest 
{ 
class Client 
{ 
private IWeatherReader reader; 
public Client(IWeatherReader reader) 
{ 
this.reader = reader; 
} 
} 
[TestMethod] 
public void Test() 
{ 
IWeatherReader reader = new Assembler<IWeatherReader>().Create(); 
Client client = new Client(reader); 
Assert.IsNotNull(client); 
} 
} 
} 
    3.2 Setter Injection方式 
Unit Test - Setter 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest 
{ 
[TestClass] 
public class SetterInjectionTest 
{ 
class Client 
{ 
private IWeatherReader reader; 
public IWeatherReader Reader 
{ 
get { return reader; } 
set { reader = value; } 
} 
} 
[TestMethod] 
public void Test() 
{ 
IWeatherReader reader = new Assembler<IWeatherReader>().Create(); 
Client client = new Client(); 
client.Reader = reader; 
Assert.IsNotNull(client.Reader); 
} 
} 
} 
    3.3 Interface Injection方式 
Unit Test - Interface 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest 
{ 
[TestClass] 
public class InterfaceInjectionTest 
{ 
interface IClientWithWeatherReader 
{ 
IWeatherReader Reader { get; set;} 
} 
class Client : IClientWithWeatherReader 
{ 
private IWeatherReader reader; 
#region IClientWithWeatherReader Members 
public IWeatherReader Reader 
{ 
get { return reader; } 
set { reader = value; } 
} 
#endregion 
} 
[TestMethod] 
public void Test() 
{ 
IWeatherReader reader = new Assembler<IWeatherReader>().Create(); 
Client client = new Client(); 
IClientWithWeatherReader clientWithReader = client; 
clientWithReader.Reader = reader; 
Assert.IsNotNull(clientWithReader.Reader); 
} 
} 
} 
 
4. 用属性（Attribute）注入 
    C#还可以通过Attribute注入，Enterprise Library中大量使用这种方式将各种第三方机制加入到类系统中。例如： 
? ?运行监控需要的Performance Counter。 
? ?用于构造过程的指标信息。 
? ?用于日志、密码处理。 
? ?等等 
    注：Java语言虽然发展比较慢，但在Java 5种也提供了类似的Annotation的机制，换了个名字省去被评估为“抄袭”的嫌疑。） 
    为了演示方便，下面设计一个应用情景： 
    
    Scenario 
    1、 应用需要一个集中的机制了解系统中实际创建过多少个特定类型对象的实例，用于评估系统的Capacity要求。 
    2、 为了防止系统资源被用尽，需要控制每类对象实例数量。 
    怎么实现呢？如下： 
? ?增加一个内存的注册器，登记每个类已经创建过的实例实例数量。 
? ?然后给每个类贴个标签——Attribute，让Assembler在生成的对象的时候根据标签的内容把把登记到注册器。 
    4.1定义抽象业务实体 
C# 
using System; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer 
{ 
/// <summary> 
/// 抽象的处理对象 
/// </summary> 
public interface IObjectWithGuid 
{ 
string Guid { get; set;} 
} 
} 
定义需要注入的限制接口，并用一个Attribute管理它 
C# 
using System; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer 
{ 
/// <summary> 
/// 需要注入的用以限制最大数量的接口 
/// </summary> 
public interface ICapacityConstraint 
{ 
int Max { get;} 
} 
public class CapacityConstraint : ICapacityConstraint 
{ 
private int max; 
public CapacityConstraint(){this.max = 0;} // 默认情况下不限制 
public CapacityConstraint(int max) { this.max = max; } 
public int Max { get { return max; } } 
} 
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] 
public class ConstraintAttribute : Attribute 
{ 
private ICapacityConstraint capacity; 
public ConstraintAttribute(int max) { this.capacity = new CapacityConstraint(max); } 
public ConstraintAttribute() { this.capacity = null; } 
public ICapacityConstraint Capacity { get { return capacity; } } 
} 
} 
Assembler上增加通过Attribute注入限制的响应 
C# 
using System; 
using System.Collections.Generic; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer 
{ 
public class Assembler 
{ 
/// <summary> 
/// 登记相关类型对“最大容量”属性的使用情况 
/// </summary> 
private IDictionary<Type, ConstraintAttribute> attributeRegistry = 
new Dictionary<Type, ConstraintAttribute>(); 
/// <summary> 
/// 登记每个类型（如须受到“最大容量”属性限制的话），实际已经创建的对象数量 
/// </summary> 
private IDictionary<Type, int> usageRegistry = new Dictionary<Type, int>(); 
public T Create<T>() 
where T : IObjectWithGuid, new() 
{ 
ICapacityConstraint constraint = GetAttributeDefinedMax(typeof(T)); 
if ((constraint == null) || (constraint.Max <= 0)) // max <= 0 代表是不需要限制数量的。 
return InternalCreate<T>(); 
else 
{ 
if (usageRegistry[typeof(T)] < constraint.Max) // 检查是否超出容量限制 
{ 
usageRegistry[typeof(T)]++; // 更新使用情况注册信息 
return InternalCreate<T>(); 
} 
else 
return default(T); 
} 
} 
// helper method 
// 直接生成特定实例，并setter 方式注入其guid。 
private T InternalCreate<T>() 
where T : IObjectWithGuid, new() 
{ 
T result = new T(); 
result.Guid = Guid.NewGuid().ToString(); 
return result; 
} 
/// helper method. 
// 获取特定类型所定义的最大数量, 同时视情况维护attributeRegistry 和usageRegistry 的注册信息。 
private ICapacityConstraint GetAttributeDefinedMax(Type type) 
{ 
ConstraintAttribute attribute = null; 
if (!attributeRegistry.TryGetValue(type, out attribute)) //新的待创建的类型 
{ 
// 填充相关类型的“最大容量”属性注册信息 
object[] attributes = type.GetCustomAttributes(typeof(ConstraintAttribute), false); 
if ((attributes == null) || (attributes.Length <= 0)) 
attributeRegistry.Add(type, null); 
else 
{ 
attribute = (ConstraintAttribute)attributes[0]; 
attributeRegistry.Add(type, attribute); 
usageRegistry.Add(type, 0); // 同时补充该类型的使用情况注册信息 
} 
} 
if (attribute == null) 
return null; 
else 
return attribute.Capacity; 
} 
} 
} 
    4.2对方案的测试 
C# 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario.Attributer; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest.Attributer 
{ 
[TestClass()] 
public class AssemblerTest 
{ 
public abstract class ObjectWithGuidBase : IObjectWithGuid 
{ 
protected string guid; 
public virtual string Guid 
{ 
get { return guid; } 
set { guid = value; } 
} 
} 
[Constraint(2)] // 通过属性注入限制 
public class ObjectWithGuidImplA : ObjectWithGuidBase { } 
[Constraint(0)] // 通过属性注入限制 
public class ObjectWithGuidImplB : ObjectWithGuidBase { } 
[Constraint(-5)] // 通过属性注入限制 
public class ObjectWithGuidImplC : ObjectWithGuidBase { } 
public class ObjectWithGuidImplD : ObjectWithGuidBase { } 
[TestMethod] 
public void Test() 
{ 
Assembler assembler = new Assembler(); 
for (int i = 0; i < 2; i++) 
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplA>()); 
Assert.IsNull(assembler.Create<ObjectWithGuidImplA>()); // 最多两个 
for (int i = 0; i < 100; i++) 
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplB>()); // 不限制 
for (int i = 0; i < 100; i++) 
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplC>()); // 不限制 
for (int i = 0; i < 100; i++) 
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplD>()); // 不限制 
} 
} 
} 

 

Blithe
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c#依赖注入
qq_45800365的博客
08-18 1389
依赖注入（Dependency Injection，简称 DI）是一种设计模式，用于将对象的创建和管理责任从使用它的类中分离出来，从而实现松耦合和易于测试的代码。构造函数注入（Constructor Injection）： 这是最常见的依赖注入方式，通过类的构造函数将依赖传递给类的实例。这种方式通常用于临时的依赖注入，例如在方法执行期间需要一个依赖对象的临时实例。在 C# 中，实现依赖注入通常需要使用一个依赖注入容器（DI Container），这是一个负责管理依赖并进行注入的工具。
详解C# 依赖注入
08-19
依赖注入在C#中的应用 依赖注入是软件设计中的一种设计模式，它的主要目的是为了...依赖注入是C#中的一种非常重要的技术，通过它，我们可以实现控制反转，达到松耦合和高内聚的效果，从而提高代码的可维护性和灵活性。
C# 依赖注入
weixin_30279751的博客
12-26 869
一、什么是依赖注入 依赖注入的正式定义： 依赖注入（Dependency Injection），是这样一个过程：由于某客户类只依赖于服务类的一个接口，而不依赖于具体服务类，所以客户类只定义一个注入点。在程序运行过程中，客户类不直接实例化具体服务类实例，而是客户类的运行上下文环境或专门组件负责实例化服务类，然后将其注入到客户类中，保证客户类的正常运行。 二、依赖注入的类别 1.Setter...
C#依赖注入和IOC容器的简单介绍
最新发布
weixin_48083386的博客
06-04 473
为了使处在较高级别的的业务层依赖于较低级别对象的功能，而没有具体的实现，必须由其他人创建类。现在，如果我们看一下代码，我们只依赖于业务访问层中数据访问层的抽象，而业务访问层是使用的是数据访问层实现的接口。因此，我们遵循了更高层次对象和更低层次对象都依赖于抽象的原则，抽象是更高层次对象和更低层次对象之间的契约。我们不是在业务层中创建数据访问层的实例，而是在基础设施的中创建它。例如，如果我们想为SQL Server创建一个新的数据访问层，我们只需实现数据访问层的抽象并将实例注入基础设施中。接口表示功能的抽象。
C#--依赖注入
weixin_42359607的博客
07-29 9967
小编在之前面试某家企业时，面试官提出了一个问题，虽然按经验，说出了解决方法，面试官也表示此方法可以实现，且提出了另一种方案，就是“依赖注入”。 面试官的题目是这样子的：如果现在公司有个程序，假设是关于动物园的程序，有些许动物（动物库A）已经加到了动物园里了，里面的动物都完成了动物该有的行为，然后程序已经测试通过，没有问题并已经发布。现在问题是，动物园里要添加新的动物种类，请问，如何不修改动物库A的代码的情况下，将新的动物物种添加到动物园里（题目大概就是这个意思，无非就是说，原来程序不允许修改，只能新增加别
C#依赖注入3种实现方法
blu_e__heart的博客
01-21 1676
这些是C#中常见的依赖注入方法，每种方法都有其特定的用法和适用场景。根据项目的需求和设计风格，可以选择最合适的方法来实现依赖注入。在C#中，有多种实现依赖注入的方法。
c# 依赖注入
GeGe&YoYo的博客
05-25 1467
每次请求，都获取一个新的实例。即使同一个请求获取多次也会是不同的实例。每次请求，都获取一个新的实例。同一个请求获取多次会得到相同的实例。请求获取-（GC回收-主动释放） 每一次获取的对象都不是同一个。请求开始-请求结束 在这次请求中获取的对象都是同一个。项目启动-项目关闭 相当于静态类 只会有一个。每次都获取同一个实例。
c# 依赖注入 控制反转
08-14
### C# 依赖注入 控制反转 #### 一、IoC（控制反转）简介 IoC，即"Inversion of Control"（控制反转），是软件工程领域的一个重要概念，特别是面向对象编程中的一个关键设计原则。从字面上理解，IoC指的是程序运行...
C# (.NET Core 6.0) DI依赖注入 示例
08-04
较为框架式的演示了DI服务依赖注入 适用于熟悉C#中的继承,基本的Core命令使用等. 该示例演示了以服务器集群为背景的各种业务的依赖注入. 示例来自于B站杨中科老师的.NET Core(6.0)教学.
C#控制台程序中使用官方依赖注入的实现
08-19
本资源主要介绍了C#控制台程序中使用官方依赖注入的实现，通过示例代码详细介绍了如何在控制台程序中使用官方依赖注入框架，旨在帮助读者更好地理解和掌握C#控制台程序中的依赖注入实现。 一、业务接口类设计 在C#...
C#依赖注入常用的几种方式
陈鼎涵
08-17 1万+
1、构造器注入 通过构造器进行依赖注入 public class MyClass { private IMyInterFace _myinterface; public MyClass (IMyInterFace myinterface) { this._myinterface = myinterface; } } 2、Se...
依赖注入（C#）
热门推荐
bin的专栏
07-30 1万+
设计模式学习笔记一，依赖注入（Dependency Injection，简称DI）设计模式中，尤其是结构型模式很多时候解决的就是对象间的依赖关系，变依赖关系具体为依赖具象。平时开发中如果发现客户程序依赖某个（或某类）对象，我们常常会对它们进行一次抽象，形成抽象的抽象类、接口，这样客户程序就可以摆脱所依赖的具体类型。二，实现（C#）示例情景假设，现在程序需要一个获取不同时间格式的的当前时间。 我们定
c#之 依赖注入
wanxiweilai的博客
01-17 1755
概念：依赖注入主要体现了IOC思想，IOC将实现详细信息编写为依赖并且实现了更高级的抽象，因此程序测试性，维护性，模块化程度都更高了。这也就对应了刚刚的那个设计规则–依赖于抽象，而不是具体的实现。创建一个appsettings.cs文件用来保存配置设置。3、Singleton:单例模式，整个应用程序生命周期只创建一个实例。1、Transient: 瞬态模式，每次访问都会创建一个新的实例。2、Scoped：域模式，在同一个scope内只初始胡一个实例。在ioc容器中注册服务。需要引用nuget包。
C# 中的依赖注入模式
vvoennvv的博客
11-15 1608
在 IoC 原则 (***) 的术语中，DI Container 具有“框架”的作用，因此您经常会看到它被称为“ DI 框架”，但我认为“框架”这个词被过度使用了，它导致混乱（你有 ASP MVC 框架、DI 框架、实体框架等）。当他们说“框架”时，他们的意思是为特定任务设计的专门的、任意复杂的可重用模块/库，并且自定义代码的编写方式使其可以与该“框架”一起使用。这里控制是倒置的，即服务的创建和依赖的创建被委托给注入器，在这种情况下，注入器就是“框架”。程序的主要控制是倒置的，从你移到框架上。
C#进阶——依赖注入(DI)
leikang111的博客
10-17 790
依赖注入(DI)
C#中的依赖注入
weixin_45507349的博客
11-22 2174
一 应用场景 .net core mvc/api 二 应用目的 是我要什么你就给我送过来，别让我大老远的找你去拿 三 基本用法 一般有两种用法： 1、定义一个接口或者抽象类IA，然后类A实现IA，当然也可以A、B、C、D多个类实现IA 2、直接定义类A、B、C等，不考虑派生类，直接注入到容器里。 四 用法一实操过程 1、先定义一个接口 public interface ITest { string GetName(); } 2、定义一个实体类实现这个接口 public
C# 依赖注入：一种提高代码质量的设计模式
qq_35320456的博客
02-10 1684
C# 依赖注入：一种提高代码质量的设计模式
C#中的依赖注入和IoC容器
nicvscs的博客
12-29 431
在本文中，我们将通过用C#重构一个非常简单的代码示例来解释依赖注入和IoC容器。 简介： 依赖注入和IoC乍一看可能相当复杂，但它们非常容易学习和理解。 在本文中，我们将通过在C#中重构一个非常简单的代码示例来解释依赖注入和IoC容器。 要求： 构建一个允许用户查看可用产品并按名称搜索产品的应用程序。 第一次尝试： 我们将从创建分层架构开始。使用分层架构有多个好处，但我们不会在本文中列出它们，因为我们关注的是依赖注入。 下面是应用程序的类图: 首先，我们将从创建一个..
C#依赖注入-初步概念了解
张中华的博客
05-09 5751
依赖注入是什么？ 依赖注入是一个过程，就是当一个类需要调用另一个类来完成某项任务的时候，在调用类里面不要去new被调用的类的对象，而是通过注入的方式来获取这样一个对象。具体的实现就是在调用类里面有一个被调用类的接口，然后通过调用接口的函数来完成任务。比如A调用B，而B实现了接口C，那么在A里面用C定义一个变量D，这个变量的实例不在A里面创建，而是通过A的上...
依赖注入原理与实践 - .NET C#
"依赖注入.NET" 是关于.NET框架中C#编程语言实现依赖注入技术的专业书籍。作者Mark Seemann深入探讨了这一关键的软件设计模式，旨在提高代码的可测试性、可维护性和可扩展性。 依赖注入（Dependency Injection，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值