PHP dependency inversion (Dependency Injection) code example, dependency inversion principle

Implementation class:

Copy code The code is as follows:

class Container
{
Protected $settings = array();

Public function set($abstract, $concrete = null)
{
           if ($concrete === null) {
              $concrete = $abstract;
}

           $this->settings[$abstract] = $concrete;
}

Public function get($abstract, $parameters = array())
{
If (!isset($this->settings[$abstract])) {
             return null;
}

           return $this->build($this->settings[$abstract], $parameters);
}

Public function build($concrete, $parameters)
{
If ($concrete instanceof Closure) {
               return $concrete($this, $parameters);
}

         $reflector = new ReflectionClass($concrete);

If (!$reflector->isInstantiable()) {
                throw new Exception("Class {$concrete} is not instantiable");
}

$constructor = $reflector->getConstructor();

If (is_null($constructor)) {
                return $reflector->newInstance();
}

$parameters = $constructor->getParameters();
          $dependencies = $this->getDependencies($parameters);

           return $reflector->newInstanceArgs($dependencies);
}

Public function getDependencies($parameters)
{
         $dependencies = array();
foreach ($parameters as $parameter) {
$dependency = $parameter->getClass();
                 if ($dependency === null) {
If ($parameter->isDefaultValueAvailable()) {
$dependencies[] = $parameter->getDefaultValue();
                     } else {
                         throw new Exception("Can not be resolve class dependency {$parameter->name}");
                }
              } else {
                      $dependencies[] = $this->get($dependency->name);
            }
}

          return $dependencies;
}
}

Implementation example:

Copy code The code is as follows:

require 'container.php';

interface MyInterface{}
class Foo implements MyInterface{}
class Bar implements MyInterface{}
class Baz
{
Public function __construct(MyInterface $foo)
{
$this->foo = $foo;
}
}

$container = new Container();
$container->set('Baz', 'Baz');
$container->set('MyInterface', 'Foo');
$baz = $container->get('Baz');
print_r($baz);
$container->set('MyInterface', 'Bar');
$baz = $container->get('Baz');
print_r($baz);

Why Dependency Injection

Dependency injection and inversion of control are synonyms and have been merged. Inversion of Control (IoC) is an important object-oriented programming principle to reduce the coupling problem of computer programs. Inversion of control is also called dependency injection (Dependency Injection). Abbreviated as DI.
Origin
As early as 2004, Martin Fowler asked the question "What aspects of control have been reversed?" He concluded that the acquisition of dependent objects was reversed. Based on this conclusion, he coined a better name for inversion of control: dependency injection. Many extraordinary applications (more elegant and complex than HelloWorld.java) are composed of two or more classes that cooperate with each other to implement business logic, which makes each object need, the object with which it cooperates (that is, a reference to the object it depends on). If this fetching process were to be implemented on its own, as you can see, this would lead to code that is highly coupled and difficult to test. IoC is also known as "Dependency Inversion Principle". Almost all frameworks use the "inverted injection (Fowler 2004) technique, which can be said to be an application of IoC principles. Programmers of object-oriented programming languages such as SmallTalk, C++, Java or various .NET languages have used these principles . Inversion of control is the core of the Spring framework. When an object is created, the reference of the object it depends on is passed to it by an external entity that controls all objects in the system. Dependencies are injected into the object. Therefore, inversion of control is the inversion of responsibility for how an object obtains a reference to the object it depends on.
Edit this paragraph IoC is a design pattern
IoC is IoC, not. What technology, like GoF, is a design pattern. Interface Driven Design interface driver has many benefits. It can provide different flexible subclass implementations, increase code stability and robustness, etc., but the interface must be implemented. , that is, the following statement must be executed sooner or later: AInterface a = new AInterfaceImp(); In this way, a coupling relationship is generated, such as: 　Class A 　{ 　AInterface a; 　A() 　{ 　} 　aMethod() 　{ 　　a = new AInterfaceImp() ; } } ClassA and AInterfaceImp are dependent. If you want to use another implementation of AInterface, you need to change the code. Of course, we can build a Factory to generate the desired specific implementation of AInterface based on conditions, that is: InterfaceImplFactory { AInterface create(Object condition) { if(condition = condA) { return new AInterfaceImpA(); } elseif(condition = condB) { return new AInterfaceImpB(); The above problems have been solved, but in essence this code coupling has not changed. This coupling can be completely solved through the IoC model. It moves the coupling out of the code and puts it into a unified XML file, and uses a container to transfer it when needed. This dependency relationship is formed, that is, the required interface implementation is injected into the class that requires it. This may be the origin of the term "dependency injection". IOC mode, the IOC container that implements the IOC mode is introduced into the system, and the IOC container can manage the life cycle, dependencies, etc. of the object, thereby making the application configuration and... The rest of the full text >>

An interview question: What technical websites do you often visit? What technical websites and open source projects are there in c#net?

Domestic cnblog 51cto csdn

Overseas
www.asp.net
www.codeproject.com
www.codeplex.com

As for open source projects, where is 51aspx You can get

the famous Nunit, Json.net, log4net, lucene.net, paint.net, mono etc., take a look at the list below

1.[TEST] xUnit .net - One of the best testing frameworks for TDD.
2.[TEST] RhinoMocks mocking framework - Make testing easier by creating mocks.
3.[TEST] White for automation of Windows applications - Use code to drive Windows programs for testing.
4.[TEST] Gallio Automation Platform - Can run many test frameworks, such as MSTest, xUnit, NUnit and MbUnit.
5.[DATA] Fluent NHibernate - Fluent NHibernate allows you to set mapping relationships using C# code.
6.[OOP] StructureMap Dependency Injection/Inversion of Control - Decouple classes and dependencies.
7.[OOP] Managed Extensibility Framework - Convert from static compiler to dynamic language program
8.[APPFX] s#arp architecture for web applications - Rapidly develop web applications with ASP.NET MVC and NHibernate.
9.[APPFX] OpenRasta REST based framework for building web applications - Let your program have a REST API interface.
10.[APPFX] CSLA.NET Application Framework - Comprehensive framework for .NET development
11.[APPFX] Spring.NET Application Framework - Comprehensive framework for Web development
12.[RUNTIME] Mono enables .NET on Linux and Mac - Use .NET on Linux, BSD, and OS X.
13.[UTIL] Sandcastle Help File Builder - Create MSDN-style documentation.
14.[HELPER] EasyHook for Windows API Hooking - Extend unmanaged code with managed code.
15.[HELPER] Json.NET for working with JSON formatted data - Serialize .NET objects with one statement.
16.[HELPER] Excel Data Reader for Excel 97 to 2007 - ...the rest of the full text>>