一、IOC
1.什么是IOC?
控制反轉（英語：Inversion of Control，縮寫為IoC），是[面向物件編程]中的一種設計原則，可以用來減低計算機代碼之間的[耦合度]其中最常見的方式叫做依賴注入（Dependency Injection，簡稱DI），還有一種方式叫“依賴查找”（Dependency Lookup）.
IoC:是一種設計模式
DI:是踐行控制反轉思想的一種方式
2.為什么要用IOC
因為IoC 控制反轉是依賴抽象，而抽象是穩定的，不依賴細節，因為細節還可能會依賴其他細節，為了屏蔽細節，需要使用依賴注入去解決無限層級的物件依賴，
3.Net中常用的IoC容器
目前用的最多的是AutoFac和Castle,在.Net Core中框架內置了IOC容器,Unity和ObjectBuilder是相對比較久遠的框架，用的比較少，
-
AutoFac
-
Castle
-
Unity
-
ObjectBuilder
二、如何手寫實作？
1.基本設計
核心思想： 工廠 + 反射
首先我們想自己實作一個IoC容器其實并不難，我們在使用現有的IoC容器都知道，在使用前，我們需要先注冊，然后才能使用
所以我們將工廠換成手動注冊的方式，因為寫一大堆if else 或者switch也不太美觀，根據主流IoC的使用方式來以葫蘆畫瓢，如果后期繼續完善功能加入程式集注入的話，還是得實作一個工廠，來省略手動注冊
但是這次目標是實作一個簡易版的IoC容器,我們先實作基礎功能，待后面一步一步去完善，再加入一些新的功能，即我們不考慮性能或者擴展度，目的是循序漸進，在寫之前我們先整理出 實作步驟和實作方式
-
方便接入和擴展，我們在這先定義一個容器介面 IManualContainer
-
定義ManualContainer繼承實作IManualContainer
-
宣告一個靜態字典物件存盤注冊的物件
-
利用反射構建物件，考慮到性能可以加入Expression或者Emit的方式來做一些優化
public interface IManualContainer
{
void Register<TFrom, To>(string servicesName = null) where To : TFrom;
Tinterface Resolve<Tinterface>(string servicesName = null);
}
2.要實作的功能
1.基本物件構造
2.建構式注入
3.多級依賴和多建構式及自定義注入
4.屬性注入&方法注入
5.單介面多實作
三、編碼實作及思路剖析
1.實作構造物件（單介面注入）
1.首先實作介面來進行編碼私有欄位 container用來存盤注冊的型別,key是對應介面的完整名稱，Value是需要Resolve的型別，
2.泛型約束保證需要被Resolve型別 (To) 實作或者繼承自注冊型別 （TFrom）
public class ManualContainer : IManualContainer
{
//存盤注冊型別
private static Dictionary<string, Type> container =
new Dictionary<string, Type>();
//注冊
public void Register<TFrom, To>(string servicesName = null) where To : TFrom
{
string Key = $"{typeof(TFrom).FullName}{servicesName}";
if (!container.ContainsKey(Key))
{
container.Add(Key, typeof(To));
}
}
1.實作構造物件，首先需要傳入被構造的型別的抽象介面T
2.在Resolve中根據T作為Key,在存盤容器中找到注冊時映射的型別，并通過反射構造物件
//構建物件
public TFrom Resolve<TFrom>(string servicesName = null)
{
string Key = $"{typeof(TFrom).FullName}{servicesName}";
container.TryGetValue(key, out Type target);
if(target is null)
{
return default(TFrom);
}
object t = Activator.CreateInstance(target);
}
}
1.首先我們準備需要的介面（ITestA）和實體（TestA）來利用容器來構造物件
public interface ITestA
{
void Run();
}
public class TestA : ITestA
{
public void Run()=> Console.WriteLine("這是介面ITestA的實作");
}
2.呼叫IoC容器來創建物件
IManualContainer container = new ManualContainer();
//注冊到容器中
container.Register<ITestA, TestA>();
ITestA instance = container.Resolve<ITestA>();
instance.Run();
//out put "這是介面ITestA的實作"
2.建構式注入
1.假設我們的TestA類中需要ITestB介面的實體或者其他更多型別的實體，并且需要通過建構式注入，我們應該如何去完善我們的IoC容器呢？
public class TestA : ITestA
{
private ITestB testB = null;
//建構式
public TestA(ITestB testB)=> this.testB = testB;
public void Run()
{
this.testB.Run();
Console.WriteLine("這是介面ITestA的實作");
}
}
2.我們按照上面的步驟照常注冊和構造物件，發現報錯了，在Resolve
-
先定義List<object>集合存盤物件構造時需要的引數串列
-
通過需要被實體的目標型別找到類中的建構式，暫不考慮多建構式case
-
找到建構式引數及型別，然后創建引數的實體加入List中,在反射構造時傳入引數就解決了
//完善Resolve構建物件函式
public TFrom Resolve<TFrom>(string servicesName = null)
{
string Key = $"{typeof(TFrom).FullName}{servicesName}";
container.TryGetValue(key, out Type target);
if(target is null)
{
return default(TFrom);
}
//存盤引數串列
List<object> paramList = new List<object>();
//找到目標型別的建構式，暫不考慮多建構式case
var ctor = target.GetConstructors().FirstOrDefault();
//找到引數串列
var ctorParams = ctor.GetParameters();
foreach (var item in ctorParams)
{
//引數型別
Type paramType = item.ParameterType;
string paramKey = paramType.FullName;
//找到引數注冊時映射的實體
container.TryGetValue(paramKey, out Type ParamType);
//構造出實體然后加入引數串列
paramList.Add(Activator.CreateInstance(ParamType));
}
object t = Activator.CreateInstance(target,paramList);
}
}
3.多級依賴（遞回）
根據上面我們目前實作的結果來看,這是解決了建構式和多引數注入以及基本的構造物件問題，那現在問題又來了
-
如果是很多層的依賴該怎么辦？
-
例如多個建構式怎么辦呢？
-
在多個建構式中用戶想自定義需要被注入的建構式怎么辦？
總結3點問題
- 1.多級依賴問題
例如ITestB 的實體中依賴ITestC,一直無限依賴我們怎么解決呢？毫無疑問，做同樣的事情，但是要無限做下去，就使用 遞回,下面我們來改造我們的方法
-
2.多個建構式
-
取引數最多的方式注入 (AutoFac)
-
取并集方式注入 (ASP .NET Core)
-
-
3.自定義注入
我們可以使用特性標記的方式來實作，用戶在需要被選擇注入的建構式上加入特性標簽來完成
1.創建私有遞回方法，這個方法的作用就是創建物件用
private object CreateInstance(Type type,string serviceName = null)
{
}
2.我們選擇第一種方式實作,修改之前獲取第一個建構式的代碼，選擇最多引數注入
//找到目標型別的建構式，找引數最多的建構式
ConstructorInfo ctor = null;
var ctors = target.GetConstructors();
ctor = ctors.OrderByDescending(x => x.GetParameters().Length).First();
3.自定義特性CtorInjection，可以使用戶自定義選擇
//自定義建構式注入標記
[AttributeUsage(AttributeTargets.Constructor)]
public class CtorInjectionAttribute : Attribute
{
}
4.最終代碼
private object CreateInstance(Type type,string serviceName = null)
{
string key = $"{ type.FullName }{serviceName}";
container.TryGetValue(key, out Type target);
//存盤引數串列
List<object> paramList = new List<object>();
ConstructorInfo ctor = null;
//找到被特性標記的建構式作為注入目標
ctor = target.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(CtorInjectionAttribute), true));
//如果沒有被特性標記，那就取建構式引數最多的作為注入目標
if (ctor is null)
{
ctor = target.GetConstructors().OrderByDescending(x => x.GetParameters().Length).First();
}
//找到引數串列
var ctorParams = ctor.GetParameters();
foreach (var item in ctorParams)
{
//引數型別
Type paramType = item.ParameterType;
//遞回呼叫構建物件
object paramInstance = CreateInstance(paramType);
//構造出實體然后加入引數串列
paramList.Add(paramInstance);
}
object t = Activator.CreateInstance(target);
return t;
}
public TFrom Resolve<TFrom>()
{
return (TFrom)this.CreateInstance(typeof(TFrom));
}
4.屬性注入&方法注入
1.自定義特性PropInjection，可以使用戶自定義選擇
//自定義構造屬性注入標記
[AttributeUsage(AttributeTargets.Property)]
public class PropInjectionAttribute : Attribute
{
}
//自定義構造方法注入標記
[AttributeUsage(AttributeTargets.Method)]
public class MethodInjectionAttribute : Attribute
{
}
2.遍歷實體中被標記特性的屬性，
3.獲取屬性的型別，呼叫遞回構造物件函式，
4.設定目標物件的屬性值，
5.方法注入也是同理，換湯不換藥而已
private object CreateInstance(Type type,string serviceName = null)
{
string key = $"{ type.FullName }{serviceName}";
container.TryGetValue(key, out Type target);
//存盤引數串列
List<object> paramList = new List<object>();
ConstructorInfo ctor = null;
//找到被特性標記的建構式作為注入目標
ctor = target.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(CtorInjectionAttribute), true));
//如果沒有被特性標記，那就取建構式引數最多的作為注入目標
if (ctor is null)
{
ctor = target.GetConstructors().OrderByDescending(x => x.GetParameters().Length).First();
}
//找到引數串列
var ctorParams = ctor.GetParameters();
foreach (var item in ctorParams)
{
//引數型別
Type paramType = item.ParameterType;
//遞回呼叫構建物件
object paramInstance = CreateInstance(paramType);
//構造出實體然后加入引數串列
paramList.Add(paramInstance);
}
object t = Activator.CreateInstance(target);
//獲取目標型別的被特性標記的屬性<屬性注入>
var propetys = target.GetProperties().Where(x => x.IsDefined(typeof(PropInjectionAttribute), true));
foreach (var item in propetys)
{
//獲取屬性型別
Type propType = item.PropertyType;
object obj = this.CreateInstance(propType);
//設定值
item.SetValue(t, obj);
}
//獲取目標型別的被特性標記的方法<方法注入>
var methods = target.GetMethods().Where(x => x.IsDefined(typeof(MethodInjectionAttribute), true)).ToList();
foreach (var item in methods)
{
List<object> methodParams = new List<object>();
foreach (var p in item.GetParameters())
{
//獲取方法引數型別
Type propType = p.ParameterType;
object obj = this.CreateInstance(propType);
methodParams.Add(obj);
}
item.Invoke(t, methodParams);
}
return t;
}
public TFrom Resolve<TFrom>()
{
return (TFrom)this.CreateInstance(typeof(TFrom));
}
5.單介面多實作
假設我們一個介面被多個實體實作，我們需要注入怎么操作呢？
毫無疑問我們應該想到在注入時取一個別名，沒錯正是這種方法，但是也會存在一個問題，我們取了別名之后只能解決注入的場景？那依賴介面的地方如何知道注入哪一個實體呢？
1.注冊單介面多實體
container.Register<ITest, test1>("test1");
container.Register<ITest, test2>("test2");
ITest instance = container.Resolve<ITest>("test1");
ITest instance1 = container.Resolve<ITest>("test2");
2.創建標記特性，用來標記目標物件
[AttributeUsage(AttributeTargets.Parameter| AttributeTargets.Property)]
public class ParamterInjectAttribute : Attribute
{
public ParamterInjectAttribute(string nickName) => NickName = nickName;
public string NickName { get; private set; }
}
3.我們需要在依賴“單介面多實體的類中”使用時告訴引數，我們需要的實體，依然使用引數特性標記
public class use : IUse
{
private ITest _Test = null;
//告訴建構式依賴ITest介面時使用別名為test1的實體
public BLL1([ParamterInjectAttribute("test1")] ITest介面時使用別名為test1的實體 Test)
{
this._Test = Test;
}
}
4.在構造物件時查找是否被特性標記，然后構造物件
foreach (var item in ctor.GetParameters())
{
Type paramType = item.ParameterType;
string nickName = string.Empty;
//查找建構式的引數是否被特性標記
if (item.IsDefined(typeof(ParamterInjectAttribute), true))
{
//找到被標記需要構造的實體別名
nickName = item.GetCustomAttribute<ParamterInjectAttribute>().NickName;
}
//根據別名創建物件
object instance = CreateInstance(paramType,nickName);
if (instance != null)
{
paramList.Add(instance);
}
}
四、總結
目前還不是很完善，只是實作了屬性,方法,以及建構式注入，很多必要功能還沒有，下一步將在現有代碼基礎上利用Emit的方式來創建物件，加入基本的驗證環節以提高健壯性,加入生命周期管理，和AOP擴展，
第一版最終代碼
public class ManualContainer : IManualContainer
{
private static Dictionary<string, Type> container = new Dictionary<string, Type>();
public void Register<TFrom, To>(string servicesName = null) where To : TFrom
{
string Key = $"{typeof(TFrom).FullName}{servicesName}";
if (!container.ContainsKey(Key))
{
container.Add(Key, typeof(To));
}
}
public Tinterface Resolve<Tinterface>(string serviceName = null)
{
return (Tinterface)this.CreateInstance(typeof(Tinterface), serviceName);
}
private object CreateInstance(Type type, string serviceName = null)
{
string key = $"{ type.FullName }{serviceName}";
container.TryGetValue(key, out Type target);
object instance = ctorInjection(target);
propInjection(target, instance);
methodInjection(target, instance);
return instance;
}
/// <summary>
/// 建構式注入
/// </summary>
/// <param name="target">需要被創建的型別</param>
/// <returns>被創建的實體</returns>
private object ctorInjection(Type targetType)
{
List<object> paramList = new List<object>();
ConstructorInfo ctor = null;
ctor = targetType.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(CtorInjectionAttribute), true));
if (ctor is null)
{
ctor = targetType.GetConstructors().OrderByDescending(x => x.GetParameters().Length).First();
}
foreach (var item in ctor.GetParameters())
{
Type paramType = item.ParameterType;
string nickName = GetNickNameByAttribute(item);
object instance = CreateInstance(paramType, nickName);
if (instance != null)
{
paramList.Add(instance);
}
}
object t = Activator.CreateInstance(targetType, paramList.ToArray());
return t;
}
/// <summary>
/// 屬性注入
/// </summary>
/// <param name="targetType">需要被創建的型別</param>
/// <param name="sourceType">根據需要被創建的型別構造出的實體</param>
private void propInjection(Type targetType, object inststance)
{
var propetys = targetType.GetProperties().Where(x => x.IsDefined(typeof(PropInjectionAttribute), true));
foreach (var item in propetys)
{
Type propType = item.PropertyType;
string nickName = GetNickNameByAttribute(item);
object obj = this.CreateInstance(propType, nickName);
item.SetValue(inststance, obj);
}
}
/// <summary>
/// 方法注入
/// </summary>
/// <param name="targetType">需要被創建的型別</param>
/// <param name="sourceType">根據需要被創建的型別構造出的實體</param>
private void methodInjection(Type targetType, object inststance)
{
List<object> methodParams = new List<object>();
var methods = targetType.GetMethods().Where(x => x.IsDefined(typeof(MethodInjectionAttribute), true)).ToList();
foreach (var item in methods)
{
foreach (var p in item.GetParameters())
{
Type propType = p.ParameterType;
string nickName = GetNickNameByAttribute(item);
object obj = this.CreateInstance(propType, nickName);
methodParams.Add(obj);
}
item.Invoke(inststance, methodParams.ToArray());
}
}
private string GetNickNameByAttribute(ICustomAttributeProvider provider)
{
if (provider.IsDefined(typeof(ParamterInjectAttribute), true))
{
ParamterInjectAttribute attribute = provider.GetCustomAttributes(typeof(ParamterInjectAttribute), true)[0] as ParamterInjectAttribute;
return attribute.NickName;
}
return string.Empty;
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/376812.html
標籤：.NET技术