[IOC] StructureMap的疑惑。

发布时间：2020-12-12 14:35:41 所属栏目：MsSql教程来源：网络整理

导读：大家好。 ? ? StructureMap的一些简单应用（基本用法、自动装配、生命周期、延迟加载）。 Q：什么是IoC ? ? IoC：Inversion of Control。中文名：控制反转。是一种思想、一种模式。控制权被反转。例子：企业经理有一批商品要存入仓库，但是现在没有仓库，所

大家好。

? ? StructureMap的一些简单应用（基本用法、自动装配、生命周期、延迟加载）。

Q：什么是IoC

? ? IoC：Inversion of Control。中文名：控制反转。是一种思想、一种模式。控制权被反转。

例子：企业经理有一批商品要存入仓库，但是现在没有仓库，所以需要找一个仓库，然后将商品存入。

场景A：经理去找一座仓库。=>找仓库的控制权一直在主管手上，经理必须自己找。

场景B：经理告诉手下去找一座仓库。=>经理将找仓库的控制权交给手下。这种将控制权转移的过程就是Inversion of Control。

Q：为什么需要IoC？

逻辑：（1）创建一个SqlServerHelper对象。（2）存入到SqlServer数据库中。

场景A：

class ProductManager
	{   
		private readonly IDBHelper dbHelper;
		public ProductManager ()
		{
			dbHelper = new SqlServerHelper ();
		}
		public void SaveProduct (Product product)
		{
			dbHelper.Save (product);
		}
	}

	internal interface IDBHelper
	{
		void Save (Product product);
	}

	class SqlServerHelper : IDBHelper
	{
		public void Save (Product product)
		{
			//Save in SqlServer
		}
	}

场景A：

1、创建SqlServerHelper的控制权在经理手里。

2、ProductManager与SqlServerHelper组件存在依赖。当依赖变化时，也就是更换SqlServerHelper组件的时候，我们需要改ProductManager代码。

3、当ProductManager调用端需要save到Oracle的时候。ProductManager代码无法复用。

4、给ProductManager添加测试。如果测试挂掉。无法确定问题是出在ProductManager还是SqlServerHelper(代码逻辑比较简单，这里不太明显)。（比如鼠标不Work了，不能确定到底是鼠标本身的问题，还是电脑USB的问题）

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

场景B：

class ProductManager
	{
		private readonly IDBHelper dbHelper;

		public ProductManager ()
		{
			dbHelper = Employee.Find ();
		}

		public void SaveProduct (Product product)
		{
			dbHelper.Save (product);
		}
	}

	internal interface IDBHelper
	{
		void Save (Product product);
	}

	class SqlServerHelper : IDBHelper
	{
		public void Save (Product product)
		{
			//Save in SqlServer
		}
	}

	static class Employee
	{
		public static SqlServerHelper Find ()
		{
			return new SqlServerHelper ();
		}
	}

场景B：

1、创建组件的控制权由经理交给了第三方Employee。（控制权转移）

2、ProductManager与SqlServerHelper组件之间没有直接的依赖，而是通过第三方Employee去控制它们之间的依赖（松散耦合）。

3、ProductManager可复用。当ProductManager调用方需要存入Oralce的时候，只需要改变Employee中代码即可。（可复用）

4、组件相对独立、可以分别测试ProductManager组件和SqlServerHelper组件。（比如电脑中各个部件都需要独立的测试。测试通过后在组装一起）

这里并不是IoC的具体实现。可以将第三方Employee理解为一个容器。只需要知道把控制权转移到第三方是为了削弱ProductManager与SqlServerHelper的依赖即可。

那么为什么需要IoC就很清晰了：降低组件之间的耦合、提高软件可测试性、代码复用等。

? Q：怎么实现IoC?

IoC容器：一个负责组件管理的容器，可以在容器中注册组件，也可从容器中取出组件。

现在我们可以把Employee对象理解为一个容器。我们在这个容器里管理SqlServerHelper组件。

1、首先在容器里注册ProductManager的依赖组件SqlServerHelper（用一个XML文件当做容器）

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section
        name="StructureMap"
        type="StructureMap.Configuration.StructureMapConfigurationSection,StructureMap"/>
  </configSections>
  <StructureMap MementoStyle="Attribute">
    <DefaultInstance
        PluginType="IoC_SMTest.IDBHelper,IoC_SMTest"
        PluggedType="IoC_SMTest.SqlServerHelper,IoC_SMTest" />
  </StructureMap>
</configuration>

PluginType:"IoC_SMTest.IDBHelper"?IDBHelper为ProductManager下的接口。

pluggedType:"IoC_SMTest.SqlServerHelper"?SqlServerHelper为IDBHelper的实现

此时容器里定义了：IDBHelper的实现是SqlServerHelper。（ProductManager所依赖的组件是SqlServerHelper）

2、获取该容器里的依赖关系

ObjectFactory.Initialize(x =>
            {
                x.PullConfigurationFromAppConfig = true;
            });

执行这步之后。程序把Config里定义的依赖关系pull下来，已经知道IDBHelper依赖SqlServerHelper组件

3、从容器中获取组件

ObjectFactory.GetInstance<IDBHelper>();

在给产品代码加一个OracleDB。实现SqlServer和Oracle之间的切换。

class ProductManager
	{
		private readonly IDBHelper dbHelper;

		public ProductManager ()
		{
			dbHelper = ObjectFactory.GetInstance<IDBHelper> ();
		}

		public void SaveProduct (Product product)
		{
			dbHelper.Save (product);
		}
	}

	interface IDBHelper
	{
		void Save (Product product);
	}

	class SqlServerHelper : IDBHelper
	{
		public void Save (Product product)
		{
			//Save in SqlServer
		}
	}

	class OracleHelper : IDBHelper
	{
		public void Save (Product product)
		{
			//Save in Oracle
		}
	}

如果ProductManager需要Oracle组件。可以直接修改容器中的依赖关系即可，产品代码不需要改变。

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section
        name="StructureMap"
        type="StructureMap.Configuration.StructureMapConfigurationSection,IoC_SMTest"
        PluggedType="IoC_SMTest.OracleHelper,IoC_SMTest" />
  </StructureMap>
</configuration>

依赖注入（被动）：

依赖注入(Dependency Injection)：这里指的将ProductManager的依赖组件注入到ProductManager中。

常用的几种方式：

1、构造函数注入（Constructor?Injection）

class ProductManager
    {
        private readonly IDBHelper dbHelper;
        public ProductManager(IDBHelper dbHelper)
        {
            this.dbHelper = dbHelper;
        }

        public void SaveProduct(Product product)
        {
            dbHelper.Save(product);
        }
    }

使用：

 var dbhelper = ObjectFactory.GetInstance<IDBHelper>();//这块可以StructureMap自动装配，直接获取ProductManager实例，自动查找依赖，后面会提。
 var productManager = new ProductManager(dbhelper);

2、属性注入（Setter Injection）

class ProductManager
    {
        public IDBHelper dbHelper { get; set; }
        public void SaveProduct(Product product)
        {
            dbHelper.Save(product);
        }
    }

使用：

var dbhelper = ObjectFactory.GetInstance<IDBHelper>();
var productManager = new ProductManager {dbHelper = dbhelper};

推荐使用Constructor?Injection，这样看起来很清晰，一个类需要多少个组件。在构造函数里一目了然。

依赖查找（主动）

class ProductManager
	{
		private readonly IDBHelper dbHelper;

		public ProductManager ()
		{
			dbHelper = ObjectFactory.GetInstance<IDBHelper> ();
		}

		public void SaveProduct (Product product)
		{
			dbHelper.Save (product);
		}
	}

当这段代码运行的时候。ProductManager会回自动从容器中找IDBHelpr的依赖组件，并且实例化。这个过程是主动的。

个人认为这就是依赖查找。

DI和IoC之间是什么关系呢？

IoC是一种思想、一种模式。它把调用者（ProductManager）和被调用者（SqlServerHelper）之间的依赖。转移到第三方容器当中。从而实现解耦。

DI都做了些什么。有两个相对独立的组件ProductManager与SqlServerHelper。在系统运行时候把SqlServerHelper组件注入到ProductManager中。建立了2个组件的关系。

这个关系从哪儿来？IoC容器里。

个人认为DI是IoC的一种实现。

StructureMap的应用

StructureMap是.NET下的IoC框架。官方传送门? ? ? 下载地址

新建一测试工程引用StructureMap.dll。开始StructureMap的第一个测试。

场景：一个商品存入到数据库中。先验证，通过验证存入数据库。

准备一些接口、类供测试使用。

public class Product
    {
        public string Name { get; set; }
        public string BeSavedDataBase { get; set; }
        public bool IsValidate { get; set; }
        public bool IsSave { get; set; }
        public string UpdateBy { get; set; }
    }

    public interface IRepository
    {
        Product Save(Product product);
    }
    public class Repository : IRepository
    {
        public string UpdateBy { get; set; }
        private readonly string dataBase;
        public Repository(string dataBase)
        {
            this.dataBase = dataBase;
        }

        public Product Save(Product product)
        {
            if (string.IsNullOrEmpty(dataBase)) return product;
            product.BeSavedDataBase = dataBase;
            product.IsSave = true;
            product.UpdateBy = UpdateBy;
            return product;
        }
    }

    public interface IValidator
    {
        bool Validate(Product product);
    }

    public class Validator : IValidator
    {
        public bool Validate(Product product)
        {
            if (string.IsNullOrEmpty(product.Name)) return false;
            product.IsValidate = true;
            return true;
        }
    }
   
    public class ProductController
    {
        private readonly IValidator validator;
        private readonly IRepository repository;
        public ProductController(IValidator validator,IRepository repository)
        {
            this.validator = validator;
            this.repository = repository;
        }

        public Product Save(Product product)
        {
            var flag = validator.Validate(product);
            if (!flag) return product;
            repository.Save(product);
            return product;
        }
    }

基本用法(Usage)&自动装配(AutoErect)

除了上面Demo中将依赖关系定义在XML中之外也可以用Registry?DSL来注册依赖组件。

1、注册依赖组件到容器中(IRepository与Repository、IValidator与Validator)。

x.For<IT>().Use<T>();

把IT与T之间的依赖关系注入到容器中

ObjectFactory.Initialize(
                x =>
                {
                    x.For<IValidator>().Use<Validator>();
                    x.For<IRepository>().Use<Repository>()
                        .Ctor<string>().Is(TestProfile.SqlServerDB)
                        .SetProperty(rep => rep.UpdateBy = TestProfile.UpdateByAdmin);
                });

(1).Ctor<string>().is(TestProfile.SqlServerDB) 给Repository类里的构造函数提供实参。

(2).SetProperty(rep => rep.UpdateBy = TestProfile.UpdateByAdmin) 给Repository类里的UpdateBy属性赋值。也有另外的属性赋值方法比如.WithProperty("UpdateBy").EqualTo(TestProfile.UpdateByAdmin);

2、获取ProductController

var controller = ObjectFactory.GetInstance<ProductController>();

通过上面准备测试类的代码可以观察到ProductController依赖IRepository和IValidator两个组件。

因为IRepository和IValidator的依赖关系已经注册在容器里。

当获取ProductController的时候。SM会自动查找ProductController的依赖(IRepository、IValidator)，并且实例化它们注入到ProductController中。这就是自动装配的过程。

PS：如果依赖没有提前注册到容器中。SM会抛“202”异常No Default Instance defined for PluginFamily.....

3、应用

controller.Save(product);

测试代码：

[TestClass]
    public class AutoErectTest
    {
        [TestInitialize]
        public void SetUp()
        {
            ObjectFactory.Initialize(
                x =>
                {
                    x.For<IValidator>().Use<Validator>();
                    x.For<IRepository>().Use<Repository>()
                        .Ctor<string>().Is(TestProfile.SqlServerDB)
                        .WithProperty("UpdateBy")
                        .EqualTo(TestProfile.UpdateByAdmin); ;
                });
        }

        [TestMethod]
        public void should_auto_erect_IContactValidator_and_IContactRepository_instance_when_get_ContactController_instance()
        {
            var controller = ObjectFactory.GetInstance<ProductController>();
            var entityResult = controller.Save(TestProfile.ProductWithName);
            Assert.AreEqual(true,entityResult.IsValidate);
            Assert.AreEqual(true,entityResult.IsSave);
        }
    }

生命周期(Life Cycle)

SM默认的对象生命周期是PerRequest.每次都是创建一个新的实例。我们可以通过注册依赖组件的时候指定组件的生命周期。

下面以IValidator组件为例：

该测试类下的2个私有方法：获取组件实例，检查组件是否为Null.

private static void GetObjectsPerOneThread(ref IValidator V1,ref IValidator V2)
        {
            V1 = ObjectFactory.GetInstance<IValidator>();
            V2 = ObjectFactory.GetInstance<IValidator>();
            CheckIsNull(V1,V2);
            Assert.AreSame(V1,V2);
        }

private static void CheckIsNull(params IValidator[] values)
        {
            foreach (var contactValidator in values)
            {
                Assert.IsNotNull(contactValidator);
            }
        }

Singleton：

        [TestMethod]
        public void objects_should_be_same_when_LifeCycal_is_Singleton()
        {
            ObjectFactory.Initialize(x => x.For<IValidator>().Singleton().Use<Validator>());
            IValidator v1 = null,v2 = null,v3 = null,v4 = null;

            ThreadStart starterFirst = () => GetObjectsPerOneThread(ref v1,ref v2);
            new Thread(starterFirst).Start();
            Thread.Sleep(500);

            ThreadStart starterSecond = () => GetObjectsPerOneThread(ref v3,ref v4);
            new Thread(starterSecond).Start();
            Thread.Sleep(500);

            CheckIsNull(v1,v2,v3,v4);
            Assert.AreSame(v1,v2);
            Assert.AreSame(v1,v3);
        }

场景

x.For<ISessionFactory>().Singleton().Use(y => NHibernateHelper.SessionFactory);

为了确保IValidator实例唯一，创建两个线程来获取4个IValidator。

Singleton适用ISessionFactory(NHibernate)场景。因为ISessionFactory是线程安全的。允许多个线程同时访问它来创建或者Open Session实例。所以我们注册ISessionFactory的时候应该指定为Singleton.

HybridHttpOrThreadLocalScoped：

[TestMethod]
        public void objects_should_be_not_same_when_a_instance_LifeCycal_is_HybridHttpOrThreadLocalScoped()
        {
            ObjectFactory.Initialize(
                x => x.For<IValidator>()
                         .HybridHttpOrThreadLocalScoped()
                         .Use<Validator>());
            IValidator v1 = null,v4 = null,v5 = null,v6 = null;

            ThreadStart starterFirst = () => GetObjectsPerOneThread(ref v1,ref v4);
            new Thread(starterSecond).Start();
            Thread.Sleep(500);

            ThreadStart starterThird = () => GetObjectsPerOneThread(ref v5,ref v6);
            new Thread(starterThird).Start();
            Thread.Sleep(500);


            Assert.AreSame(v1,v2);
            Assert.AreSame(v3,v4);
            Assert.AreSame(v5,v6);
            Assert.AreNotSame(v1,v3);
            Assert.AreNotSame(v3,v5);
            Assert.AreNotSame(v1,v5);
        }

场景：

x.For<Session>().HybridHttpOrThreadLocalScoped().Use<Session>()

如果存在HttpContext，那么在HttpContext上唯一。否则在TreadLocal上唯一。HttpContext和TreadLocal销毁，组件也随之销毁。

应用场景：注册(NHibernate)Session的时候。应该让一个Session在一个请求中唯一。因为Session不是线程安全。一个Session是操作数据库的一个工作单元。如果多个请求共享一个Session那么就会出现并发、脏数据等情况。

Transient：

[TestMethod]
        public void objects_should_be_not_same_when_LifeCycal_is_Transient()
        {
            ObjectFactory.Initialize(x => x.For<IValidator>().Transient().Use<Validator>());
            var v1 = ObjectFactory.GetInstance<IValidator>();
            var v2 = ObjectFactory.GetInstance<IValidator>();
            CheckIsNull(v1,v2);
            Assert.AreNotSame(v1,v2);
        }

每次请求都会创建一个新的实例。

HttpContextScoped：

[TestMethod]
        public void objects_should_be_same_when_LifeCycal_is_HttpContextScoped()
        {
            ObjectFactory.Initialize(x => x.For<IValidator>().HttpContextScoped().Use<Validator>());
            IValidator v1 = null,v2 = null;
            ThreadStart starterFirst = () => GetObjectsPerOneThread(ref v1,ref v2);
            var thread = new Thread(starterFirst);
            thread.Start();
            Thread.Sleep(500);
            Assert.AreSame(v1,v2);
            thread.Abort();
            Assert.IsNull(v1);
            Assert.IsNull(v2);
        }

HttpContext销毁(一个请求结束)，组件也随之销毁。

想想还是提一下延迟加载吧，因为我没有想到在什么场景下应用，其实延迟加载就是应用到MS的Lazy关键字。Lazy<T>有2个属性，第一个是IsValueCreate，第二个是Value.

没有调用Value的时候，IsValueCreate为false。也就是该对象没有被创建。如果调用value属性，T就会被创建，那么IsValueCreate就会变为true。

延迟加载(Lazy)

[TestClass]
    public class LazyTest
    {
        [TestMethod]
        public void lazy_object_should_not_be_created_when_it_does_not_be_use()
        {

            ObjectFactory.Initialize(
                x =>
                {
                    x.For<Lazy<ProductController>>()
                          .Use(y => new Lazy<ProductController>(y.GetInstance<ProductController>));
                    x.For<IValidator>().Use<Validator>();
                    x.For<IRepository>().Use<Repository>()
                        .Ctor<string>().Is("admin")
                        .WithProperty("DataBase").EqualTo("SqlServer");
                });

            var controller = ObjectFactory.GetInstance<Lazy<ProductController>>();
            Assert.IsFalse(controller.IsValueCreated);
            controller.Value.Save(new Product { Name = "ipad" });
            Assert.IsTrue(controller.IsValueCreated);
        }

        [TestMethod]
        public void exceptionCode_should_be_202_when_lazy_object_do_not_to_be_created()
        {
            ObjectFactory.Initialize(
                x =>
                {
                    x.For<Lazy<IValidator>>()
                        .Use(y => new Lazy<IValidator>(y.GetInstance<Validator>));
                    x.For<Lazy<IRepository>>()
                        .Use(y => new Lazy<IRepository>(y.GetInstance<Repository>));
                });
            const string expectExceptionMsg = "No Default Instance defined for PluginFamily ";
            const int expectExceptionCode = 202;

            try
            {
                ObjectFactory.GetInstance<ProductController>();
                Assert.Fail();
            }
            catch (StructureMapException exception)
            {
                Assert.AreEqual(expectExceptionCode,exception.ErrorCode);
                Assert.IsTrue(exception.Message.Contains(expectExceptionMsg));
            }
        }
    }

到这里一些简单的StructureMap的应用就告一段落了。当然还有一些其他的应用，可以从官方API里找。

最后跑下所有测试。

还有一些没有涉及到的。以后有时间会慢慢深入。看出文章存在问题的朋友请给一些反馈。持续改进。

测试代码下载。

完

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!