public class HighLevelModule
{private readonly LowLevelModule _lowLowelModule;public HighLevelModule(){_lowLevelModule = new LowLevelModule();   }public void Call(){_lowLevelModule.Initiate();_lowLevelModule.Send();}
}public class LowLevelModule
{public void Initiate(){//do initiation before sending}public void Send(){//perform sending operation}
}

在上面的代码中，HighLevelModule直接依赖于LowLevelModule并且不遵循DIP的第一点。为什么这么重要？两者之间的直接且紧密耦合的关系使得在HighLevelModule上独立于LowLevelModule创建单元测试变得更加困难。你不得不在同一时间测试HighLevelModule和LowLevelModule，因为它们是紧密耦合。

public interface IOperation
{void Initiate();void Send();
}public class LowLevelModule: IOperation
{public void Initiate(){//do initiation before sending}public void Send(){//perform sending operation}
}

其次，由于HighLevelModule将仅依赖IOperation抽象，因此我们不能再在HighLevelModule类内部使用new LowLevelModule()。LowLevelModule需要从调用者上下文中注入到HighLevelModule类中。依赖项LowLevelModule需要反转。这就是术语“依赖倒置”和“控制反转”的来源。

public class HighLevelModule
{private readonly IOperation _operation;public HighLevelModule(IOperation operation){_operation = operation;}public void Call(){_operation.Initiate();_operation.Send();}
}

我们已经将 HighLevelModule和LowLevelModule彼此分离，现在两者都依赖于抽象IOperation。Send方法的行为可以从类之外，通过使用任何的IOperation选择实现来控制，例如LowLevelModule

public interface IOperation
{void Send();
}public class LowLevelModule: IOperation
{public LowLevelModule(){Initiate();}private void Initiate(){//do initiation before sending}public void Send(){//perform sending operation}
}public class HighLevelModule
{private readonly IOperation _operation;public HighLevelModule(IOperation operation){_operation = operation;}public void Call(){_operation.Send();}
}

2.抽象方法

public abstract class OperationBase
{public abstract void Send();
}public class LowLevelModule: OperationBase
{public LowLevelModule(){Initiate();}private void Initiate(){//do initiation before sending}public void Send(){//perform sending operation}
}public class HighLevelModule
{private readonly OperationBase _operation;public HighLevelModule(OperationBase operation){_operation = operation;}public void Call(){_operation.Send();}
}

上面的代码等效于使用interface。通常，只有在共享实现细节的情况下，我才使用abstract类。例如，如果HighLevelModule可以使用LowLevelModule或AnotherLowLevelModule，并且两个类都具有共享的实现细节，那么我将使用一个abstract类作为两者的基类。基类将实现IOperation，这是实际的抽象。

public interface IOperation
{void Send();
}public abstract class OperationBase: IOperation
{public OperationBase(){Initiate();}private void Initiate(){//do initiation before sending, also shared implementation in this example}public abstract void Send();
}public class LowLevelModule: OperationBase
{public void Send(){//perform sending operation}
}public class AnotherLowLevelModule: OperationBase
{public void Send(){//perform another sending operation}
}public class HighLevelModule
{private readonly IOperation _operation;public HighLevelModule(IOperation operation){_operation = operation;}public void Call(){_operation.Send();}
}

使用委托

public class Caller
{ public void CallerMethod(){var module = new HighLevelModule(Send);...}public void Send(){//this is the method injected into HighLevelModule}
}public class HighLevelModule
{private readonly Action _sendOperation;public HighLevelModule(Action sendOperation){_sendOperation = sendOperation;}public void Call(){_sendOperation();}
}

或者，您可以创建自己的委托并为其赋予一个有意义的名称。

public delegate void SendOperation();public class Caller
{ public void CallerMethod(){var module = new HighLevelModule(Send);...}public void Send(){//this is the method injected into HighLevelModule}
}public class HighLevelModule
{private readonly SendOperation _sendOperation;public HighLevelModule(SendOperation sendOperation){_sendOperation = sendOperation;}public void Call(){_sendOperation();}
}

使用泛型委托的好处是我们不需要为依赖项创建或实现一种类型，例如接口和类。我们可以从调用者上下文或其他任何地方使用任何方法或函数。

public class HighLevelModule
{private readonly IOperation _operation;public HighLevelModule(IOperation operation){_operation = operation;}public void Call(){_operation.Send();}
}

Setter 注入

public class HighLevelModule
{public IOperation Operation { get; set; }public void Call(){Operation.Send();}
}

方法注入

public class HighLevelModule
{private readonly IOperation _operationOne;private readonly IOperation _operationTwo;public void SetOperations(IOperation operationOne, IOperation operationTwo){_operationOne = operationOne;_operationTwo = operationTwo;}public void Call(){_operationOne.Send();_operationTwo.Send();}
}

使用方法注入时，作为参数传递的依赖项将保留在类中，例如作为字段或属性，以备后用。在方法中传递某些类或接口并仅在方法中使用时，这不算作方法注入。

public class Caller
{ public void CallerMethod(){var module = new HighLevelModule();module.SendEvent += Send ;...}public void Send(){//this is the method injected into HighLevelModule}
}public class HighLevelModule
{public event Action SendEvent = delegate {};public void Call(){SendEvent();}
}

通常，我的口头禅始终是使用构造函数注入，如果没有什么可迫使您使用Setter或Method注入的话，这也使我们能够在以后使用IoC容器。

public class Helper{public static IOperation GlobalStateOperation { get; set;}}public class HighLevelModule{public void Call(){Helper.GlobalStateOperation.Send();}}public class Caller{public void CallerMethod(){Helper.GlobalStateOperation = new LowLevelModule();var highLevelModule = new HighLevelModule();highLevelModule.Call();}}
}

全局状态可以表示为属性、方法甚至字段。重要的一点是，基础值具有公共setter和getter。setter和getter可以采用方法而不是属性的形式。

public interface IOperation
{void Send();
}public class LowLevelModule: IOperation
{public LowLevelModule(){Initiate();}private void Initiate(){//do initiation before sending}public void Send(){//perform sending operation}
}public class HighLevelModule
{private readonly Container _container;public HighLevelModule(Container container){_container = container;}public void Call(){IOperation operation = _container.Resolvel<IOperation>();operation.Send();}
}public class Caller
{public void UsingContainerObject(){//registry the LowLevelModule as implementation of IOperationvar register  = new Registry();registry.For<IOperation>.Use<LowLevelModule>();//wrap-up registry in a containervar container = new Container(registry);//inject the container into HighLevelModulevar highLevelModule = new HighLevelModule(container);highLevelModule.Call();     }
}

public interface IOperation
{void Send();
}public class LowLevelModule: IOperation
{public LowLevelModule(){Initiate();}private void Initiate(){//do initiation before sending}public void Send(){//perform sending operation}
}public interface IModuleFactory
{IOperation CreateModule();
}public class ModuleFactory: IModuleFactory
{public IOperation CreateModule(){//LowLevelModule is the implementation of the IOperation, //and it is hardcoded in the factory. return new LowLevelModule();}
}public class HighLevelModule
{private readonly IModuleFactory _moduleFactory;public HighLevelModule(IModuleFactory moduleFactory){_moduleFactory = moduleFactory;}public void Call(){IOperation operation = _moduleFactory.CreateModule();operation.Send();}
}public class Caller
{public void CallerMethod(){//create the factory as the implementation of abstract factoryIModuleFactory moduleFactory = new ModuleFactory();//inject the factory into HighLevelModulevar highLevelModule = new HighLevelModule(moduleFactory);   highLevelModule.Call();  }
}

我的建议是谨慎使用间接。服务定位器模式，如今被视为反模式。但是，有时可能需要使用工厂对象为您创建依赖关系。我的理想是避免使用间接，除非证明有必要。