架構，改善程序復用性的設計~第五講 復用離不開反射和IOC

從本文標題中可以看出，主要說的是反射技術和控制反轉（IOC）技術，本文主要先介紹一下我對這兩種技術的理解及它們的優缺點，最后再用實例來說一下使用方法。

反射：可以使用反射動態創建類型的實例，將類型綁定到現有對象，或從現有對象獲取類型並調用其方法或訪問其字段和屬性。這里，它最重要的是“動態性”，即根據條件動態創建“指定類型”的“實例”。

// Using GetType to obtain type information:
int i = 42;
System.Type type = i.GetType();
System.Console.WriteLine(type);

結果是：

System.Int32

本示例使用靜態方法 GetType(Object 基類派生的所有類型都繼承該方法） 獲取變量類型的簡單反射實例

// Using Reflection to get information from an Assembly:
System.Reflection.Assembly o = System.Reflection.Assembly.Load("mscorlib.dll");
System.Console.WriteLine(o.GetName());

結果是：

mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

本示例使用反射獲取已加載的程序集的完整名稱

反射一般用在以下情況中：

• 需要訪問程序元數據的屬性。linq to sql 中使用很多

• 執行后期綁定，訪問在運行時創建的類型的方法。與工廠模式一起使用，根據配置文件中的類型來動態建立實例

IOC:（Inversion of Control，英文縮寫為IoC）是一個重要的面向對象編程的法則來削減計算機程序的耦合問題。 控制反轉還有一個名字叫做依賴注入（Dependency Injection）。簡稱DI。實現IOC的架構有很多如：Avalon 、Spring、JBoss及Unity等。

理解IOC：可以把IoC模式看做是工廠模式的升華，可以把IoC看作是一個大工廠，只不過這個大工廠里要生成的對象都是在XML文件中給出定義的，然后利用Java 的“反射”編程，根據XML中給出的類名生成相應的對象。

實現非常簡單，根據容易名稱去創建對象即可

    /// <summary>
    /// The static factory of container
    /// </summary>
    public sealed class ContainerManager
    {
        /// <summary>
        /// Creates the specified container instance .
        /// </summary>
        /// <param name="containerName">Name of the container.</param>
        /// <returns></returns>
        public static IContainerContext GetContainer(string containerName)
        {
            return new UnityContainerContext(containerName);
        }
    }

以下是在實際項目中的使用，IOC架構是用Unity，它的基礎代碼是：

    /// <summary>
    /// The specific container context for Unity
    /// </summary>
    public class UnityContainerContext : ContainerContextBase
    {
        #region Fields

        /// <summary>
        /// The lock used for synchronous
        /// </summary>
        private static readonly object _synlock = new object();

        #endregion

        #region Constructor

        /// <summary>
        /// Initializes a new instance of the <see cref="UnityContainerContext"/> class.
        /// </summary>
        /// <param name="name">The name.</param>
        public UnityContainerContext(string name)
            : base(name)
        {
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets the current context.
        /// </summary>
        /// <value>The current context.</value>
        private HttpContext CurrentContext
        {
            get
            {
                HttpContext context = HttpContext.Current;
                if (context == null)
                {
                    throw new Exception("The current httpcontext is null");
                }
                return context;
            }
        }

        #endregion

        #region Override Methods

        /// <summary>
        /// Initializes container.
        /// </summary>
        public override void Initialize()
        {
            OnBeforeInitialized(new ContainerEventArgs(this, ContainerType.Unity));

            if (CurrentContext.Application[Name] == null)
            {
                lock (_synlock)
                {
                    if (CurrentContext.Application[Name] == null)
                    {
                        IUnityContainer currentContainer = new UnityContainer();
                        UnityConfigurationSection section = ConfigurationManager.GetSection("unity") as UnityConfigurationSection;
                        section.Containers[Name].Configure(currentContainer);
                        CurrentContext.Application[Name] = currentContainer;
                    }
                }
            }

            OnAfterInitialized(new ContainerEventArgs(this, ContainerType.Unity));
        }

        /// <summary>
        /// Resolves this instance.
        /// </summary>
        /// <typeparam name="T">Parameter type.</typeparam>
        /// <returns></returns>
        public override T Resolve<T>()
        {
            try
            {
                Initialize();

                IUnityContainer currentContainer = CurrentContext.Application[Name] as IUnityContainer;
                return currentContainer.Resolve<T>();
            }
            catch(Exception ex)
            {
                OnResolveFailed(new ContainerFailedEventArgs(this, ContainerType.Unity, ex));
                return default(T);
            }
        }

        /// <summary>
        /// Tears down.
        /// </summary>
        public override void TearDown()
        {
            OnBeforeTearDown(new ContainerEventArgs(this, ContainerType.Unity));

            CurrentContext.Application[Name] = null;

            OnAfterTearDown(new ContainerEventArgs(this, ContainerType.Unity));
        }

        #endregion

    }

在項目中通過unity來創建對象的代碼是：

        /// <summary>
        /// 數據層實體的個性操作對象
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <returns></returns>
        protected TEntity LoadRepositoryEntity<TEntity>()
        {
            IContainerContext container = ContainerManager.GetContainer("repositoryContainer");
            return container.Resolve<TEntity>();
        }

這樣，在BLL層調用DAL層對象時，可以通過LoadRepositoryEntity泛型方法來實現。