Object-oriented design (OOD) helps us develop high-performance, easy-to-scale, and reusable programs. Among them, Ood has an important idea that is the dependency inversion principle (DIP).
dependency Inversion principle (DIP): A principle of software architecture design (abstract concept)
Inversion of Control (IoC): a way of reversing flows, dependencies, and interfaces (specific implementations of dips)
Dependency Injection (DI): An implementation of the IOC, used to reverse the dependency (the specific implementation of the IOC)
IOC container: a framework of dependency injection used to map dependencies, manage object creation and life cycle (DI framework),
Unity: A Microsoft-launched IOC framework
TDD: test-driven development, a core practice and technology in agile development, is also a design methodology
The above contents are copied (English is not good, put here for reference), related content to see some, unknown feeling li.
Once wrote a hotel reading and writing room card procedures, different hotel door locks are not the same, the same hotel may also change the door lock, program flow:
1. Get the current hotel door lock type via API
2. Download the DLL that corresponds to the latch if necessary
3. Read and Write functions
First, define the interface
Create a new Class library (Lock.interface) with the following code:
namespace lock{public interface ILock {//<summary>/// locks initialized //</summary> <param name= "password" > Initialize password </param> //<returns></returns> bool Init (int password);} }
Is it an IOC? (I'm not sure)
Second, Unit testing
Create a new unit test project (lock.tests) with the following code:
1. Latch a unit test
/// <summary> ///door lock a test/// </summary>[TestClass ()] Public classlockatests {/// <summary> ///Initialize, password is a positive odd number/// </summary>[TestMethod ()] Public voidinittest () {ILock L=NewLocka (); varret = L.init (1); Assert.AreEqual (ret,true); RET= L.init (2); Assert.AreEqual (ret,false); RET= L.init (-1); Assert.AreEqual (ret,false); } }
2. Door Lock B Unit Test
<summary> ///Lock B Test ///</summary> [TestClass ()] public class lockbtests { <summary> ///initialization test, password is positive even //</summary> [TestMethod ()] public void Inittest () { ILock L = new lockb (); var ret = l.init (1); Assert.AreEqual (ret, false); ret = L.init (2); Assert.AreEqual (ret, true); ret = L.init ( -1); Assert.AreEqual (ret, false); }
Obviously the compilation does not pass (can not be compiled is also a test)
Iii. Definition of Classes
1. Create the door lock Class A library (Lock.locka) with the following code:
<summary>///Lock A/// </summary> public class Locka:ilock { //<summary>< c6/>///Initialize//</summary>// <param name= "password" > correct password is positive odd </param>/// < returns></returns> Public bool Init (int password) { return password > 0 && ( Password% 2) = = 1; } }
2. Create a door lock Class B library (LOCK.LOCKB) with the following code:
<summary>/// door lock b/// </summary> public class Lockb:ilock {// <summary >//Initialize///</summary>// <param name= "password" > correct password is positive even </param>// <returns></returns> Public bool Init (int password) { return password > 0 && ( Password% 2) = = 0; } }
After compiling successfully, go back to the test project, add the reference, compile the pass, run the test:
Not TDD?
Iv. Main Program
1. Adding the console project
2. Add Unity (5.8.6) package
3. Modify the app. config to:
<?xml version= "1.0" encoding= "Utf-8"?><configuration> <configSections> <section name= "Unity" ty Pe= "Microsoft.practices.unity.configuration.unityconfigurationsection,unity.configuration, Version=5.2.1.0, Culture=neutral, publickeytoken=6d32ff45e0ccc69f "/><!--Some of the content on the web copied over with errors, and later viewed the definition of unityconfigurationsection, copied the corresponding assembly type= "namespace. Class name, assembly" -</configSections> <unity> <containers> <container name= "Locka" > <register type= "Lock.ilock,lock.interface" mapto= "Lock.locka,lock.locka" ></register> </container> <containe R name= "lockb" > <register type= "lock.ilock,lock.interface" mapto= "lock.lockb,lock.lockb" ></register> ; </container> </containers> </unity> <startup> <supportedruntime version= "v4.0" sku= ". netframework,version=v4.5.2 "/> </startup></configuration>
4. Reference interface
The 5.Main method is as follows:
static void Main (string[] args) { var container = new UnityContainer (); unityconfigurationsection config = (unityconfigurationsection) configurationmanager.getsection ( Unityconfigurationsection.sectionname); "Locka");
ILock L = container. Resolve<ilock> (); Console.WriteLine (L.init (2)); Console.WriteLine (L.init (1)); Console.WriteLine (L.init (-1));
Console.readkey (); }
6. Copy the DLL for lock A to the running directory
7. The result of the operation is: false, True, false, is the result of door lock a
8. Change "Locka" to "lockb" and copy the DLL of door lock B to the running directory, and the result of operation is true, false, and false is the result of latch B.
It's Di, isn't it? We've all used unity.
At this point, the basic realization of the desired function, the future of the new hotel to increase the door lock C, door lock D is no problem, only the old hotel changed to lock e problem is not solved (estimate can be dynamically modified config file implementation, do not know there is no better way).
C # Ioc, DI, Unity, TDD ideas and practices