zoukankan      html  css  js  c++  java

  • [.NET] Rough Dependency Injection

    动机

    在设计系统架构的时候，在系统里加入Dependency Injection(DI)，让系统可以在不改变程序代码的状况下，抽换类别来提高重用性、扩充性。在.NET里可以选择一些的Framework来使用，例如：Spring Framework、Unity Application Block、Managed Extensibility Framework (MEF)。

    在一些中小型项目，套用上列这些Framework，常常会有种拿大炮打蚊子的感觉。因为这些Framework为了能够符合更多的使用情景，而加入了很多功能。一直加下去的结果，就是系统变的庞大并且较难理解上手。以Spring来说，光是怎么写配置文件的操作，都可以写成书了。当然这样用意是好的，一个够强大的Framework学习曲线必然会较高，但是学会之后能适用的范围也会更广。

    不过不得面对的现实是，很多开发人员没时间学习各种Framework(或是无心学习?)。在系统架构里加入这些强大Framework，提高了系统的各项质量时，也拉高技术门坎。过高的技术门坎在后续开发、维护，补充人手时会越来越艰难…。以此为发想于是就萌生了：建立简单易用的一组类别，完成Dependency Injection(DI)应该具备的基础功能。只需要学习基础功能，就能为系统加入Dependency Injection(DI)功能。这样就能降低开发人员的技术门坎，让更多的开发人员能做为补充人力加入项目。

    本篇文章介绍一个实作Dependency Injection(DI)基础功能的Rough Dependency Injection实作，这个实作定义对象之间的职责跟互动，用来反射生成要注入的对象。为自己做个纪录，也希望能帮助到有需要的开发人员。

    * 必须要特别声明的是，Spring、MEF这些Framework有很高的价值。当这些Framework成为整个团队基础开发知识时，整个团队的开发能力将会提升一个台阶。

    结构

    Rough Dependency Injection主要是将Dependency Injection(DI) 基础功能，拆为两大部分：对象生成、对象设定，并且将复杂的对象设定隔离在系统之外。模式的结构如下：

    主要的参与者有：

    TEntity
    -欲注入系统的对象。

    IReflectProfileRepository
    - ReflectProfile进出系统边界的接口。
    -将对象设定隔离在系统之外，可以抽换各种不同数据存储。
    -极端的案例可以抽换成为HardCodeRepository，连设定都从系统移除。

    ReflectProfile
    -DTO物件。
    -储存用来反射生成IReflectBuilder所需要的参数。

    IReflectBuilder
    -经由ReflectProfile储存参数，反射生成的对象接口。
    -使用ReflectProfile储存参数，生成TEntity。

    ReflectManager
    -藉由IReflectProfileRepository取得系统储存的ReflectProfile。
    -使用ReflectProfile储存参数，反射生成IReflectBuilder。
    -使用IReflectBuilder与ReflectProfile，生成TEntity。

    透过下面的图片说明，可以了解相关对象之间的互动流程。

    实作

    范列下载

    实作说明请参照范例程序内容：RoughDependencyInjectionSample点此下载

    ReflectProfile、IReflectProfileRepository

    首先为了将对象设定这个职责，隔离在系统之外。所以在整个模块的边界套用Repository模式，建立出IReflectProfileRepository。并且使用ReflectProfile做为进出系统边界的DTO对象，这个ReflectProfile对象储存生成对象的参数数据。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    namespace CLK.Reflection
    {
        public sealed class ReflectProfile
        {
            // Constructors
            public ReflectProfile()
            {
                // Default
                this.ProfileName = string.Empty;
                this.BuilderType = string.Empty;
                this.Parameters = new Dictionary<string, string>();
            }
     
     
            // Properties
            public string ProfileName { get; set; }
     
            public string BuilderType { get; set; }
     
            public Dictionary<string, string> Parameters { get; private set; }
        }
    }
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    namespace CLK.Reflection
    {
        public interface IReflectProfileRepository
        {
            // Methods
            string GetDefaultProfileName(string reflectSpace);
     
            ReflectProfile GetProfile(string reflectSpace, string profileName);
     
            IEnumerable<ReflectProfile> CreateAllProfile(string reflectSpace);
        }
    }

    IReflectBuilder、ReflectManager

    接着处理ReflectManager来使用ReflectProfile。ReflectManager主要的工作就是透过IReflectProfileRepository取得的ReflectProfile，用ReflectProfile来反射生成IReflectBuilder实作。然后在利用这个IReflectBuilder实作，配合ReflectProfile来生成系统需要注入的TEntity。之所以不直接反射生成TEntity另外再建一层IReflectBuilder，是因为不希望在TEntity里，混入DI相关功能的相依。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    namespace CLK.Reflection
    {
        public interface IReflectBuilder
        {
            // Methods
            object Create(Dictionary<string, string> parameters);
        }
    }
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    namespace CLK.Reflection
    {
        public class ReflectManager
        {
            // Fields
            private readonly IReflectProfileRepository _repository = null;
     
     
            // Constructors
            public ReflectManager(IReflectProfileRepository repository)
            {
                #region Contracts
     
                if (repository == null) throw new ArgumentNullException();
     
                #endregion
     
                // Arguments
                _repository = repository;
            }
     
     
            // Methods
            private TEntity Create<TEntity>(ReflectProfile profile) where TEntity : class
            {
                #region Contracts
     
                if (profile == null) throw new ArgumentNullException();
     
                #endregion
     
                // Require
                if (string.IsNullOrEmpty(profile.ProfileName) == true) throw new InvalidOperationException();
                if (string.IsNullOrEmpty(profile.BuilderType) == true) throw new InvalidOperationException();
     
                // BuilderType
                Type builderType = Type.GetType(profile.BuilderType);
                if (builderType == null) throw new ArgumentException(String.Format("Action:{0}, State:{1}, BuilderType:{2}", "Reflect", "Fail to Access BuilderType", profile.BuilderType));
     
                // Builder
                IReflectBuilder builder = Activator.CreateInstance(builderType) as IReflectBuilder;
                if (builder == null) throw new ArgumentException(String.Format("Action:{0}, State:{1}, BuilderType:{2}", "Reflect", "Fail to Create Builder", profile.BuilderType));
                 
                // Entity
                TEntity entity = builder.Create(profile.Parameters) as TEntity;
                if (entity == null) throw new ArgumentException(String.Format("Action:{0}, State:{1}, BuilderType:{2}", "Reflect", "Fail to Create Entity", profile.BuilderType));
     
                // Return
                return entity;
            }
     
     
            public IEnumerable<TEntity> CreateAll<TEntity>(string reflectSpace) where TEntity : class
            {
                #region Contracts
     
                if (string.IsNullOrEmpty(reflectSpace) == true) throw new ArgumentNullException();
     
                #endregion
     
                // Result
                List<TEntity> entityList = new List<TEntity>();
     
                // Create
                foreach (ReflectProfile profile in _repository.CreateAllProfile(reflectSpace))
                {
                    TEntity entity = this.Create<TEntity>(profile);
                    if (entity != null)
                    {
                        entityList.Add(entity);
                    }
                }
     
                // Return
                return entityList;
            }
     
            public TEntity Create<TEntity>(string reflectSpace) where TEntity : class
            {
                #region Contracts
     
                if (string.IsNullOrEmpty(reflectSpace) == true) throw new ArgumentNullException();
     
                #endregion
     
                // ProfileName
                string profileName = _repository.GetDefaultProfileName(reflectSpace);
                if (string.IsNullOrEmpty(profileName) == true) throw new ArgumentException(String.Format("Action:{0}, State:{1}, ReflectSpace:{2}", "Reflect", "Fail to Get DefaultProfileName", reflectSpace));
     
                // Return
                return this.Create<TEntity>(reflectSpace, profileName);
            }
     
            public TEntity Create<TEntity>(string reflectSpace, string profileName) where TEntity : class
            {
                #region Contracts
     
                if (string.IsNullOrEmpty(reflectSpace) == true) throw new ArgumentNullException();
                if (string.IsNullOrEmpty(profileName) == true) throw new ArgumentNullException();
     
                #endregion
     
                // Profile
                ReflectProfile profile = _repository.GetProfile(reflectSpace, profileName);
                if (profile == null) return default(TEntity);
     
                // Return
                return this.Create<TEntity>(profile);
            }       
        }   
    }

    ConfigReflectProfileRepository

    在范例程序里，示范了IReflectProfileRepository的实作，这个实作使用App.config做为ReflectProfile的数据源。相关的程序代码如下，有兴趣的开发人员可以花点时间学习，在需要扩充IReflectProfileRepository的时候(例如：改用SQL存放)，就可以自行加入相关的实作。

    使用

    DisplayWorker

    接着撰写一个虚拟的IDisplayWorker来示范如何套用Rough Dependency Injection。首先在项目内建立IDisplayWorker，这个IDisplayWorker很简单的只开放一个Show函式让系统使用。接着建立两个实作IDisplayWorker的对象，这两个对象就是后续要用来注入系统的对象。到这边可以发现，套用Rough Dependency Injection注入的对象，不会有额外的相依，只要完成自己应有的职责就可以。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    namespace TestProject
    {
        public interface IDisplayWorker
        {
            // Methods
            void Show();
        }
     
        public class AAADisplayWorker : IDisplayWorker
        {
            // Properties
            public string AAA { get; set; }
     
     
            // Methods
            public void Show()
            {
                Console.WriteLine(this.AAA);
            }
        }
     
        public class BBBDisplayWorker : IDisplayWorker
        {
            // Properties
            public int BBB { get; set; }
     
     
            // Methods
            public void Show()
            {
                Console.WriteLine(this.BBB);
            }
        }
    }

    DisplayWorkerBuilder

    要让注入对象，不会有额外的相依，也是要付出代价。要另外建立一层Builder，用来生成注入对象，以及隔离注入对象与Rough Dependency Injection的相依。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    namespace TestProject
    {
        public class AAADisplayWorkerBuilder : IReflectBuilder
        {
            // Methods
            public object Create(Dictionary<string, string> parameters)
            {
                AAADisplayWorker worker = new AAADisplayWorker();
                worker.AAA = Convert.ToString(parameters["AAA"]);
                return worker;
            }
        }
     
        public class BBBDisplayWorkerBuilder : IReflectBuilder
        {
            // Methods
            public object Create(Dictionary<string, string> parameters)
            {
                BBBDisplayWorker worker = new BBBDisplayWorker();
                worker.BBB = Convert.ToInt32(parameters["BBB"]);
                return worker;
            }
        }
    }

    执行

    最后建立使用IDisplayWorker的范例RoughDependencyInjectionSample，在RoughDependencyInjectionSample内透过ReflectManager搭配App.config里的设定，为系统注入两个IDisplayWorker实作让系统使用。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
     
      <!-- ConfigSections -->
      <configSections>
        <sectionGroup name="testProject">
          <section name="displayWorker" type="CLK.Reflection.Implementation.ConfigReflectProfileSection, CLK" />
        </sectionGroup>
      </configSections>
     
      <!-- TestProject -->
      <testProject>
        <displayWorker>
          <add name="AAA" builderType="TestProject.AAADisplayWorkerBuilder, TestProject" AAA="Clark=_=y-~" />
          <add name="BBB" builderType="TestProject.BBBDisplayWorkerBuilder, TestProject" BBB="1234" />
        </displayWorker>
      </testProject>
     
    </configuration>
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    namespace TestProject
    {
        class Program
        {
            static void Main(string[] args)
            {
                // ReflectManager
                ReflectManager reflectManager = new ReflectManager(new ConfigReflectProfileRepository());
     
                // CreateAll
                foreach (IDisplayWorker worker in reflectManager.CreateAll<IDisplayWorker>(@"testProject/displayWorker"))
                {
                    // Show
                    worker.Show();
                }
     
                // End
                Console.ReadLine();
            }
        }
    }

    期許自己~
    能以更簡潔的文字與程式碼，傳達出程式設計背後的精神。
    真正做到「以形寫神」的境界。

    分类: .NET
  • 相关阅读:
    qemu-kvm磁盘读写的缓冲(cache)的五种模式
    关于追踪qemu 源码函数路径的一个方法
    准备升大三啦
    关于Vim的一个配置文件
    POJ 3253
    hihocoder 第二十五周 spfa 最短路
    POJ 2718 穷举
    《鸟哥Linux私房菜基础学习篇》命令索引
    博文流
    《SDN核心技术剖析和实战指南》3.3读书笔记
  • 原文地址：https://www.cnblogs.com/Leo_wl/p/2684488.html
Copyright © 2011-2022 走看看