C#中的扩展方法

扩展方法使你能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。 扩展方法是一种特殊的静态方法，但可以像扩展类型上的实例方法一样进行调用。 以上是msdn官网对扩展方法的描述，现在我通过一个情景例子来对此进行阐释。假设一个控制台程序class Program{}里面的主函数如下：

static void Main(string[] args)
        {
            DateTime now = DateTime.Now;
            string time = now.ToString("yyyy-MM-dd HH:mm:ss"); 
            Console.WriteLine(time);
            Console.ReadKey();
        }

假设需求变了，日期的显示格式要变成"yyyy-MM-dd"这种格式，当然只需要初始化time时按下面写法改写即可：

string time = now.ToString("yyyy-MM-dd");

但是如果要改变日期格式的有很多个类呢？每个都要改一次吗？这样一旦需求变来变去就忙死人了。传统的解决方式是封装一个帮助类，在里面写方法，然后供其他类调用。

本例在当前项目模仿添加一个DateHelper类:public class DateHelper{}，在类里面定义方法：

public static string DateToString(DateTime dt)
        {
            return dt.ToString("yyyy-MM-dd HH:mm:ss");
        }

于是原来的主函数改写如下：

static void Main(string[] args)
        {
            DateTime now = DateTime.Now;
            string time = DateHelper.DateToString(now);
            Console.WriteLine(time);
            Console.ReadKey();
        }

此时如果变需求，只需要改写DateHelp类里的DateToString()方法就行了，不管有多少个类调用此方法，都会被影响。问题解决了，可是这样要调用另一个类的方法，还是有点麻烦，有没有什么方法能够让我们像now.DateToString()一样直接调用呢？当然DateTime是微软写好的，我们改不了，无法创建想要的实例方法，于是，便引出了扩展方法。
下面是扩展方法的要素：

1.此方法必须是一个静态方法

2.此方法必须放在静态类中

3.此方法的第一个参数必须以this开头，并且指定此方法是扩展自哪个类型

根据以上要素，我们DateHelper类改成静态类：public static class DateHelper{} ，同时改写DateToString()方法：

public static string DateToString(this DateTime dt)
        {
            return dt.ToString("yyyy-MM-dd HH:mm:ss");
        }

此时回到主函数方法体，输入"now."便可以看见自动提示有个DateToString()方法，于是代码可以这样写：

static void Main(string[] args)
        {
            DateTime now = DateTime.Now; 
            string time = now.DateToString();
            Console.WriteLine(time);
            Console.ReadKey();
        }

显而易见，这样用起来会更加便捷，而且这样让我们看起来确实就像是被扩展类型本身具有的实例方法一样，可读性很高。下面概括一下扩展方法的特点：

1.扩展方法扩展自哪个类型，就必须是此类型的变量来使用，其他类型无法使用，本例扩展自DateTime类型，就只能是被DateTime类型的变量.出来(now.DateToString())
2.扩展方法中的this后面的参数不属于方法的参数，本例是无参数，this后面的DateTime dt是指明扩展方法扩展自何种类型
3.如果扩展方法和实例方法具有相同的签名，则优先调用实例方法
4.扩展自父类上的方法，可以被子类的对象直接使用
5.扩展自接口上的方法，可以被实现类的对象直接使用
6.扩展方法最终还是被编译器编译成：静态类.静态方法()，本例中now.DateToString()最终还是会被编译成DateHelper.DateToString(now)，这是它的本质

实际上，我们可能会遇到这样的情景，如在接口扩展一个方法的时候，所有的原本已实现该接口的类都要实现新扩展的方法，这样的改动是一个很麻烦的工作，可以使用扩展方法“曲线救国”；而有时候我们想为某个类添加新方法却不想改动这个类，那么扩展方法这种“伪添加”方法的方式就体现出它的价值了。最常见的扩展方法是LINQ标准查询运算符，运用广泛，这种方便快捷的方式理应博得码农们点1024个赞。

 

不逆袭，不 I T ！
Can't fly , can't be an IT guy !

转载自：http://www.cnblogs.com/0weibin/p/3954639.html

说明：做项目中遇到一种场景，需要根据查询时间段， 获取时间段中中每个月份对应的金额(费用统计)。如截图中的两列

因为列是动态的， 首先想到的就是后天拼接JSON格式字符串， 然后返回到前台， 组装表头及内容。 但是当前系统中easyUI版本为1.2，并不支持 data属性(官方从1.3.2开始支持)。所以只能返回list<T> 格式。

网上一搜相关代码很多， 看客可以自己搜索一下。 我这里记录一下我当时使用场景及用法，已备以后使用。

1.需要引用cglib jar包， 我用的版本是2.2

2.建一个实体对象 DynamicBean.java 。主要用来处理对象。

public class DynamicBean {
    private Object object = null; // 动态生成的类

    private BeanMap beanMap = null; // 存放属性名称以及属性的类型

    public DynamicBean() {
        super();
    }

    public DynamicBean(Map propertyMap) {
        this.object = generateBean(propertyMap);
        this.beanMap = BeanMap.create(this.object);
    }

    /**
     * @param propertyMap
     * @return
     */
    private Object generateBean(Map propertyMap) {
        BeanGenerator generator = new BeanGenerator();
        Set keySet = propertyMap.keySet();
        for (Iterator<String> i = keySet.iterator(); i.hasNext();) {
            String key = (String) i.next();
            generator.addProperty(key, (Class) propertyMap.get(key));
        }
        return generator.create();
    }

    /**
     * ��bean���Ը�ֵ
     * @param property ������
     * @param value ֵ
     */
    public void setValue(Object property, Object value) {
        beanMap.put(property, value);
    }

    /**
     * ͨ���������õ�����ֵ
     * @param property ������
     * @return ֵ
     */
    public Object getValue(String property) {
        return beanMap.get(property);
    }

    /**
     * 返回新生成的对象
     * @return
     */
    public Object getObject() {
        return this.object;
    }
}

3. 原来对象， 及需要拼接到对象中的属性字段集合处理方法。

/**
*参数说明：
*  object ： 查询结果数组中对象。
*  moneyMap ： 为对象对应所有月份数据集合
*  解释：已经查询出一组账单对象集合List<Bill> , 而moneyMap为对象中的一个属性 
*  Map<String,Bigdecimal>， 存放了月份及金额
*/
private Object dynamicClass(Object object, Map<String, BigDecimal> moneyMap) throws Exception {
        // 字段 - 值 集合
        HashMap<String, Object> returnMap = new HashMap<String, Object>();
        // 字段 - 字段类型 集合
        HashMap<String, Object> typeMap = new HashMap<String, Object>();
        // 获取传入类
        Class<? extends Object> type = object.getClass();
        BeanInfo beanInfo = Introspector.getBeanInfo(type);
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        // 获取对象中已存在的数据
        for (int i = 0; i < propertyDescriptors.length; i++) {
            PropertyDescriptor descriptor = propertyDescriptors[i];
            String propertyName = descriptor.getName();
            if (!propertyName.equals("class") && !propertyName.equals("monthMap")) {
                Method readMethod = descriptor.getReadMethod();
                Object result = readMethod.invoke(object, new Object[0]);
                if (result != null) {
                    returnMap.put(propertyName, result);
                } else {
                    String propertyType = descriptor.getPropertyType().toString();
                    if (propertyType.contains("java.math.BigDecimal")) {
                        returnMap.put(propertyName, new BigDecimal(0));
                    } else {
                        returnMap.put(propertyName, "");
                    }
                }
                typeMap.put(propertyName, descriptor.getPropertyType());
            }
        }
        // 获取月份数据， 变为字段属性
        Set<String> monthKeys = moneyMap.keySet();
        for (Iterator<String> it = monthKeys.iterator(); it.hasNext();) {
            String key = (String) it.next();
            // 字段类型
            typeMap.put(key, Class.forName("java.math.BigDecimal"));
            // 字段对应值
            returnMap.put(key, moneyMap.get(key));
        }
        // map转换成实体对象
        DynamicBean bean = new DynamicBean(typeMap);
        // 赋值
        Set<String> keys = typeMap.keySet();
        for (Iterator<String> it = keys.iterator(); it.hasNext();) {
            String key = (String) it.next();
            bean.setValue(key, returnMap.get(key));
        }
        Object obj = bean.getObject();
        return obj;
    }

做笔记使用， 说不定以后还会用到。

动态类实现

using System;  
using System.Collections.Generic;  
using System.Reflection.Emit;  
using System.Reflection;  
using System.Threading;  
  
namespace CopyMapFile  
{  
/** <summary>  
/// 类帮助器,可以动态对类,类成员进行控制(添加,删除),目前只支持属性控制。  
/// 注意,属性以外的其它成员会被清空,功能还有待完善,使其不影响其它成员。  
/// </summary>  
    public class ClassHelper  
    {  
        #region 公有方法  
        /** <summary>  
        /// 防止实例化。  
        /// </summary>  
        private ClassHelper() { }  
  
        /** <summary>  
        /// 根据类的类型型创建类实例。  
        /// </summary>  
        /// <param name="t">将要创建的类型。</param>  
        /// <returns>返回创建的类实例。</returns>  
        public static object CreateInstance(Type t)  
        {  
            return Activator.CreateInstance(t);  
        }  
  
        /** <summary>  
        /// 根据类的名称,属性列表创建型实例。  
        /// </summary>  
        /// <param name="className">将要创建的类的名称。</param>  
        /// <param name="lcpi">将要创建的类的属性列表。</param>  
        /// <returns>返回创建的类实例</returns>  
        public static object CreateInstance(string className, List<CustPropertyInfo> lcpi)  
        {  
            Type t = BuildType(className);  
            t = AddProperty(t, lcpi);  
            return Activator.CreateInstance(t);  
        }  
  
        /** <summary>  
        /// 根据属性列表创建类的实例,默认类名为DefaultClass,由于生成的类不是强类型,所以类名可以忽略。  
        /// </summary>  
        /// <param name="lcpi">将要创建的类的属性列表</param>  
        /// <returns>返回创建的类的实例。</returns>  
        public static object CreateInstance(List<CustPropertyInfo> lcpi)  
        {  
            return CreateInstance("DefaultClass", lcpi);  
        }  
  
        /** <summary>  
        /// 根据类的实例设置类的属性。  
        /// </summary>  
        /// <param name="classInstance">将要设置的类的实例。</param>  
        /// <param name="propertyName">将要设置属性名。</param>  
        /// <param name="propertSetValue">将要设置属性值。</param>  
        public static void SetPropertyValue(object classInstance, string propertyName, object propertSetValue)  
        {  
            classInstance.GetType().InvokeMember(propertyName, BindingFlags.SetProperty,  
                                          null, classInstance, new object[] { Convert.ChangeType(propertSetValue, propertSetValue.GetType()) });  
        }  
  
        /** <summary>  
        /// 根据类的实例获取类的属性。  
        /// </summary>  
        /// <param name="classInstance">将要获取的类的实例</param>  
        /// <param name="propertyName">将要设置的属性名。</param>  
        /// <returns>返回获取的类的属性。</returns>  
        public static object GetPropertyValue(object classInstance, string propertyName)  
        {  
            return classInstance.GetType().InvokeMember(propertyName, BindingFlags.GetProperty,  
                                                          null, classInstance, new object[] { });  
        }  
  
        /** <summary>  
        /// 创建一个没有成员的类型的实例,类名为"DefaultClass"。  
        /// </summary>  
        /// <returns>返回创建的类型的实例。</returns>  
        public static Type BuildType()  
        {  
            return BuildType("DefaultClass");  
        }  
  
        /** <summary>  
        /// 根据类名创建一个没有成员的类型的实例。  
        /// </summary>  
        /// <param name="className">将要创建的类型的实例的类名。</param>  
        /// <returns>返回创建的类型的实例。</returns>  
        public static Type BuildType(string className)  
        {  
  
            AppDomain myDomain = Thread.GetDomain();  
            AssemblyName myAsmName = new AssemblyName();  
            myAsmName.Name = "MyDynamicAssembly";  
  
            //创建一个永久程序集,设置为AssemblyBuilderAccess.RunAndSave。  
            AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,  
                                                            AssemblyBuilderAccess.RunAndSave);  
  
            //创建一个永久单模程序块。  
            ModuleBuilder myModBuilder =  
                myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");  
            //创建TypeBuilder。  
            TypeBuilder myTypeBuilder = myModBuilder.DefineType(className,  
                                                            TypeAttributes.Public);  
  
            //创建类型。  
            Type retval = myTypeBuilder.CreateType();  
  
            //保存程序集,以便可以被Ildasm.exe解析,或被测试程序引用。  
            //myAsmBuilder.Save(myAsmName.Name + ".dll");  
            return retval;  
        }  
  
        /** <summary>  
        /// 添加属性到类型的实例,注意:该操作会将其它成员清除掉,其功能有待完善。  
        /// </summary>  
        /// <param name="classType">指定类型的实例。</param>  
        /// <param name="lcpi">表示属性的一个列表。</param>  
        /// <returns>返回处理过的类型的实例。</returns>  
        public static Type AddProperty(Type classType, List<CustPropertyInfo> lcpi)  
        {  
            //合并先前的属性,以便一起在下一步进行处理。  
            MergeProperty(classType, lcpi);  
            //把属性加入到Type。  
            return AddPropertyToType(classType, lcpi);  
        }  
  
        /** <summary>  
        /// 添加属性到类型的实例,注意:该操作会将其它成员清除掉,其功能有待完善。  
        /// </summary>  
        /// <param name="classType">指定类型的实例。</param>  
        /// <param name="cpi">表示一个属性。</param>  
        /// <returns>返回处理过的类型的实例。</returns>  
        public static Type AddProperty(Type classType, CustPropertyInfo cpi)  
        {  
            List<CustPropertyInfo> lcpi = new List<CustPropertyInfo>();  
            lcpi.Add(cpi);  
            //合并先前的属性,以便一起在下一步进行处理。  
            MergeProperty(classType, lcpi);  
            //把属性加入到Type。  
            return AddPropertyToType(classType, lcpi);  
        }  
  
        /** <summary>  
        /// 从类型的实例中移除属性,注意:该操作会将其它成员清除掉,其功能有待完善。  
        /// </summary>  
        /// <param name="classType">指定类型的实例。</param>  
        /// <param name="propertyName">要移除的属性。</param>  
        /// <returns>返回处理过的类型的实例。</returns>  
        public static Type DeleteProperty(Type classType, string propertyName)  
        {  
            List<string> ls = new List<string>();  
            ls.Add(propertyName);  
  
            //合并先前的属性,以便一起在下一步进行处理。  
            List<CustPropertyInfo> lcpi = SeparateProperty(classType, ls);  
            //把属性加入到Type。  
            return AddPropertyToType(classType, lcpi);  
        }  
  
        /** <summary>  
        /// 从类型的实例中移除属性,注意:该操作会将其它成员清除掉,其功能有待完善。  
        /// </summary>  
        /// <param name="classType">指定类型的实例。</param>  
        /// <param name="ls">要移除的属性列表。</param>  
        /// <returns>返回处理过的类型的实例。</returns>  
        public static Type DeleteProperty(Type classType, List<string> ls)  
        {  
            //合并先前的属性,以便一起在下一步进行处理。  
            List<CustPropertyInfo> lcpi = SeparateProperty(classType, ls);  
            //把属性加入到Type。  
            return AddPropertyToType(classType, lcpi);  
        }  
        #endregion  
 
        #region 私有方法  
        /** <summary>  
        /// 把类型的实例t和lcpi参数里的属性进行合并。  
        /// </summary>  
        /// <param name="t">实例t</param>  
        /// <param name="lcpi">里面包含属性列表的信息。</param>  
        private static void MergeProperty(Type t, List<CustPropertyInfo> lcpi)  
        {  
            foreach (PropertyInfo pi in t.GetProperties())  
            {  
                CustPropertyInfo cpi = new CustPropertyInfo(pi.PropertyType.FullName, pi.Name);  
                lcpi.Add(cpi);  
            }  
        }  
  
        /** <summary>  
        /// 从类型的实例t的属性移除属性列表lcpi,返回的新属性列表在lcpi中。  
        /// </summary>  
        /// <param name="t">类型的实例t。</param>  
        /// <param name="ls">要移除的属性列表。</param>  
        private static List<CustPropertyInfo> SeparateProperty(Type t, List<string> ls)  
        {  
            List<CustPropertyInfo> ret = new List<CustPropertyInfo>();  
            foreach (PropertyInfo pi in t.GetProperties())  
            {  
                foreach (string s in ls)  
                {  
                    if (pi.Name != s)  
                    {  
                        CustPropertyInfo cpi = new CustPropertyInfo(pi.PropertyType.FullName, pi.Name);  
                        ret.Add(cpi);  
                    }  
                }  
            }  
  
            return ret;  
        }  
  
        /** <summary>  
        /// 把lcpi参数里的属性加入到myTypeBuilder中。注意:该操作会将其它成员清除掉,其功能有待完善。  
        /// </summary>  
        /// <param name="myTypeBuilder">类型构造器的实例。</param>  
        /// <param name="lcpi">里面包含属性列表的信息。</param>  
        private static void AddPropertyToTypeBuilder(TypeBuilder myTypeBuilder, List<CustPropertyInfo> lcpi)  
        {  
            PropertyBuilder custNamePropBldr;  
            MethodBuilder custNameGetPropMthdBldr;  
            MethodBuilder custNameSetPropMthdBldr;  
            MethodAttributes getSetAttr;  
            ILGenerator custNameGetIL;  
            ILGenerator custNameSetIL;  
  
            // 属性Set和Get方法要一个专门的属性。这里设置为Public。  
            getSetAttr =  
                MethodAttributes.Public | MethodAttributes.SpecialName |  
                    MethodAttributes.HideBySig;  
  
            // 添加属性到myTypeBuilder。  
            foreach (CustPropertyInfo cpi in lcpi)  
            {  
                //定义字段。  
                FieldBuilder customerNameBldr = myTypeBuilder.DefineField(cpi.FieldName,  
                                                                          Type.GetType(cpi.Type),  
                                                                          FieldAttributes.Private);  
                customerNameBldr.SetConstant("11111111");  
                //定义属性。  
                //最后一个参数为null,因为属性没有参数。  
                custNamePropBldr = myTypeBuilder.DefineProperty(cpi.PropertyName,  
                                                                 PropertyAttributes.HasDefault,  
                                                                 Type.GetType(cpi.Type),  
                                                                 null);  
  
                custNamePropBldr.SetConstant("111111111");  
                //定义Get方法。  
                custNameGetPropMthdBldr =  
                    myTypeBuilder.DefineMethod(cpi.GetPropertyMethodName,  
                                               getSetAttr,  
                                               Type.GetType(cpi.Type),  
                                               Type.EmptyTypes);  
  
                custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();  
  
                try  
                {  
                    custNameGetIL.Emit(OpCodes.Ldarg_0);  
                    //custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);  
                    custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);  
                    custNameGetIL.Emit(OpCodes.Ret);  
                }  
                catch (Exception ex)  
                {  
  
                     
                }  
  
                //定义Set方法。  
                custNameSetPropMthdBldr =  
                    myTypeBuilder.DefineMethod(cpi.SetPropertyMethodName,  
                                               getSetAttr,  
                                               null,  
                                               new Type[] { Type.GetType(cpi.Type) });  
  
                custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();  
  
                custNameSetIL.Emit(OpCodes.Ldarg_0);  
                custNameSetIL.Emit(OpCodes.Ldarg_1);  
                custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);  
                custNameSetIL.Emit(OpCodes.Ret);  
                //custNamePropBldr.SetConstant("ceshi");  
                //把创建的两个方法(Get,Set)加入到PropertyBuilder中。  
                custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);  
                custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);  
            }  
        }  
  
        /** <summary>  
        /// 把属性加入到类型的实例。  
        /// </summary>  
        /// <param name="classType">类型的实例。</param>  
        /// <param name="lcpi">要加入的属性列表。</param>  
        /// <returns>返回处理过的类型的实例。</returns>  
        public static Type AddPropertyToType(Type classType, List<CustPropertyInfo> lcpi)  
        {  
            AppDomain myDomain = Thread.GetDomain();  
            AssemblyName myAsmName = new AssemblyName();  
            myAsmName.Name = "MyDynamicAssembly";  
  
            //创建一个永久程序集,设置为AssemblyBuilderAccess.RunAndSave。  
            AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,  
                                                            AssemblyBuilderAccess.RunAndSave);  
  
            //创建一个永久单模程序块。  
            ModuleBuilder myModBuilder =  
                myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");  
            //创建TypeBuilder。  
            TypeBuilder myTypeBuilder = myModBuilder.DefineType(classType.FullName,  
                                                            TypeAttributes.Public);  
  
            //把lcpi中定义的属性加入到TypeBuilder。将清空其它的成员。其功能有待扩展,使其不影响其它成员。  
            AddPropertyToTypeBuilder(myTypeBuilder, lcpi);  
  
            //创建类型。  
            Type retval = myTypeBuilder.CreateType();  
  
            //保存程序集,以便可以被Ildasm.exe解析,或被测试程序引用。  
            //myAsmBuilder.Save(myAsmName.Name + ".dll");  
            return retval;  
        }  
        #endregion  
 
        #region 辅助类  
        /** <summary>  
        /// 自定义的属性信息类型。  
        /// </summary>  
        public class CustPropertyInfo  
        {  
            private string propertyName;  
            private string type;  
  
            /** <summary>  
            /// 空构造。  
            /// </summary>  
            public CustPropertyInfo() { }  
  
            /** <summary>  
            /// 根据属性类型名称,属性名称构造实例。  
            /// </summary>  
            /// <param name="type">属性类型名称。</param>  
            /// <param name="propertyName">属性名称。</param>  
            public CustPropertyInfo(string type, string propertyName)  
            {  
                this.type = type;  
                this.propertyName = propertyName;  
            }  
  
            /** <summary>  
            /// 获取或设置属性类型名称。  
            /// </summary>  
            public string Type  
            {  
                get { return type; }  
                set { type = value; }  
            }  
  
            /** <summary>  
            /// 获取或设置属性名称。  
            /// </summary>  
            public string PropertyName  
            {  
                get { return propertyName; }  
                set { propertyName = value; }  
            }  
  
            /** <summary>  
            /// 获取属性字段名称。  
            /// </summary>  
            public string FieldName  
            {  
                get   
                {  
                    if (propertyName.Length < 1)  
                        return "";  
                    return propertyName.Substring(0, 1).ToLower() + propertyName.Substring(1);   
                }  
            }  
  
            /** <summary>  
            /// 获取属性在IL中的Set方法名。  
            /// </summary>  
            public string SetPropertyMethodName  
            {  
                get { return "set_" + PropertyName; }  
            }  
  
            /** <summary>  
            ///  获取属性在IL中的Get方法名。  
            /// </summary>  
            public string GetPropertyMethodName  
            {  
                get { return "get_" + PropertyName; }  
            }  
        }  
        #endregion  
    }  
}