.Net配置文件——反射+配置文件存储范例实例【C#.Net教程】,.Net，配置文件，反射

设置文件+反射确切去除了挑选语句的烦琐，带来了幽美的赶脚！

起首改进了一下类（接上文）：

namespace ClassLib
{
    /// <summary>
    /// Interface IGreetingStrategy
    /// </summary>
    /// <remarks>Editor：v-liuhch CreateTime：2015/6/28 11:01:58</remarks>
    public interface IGreetingStrategy
    {
        string GreetingType { get; }
        void SetGreetingWords(ITextControl textContrl);
    }

    /// <summary>
    /// Class EnglishGreeting
    /// </summary>
    /// <remarks>Editor：v-liuhch CreateTime：2015/6/28 11:02:38</remarks>
    public class EnglishGreeting : IGreetingStrategy
    {
        public string GreetingType
        {
            get { return "English"; }
        }

        public void SetGreetingWords(ITextControl textContrl)
        {
            textContrl.Text = "hello,readers";
        }
    }

    /// <summary>
    /// Class ChineseGreeting
    /// </summary>
    /// <remarks>Editor：v-liuhch CreateTime：2015/6/28 11:02:56</remarks>
    public class ChineseGreeting : IGreetingStrategy
    {
        private string greetingType;
        public ChineseGreeting(string greetingType)
        {

            this.greetingType = greetingType;
        }
        public ChineseGreeting() : this("中文") { }
        public ChineseGreeting(XmlNode section) {
            XmlAttribute attr = section.SelectSingleNode("params").Attributes["greetingType"];//猎取属性值
            greetingType = attr.Value;//为字段赋值
        }
        public string GreetingType
        {
            get { return greetingType; }
        }

        public void SetGreetingWords(ITextControl textContrl)
        {
            textContrl.Text = "你好啊，小读者！";
        }
    }

    /// <summary>
    /// Class GeneralClass:这个类能够另有许多的字段，属性，要领，这里只是简写下
    /// PS：GeneralClass是一个一般的范例，这个类内部保护着IGreetingStrategy，挪用的时刻照样依据多态详细挪用。
    /// </summary>
    /// <remarks>Editor：v-liuhch CreateTime：2015/6/28 11:08:04</remarks>
    public class GeneralClass
    {
        private IGreetingStrategy gs;
        public GeneralClass(IGreetingStrategy gs)
        {
            this.gs = gs;
        }
        public string GeneralProperty
        {
            get
            {
                //做一些分外的事情，这里省略
                return "<span sytle='color:red'>" + gs.GreetingType + "</span>";
            }
        }
        public void GeneralMethod(ITextControl textContrl)
        {
            //做一些分外的事情，这里省略
            gs.SetGreetingWords(textContrl);
            textContrl.Text = "<span sytle='color:red'>" + textContrl.Text + "</span>";
            //省略。。。。。。。
        }


    }

}

然后在设置文件中定义好我们要运用的详细类和自定义标签的处置惩罚顺序：

  <!--greetingStrategy节点及其处置惩罚顺序设置-->
  <configSections>
    <section name="greetingStrategy" type="ClassLib.GreetingConfigurationHandler,ClassLib"/>
  </configSections>
  <greetingStrategy type="ClassLib.ChineseGreeting,ClassLib">
    <params greetingType="***中文问候***"/>  <!--组织函数的参数-->
  </greetingStrategy>

这里，ChineseGreeting是我们要运用的类，上面定义的是处置惩罚greetingStrategy的类；

接着，写这个类的详细完成：

namespace ClassLib
{
    public class GreetingConfigurationHandler : IConfigurationSectionHandler
    {
        /*
         处置惩罚有参数的组织函数的对象的建立：
         */
        /// <summary>
        /// 建立设置节处置惩罚顺序。
        /// </summary>
        /// <param name="parent">父对象。</param>
        /// <param name="configContext">设置上下文对象。</param>
        /// <param name="section">节 XML 节点。</param>
        /// <returns>建立的节处置惩罚顺序对象。</returns>
        /// <exception cref="System.NotImplementedException"></exception>
        /// <remarks>Editor：v-liuhch CreateTime：2015/6/30 20:34:54</remarks>
        public object Create(object parent, object configContext, System.Xml.XmlNode section)
        {
            //猎取节点type属性的值
            Type t = Type.GetType(section.Attributes["type"].Value);
            object obj=null;

            try
            {
                /* 2，在要实例的类中到场一个组织函数，吸收一个XmlNode节点，将greeting_stragetgy的节点在此通报，然后在这个组织函数中举行处置惩罚；*/
                //假如t包括有参数为xmlnode的组织函数，直接运用这个组织函数
                Type[] paras = { typeof(XmlNode) };
                ConstructorInfo constructors = t.GetConstructor(paras);
                if (constructors != null)
                {
                    object[] paramters = { section };
                    return Activator.CreateInstance(t, paramters); //传入读取到的组织函数的参数
                }

                if (section.SelectSingleNode("params") == null)  //无参数组织函数
                {
                    obj = Activator.CreateInstance(t);
                }
                else  //有参数组织函数
                {
                    /*1，在此类中对战略类举行处置惩罚，获得params节点的属性值，然后通报给详细实例化的类；*/

                    //猎取params节点的属性greetingType的值
                    XmlAttribute attr = section.SelectSingleNode("params").Attributes["greetingType"];
                    object[] parameters = { attr.Value };
                    obj = Activator.CreateInstance(t, parameters); //传入读取到的组织函数的参数
                } 
            }
            catch (Exception)
            {

                return null;
            }
            
            return obj ;
        }
    }
}

在建立要领中，我们先推断ChineseGreeting类有无一个参数为节点的组织要领，假如有的话，就直接将section看成参数，在应用反射建立范例实例的时刻传进去；

假如没有如许的组织要领，我们就在这个处置惩罚类内里读取XML文件中的参数，然后在范例实例化的时刻传进去；

两种体式格局比较，实在都是一样的，只过是这个参数读取的日夕的题目；个人对比了下，以为在这个类内里读取设置文件中的组织函数参数的体式格局越发天真，个人偏幸。

写个东西测试下：

 #region 自定义节点存储范例信息——反射要领
            IGreetingStrategy greetingStrategy = (IGreetingStrategy)ConfigurationManager.GetSection("greetingStrategy");
            if (greetingStrategy != null)
            {
                GeneralClass generalClass = new GeneralClass(greetingStrategy);
                ltrGreetingType.Text = generalClass.GeneralProperty;
                generalClass.GeneralMethod(ltrGreetingWord);
            }
            #endregion

嘿嘿，相对轻易。