C# .net mvc 依赖注入、控制反转、Ioc、Autoface(草稿)

C# .net mvc 依赖注入、控制反转、Ioc、Autoface

概念：

控制反转：就是把依赖的创建移到使用这些依赖的类的外部

我想先看下面例子：

FoodServies类中有一个方法EatFood

public class FoodServies
{
public void EatFood()
{
Console.WriteLine("吃东西");
}
}

Systemdo类中需要调用EatFood,

public class Systemdo
{
FoodServies food;
//构造函数，实例化的时候调用
public Systemdo()
{
food = new FoodServies();
}
public void doSomething()
{
food.EatFood();
}
}

Systemdo依赖FoodServies类，当一个组件依赖另外一个组件时，我们称其为耦合。

为了降低组件直接的耦合程度，一般采用独立但相关的步骤：

1.在两块代码之间引入抽象层，我们通常用的接口。

//在两块代码之间引入抽象层，我们通常用的接口
public interface IFoodServies
{
public void EatFood();
}

public class FoodServies : IFoodServies
{
public void EatFood()
{
Console.WriteLine("吃东西");
}
}

public class Systemdo
{
IFoodServies food;
//构造函数，实例化的时候调用
public Systemdo()
{
food = new FoodServies();
}
public void doSomething()
{
food.EatFood();
}
}

2.把选择抽象实现的责任移到消费类的外部。

需要把FoodServies类的创建移到Systemdo类的外面

把依赖的创建移到使用这些依赖的类的外部，这称为控制反转模式，之所以这样命名，是因为反转的是依赖的创建，正因为如此，才消除了消费者类对依赖创建的控制。

实现

1.服务定位器（不推荐）

public interface IFoodServiesLocator
{
object GetFoodServies(Type servicrType);

}
public static class ServiesLocatorExtensions
{

public static TService GetFoodServies<TService>(this IFoodServiesLocator locator)
{
return (TService)locator.GetFoodServies(typeof(TService));
}
}

public interface IFoodServies
{
void EatFood();
}

public class FoodServies : IFoodServies
{
public void EatFood()
{
Console.WriteLine("吃东西");
}
}

public class Systemdo
{
IFoodServies food;
//
public Systemdo(IFoodServiesLocator locator)
{
food = locator.GetFoodServies<IFoodServies>();
}
public void doSomething()
{
food.EatFood();
}
}

调用

这里写代码片