精华内容
下载资源
问答
  • IDL数组动态扩展方法
    千次阅读
    2018-05-23 16:54:12

    IDL作为一种完全面向矩阵的动态语言,数组是其最基本的结构,在IDL中可直接对数组进行扩展,这在C#和Java这类编译型语言中,是无法做到的。在C#和Java中实现动态数据结构,往往需要用到List,Array,Vector等动态数组封装类,通过这些类中的Add和Delete等方法来对元素进行操作。在IDL中,对数据的动态操作非常方便,数组大小和结构可根据运行候程序的需要自动变化。在数组元素无法确定时,常采用数组合并的方式来动态的扩充数组,同时保持数组原有元素的不变性。数组合并的运算符为“[ ]”,关于“[ ]”操作符,IDL帮助中描述如下:

    [ ]:Array concatenation
    The expression [A,B] is an array formed by concatenating A and B, which can be scalars or arrays, along the first dimension.

    To concatenate second and third levels, nest the brackets; [[1,2],[3,4]] is a 2-element by 2-element array with the first row containing 1 and 2 and the second row containing 3 and 4. Operands must have compatible dimensions; all dimensions must be equal except the dimension that is to be concatenated, e.g., [2,INTARR(2,2)] are incompatible.
    Eg:
    Define C as three-point vector:
    C = [0, 1, 3]
    Add 5 to the end of C:
    PRINT, [C, 5]
    IDL Prints: 0 1 3 5
    Insert -1 at the beginning of C:
    PRINT, [-1, C]
    IDL Prints: -1 0 1 3
    Plot ARR2 appended to ARR1.
    PLOT, [ARR1, ARR2]
    Define a 3x3 matrix.
    KER = [[1,2,1], [2,4,2], $ [1,2,1]]
    Note - Array concatenation is a relatively inefficient operation, and should only be performed once for a given set of data if possible.

    一维数组合并

    a = [1,2,3]
    b = [4,5,6]
    c=[a,b]
    print,c
    1 2 3 4 5 6

    行数相同的二维数组合并

    行数相同,直接用[]。相当于matlab中的[a,b]
    IDL> a=indgen(2,5)
    IDL> print,a
    0 1
    2 3
    4 5
    6 7
    8 9

    IDL> b=indgen(4,5)
    IDL> print,b
    0 1 2 3
    4 5 6 7
    8 9 10 11
    12 13 14 15
    16 17 18 19
    IDL> ;行数相同,直接用[].相当于matlab中的[a,b]
    IDL> c=[a,b]
    IDL> help,c
    C INT = Array[6, 5]
    IDL> print,c
    0 1 0 1 2 3
    2 3 4 5 6 7
    4 5 8 9 10 11
    6 7 12 13 14 15
    8 9 16 17 18 19

    列数相同的二维数组合并

    用[[],[]]。相当于matlab中的[a;b]
    IDL> d=indgen(2,3)
    IDL> print,d
    0 1
    2 3
    4 5
    IDL> ;列数相同,需用[[],[]]
    IDL> e=[[a],[d]]
    IDL> help,e
    E INT = Array[2, 8]
    IDL> print,e
    0 1
    2 3
    4 5
    6 7
    8 9
    0 1
    2 3
    4 5

    更多相关内容
  • C#扩展方法 扩展方法使你能够向现有类型“添加”方法,而无需创建新的派生类型、重新编译或以其他方式修改原始类型。 扩展方法是一种特殊的静态方法,但可以像扩展类型上的实例方法一样进行调用。 以上是...

    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
    展开全文
  • Java 类动态添加属性字段

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

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

    因为列是动态的, 首先想到的就是后天拼接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;
        }

     

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

    展开全文
  • C#类动态添加属性

    万次阅读 2015-09-16 14:59:45
    动态类实现 using System; using System.Collections.Generic; using System.Reflection.Emit; using System.Reflection; using System.Threading; namespace CopyMapFile { /**//// /// 类帮助器,可以...

    动态类实现

    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  
        }  
    }  
    


    展开全文
  • python 类扩展

    千次阅读 2018-05-18 09:22:58
    原文链接:https://blog.csdn.net/kikaylee/article/details/53190769Python作为动态语言,灵活性之一就是支持动态扩展,可以动态对象或者实例添加属性或者方法。这一特性给Python语言带来了很大的灵活...
  • iOS App添加扩展App Extension

    千次阅读 2019-05-13 10:24:24
    demo地址,里面额外添加了一个分享的扩展 :https://github.com/guochaoshun/iosAppExtension Today extensions (今日扩展): ... Today extension就是我们上面所说的通知中心扩展,因为这个扩展会显示...
  • 使用cglib动态创建添加方法

    千次阅读 2014-04-28 14:52:42
    是一个强大的,高性能,高质量的Code生成类库,它可以运行期扩展Java与实现Java接口。许多开源项目都用到了它,如Hibernate,Spring之用它来实现动态代理。 简单样例—动态生成bean 样例说明:建立一个...
  • Java增强一个的几种方法

    千次阅读 2017-06-10 13:37:52
    今天有人问我怎么增强一个的功能。博客刚好没东西,今天就讲讲增强。 增强的手段有三种类型: 1、继承或者实现接口:特点是被增强对象不... 继承:AA继承a对象的类型:A,然后重写fun1()方法,其中重写的fun
  • 一般来说,如果要编写模块化的软件,就要对对动态链接库(DLL)有一定的了解,本人这段时间修改以前的软件时,决定把重复用的和对话框做到DLL,下面就从一个简单的例子讲起,如何实现MFC扩展DLL导出和对话框...
  • 大型项目,企业级开发多人同时维护同一个,此时程序员A因为某项需求只想给当前currentClass添加一个方法newMethod,那该怎么办呢? 最简单粗暴的方式是把newMethod添加到currentClass,然后直接实现该...
  • 实际开发当中,当JavaScript内置的那些类所提供的动态方法动态属性不满足我们实际开发时,我们就可以通过"prototype"属性给自定义类添加方法和属性或者扩展原有的类方法和属性。 一、扩展JavaScript内置...
  • iOS类别扩展无法识别添加方法

    千次阅读 2015-06-15 23:23:02
    ios开发创建了类别扩展的文件,但总是识别扩展的原文件方法,在动态调用扩展方法时出现unrecognized selector sent to instance错误,看到国外网站的一个解决办法: Objective-C does not define linker ...
  • 不重启JVM动态添加日志(阿里Arthas)

    千次阅读 多人点赞 2021-01-28 00:26:29
    如果生产环境临时出现故障,但是现运行代码未打印定位问题所需要的日志,我们通常的做法是添加日志->重新发布->重现故障。但是这样麻烦不说,最重要的是...所以我们希望找到一个不重启应用,能够动态增加日志的方法
  • 动态图形模板是一种可 After Effects 或 Premiere Pro 创建的文件类型,您可以将计算机动态图形模板安装到 Premiere Pro 。安装动态图形模板时,将其复制到 Premiere Pro 的本地模板文件夹,即可任何 ...
  • groovy运行期间动态添加属性和方法

    千次阅读 2012-04-28 17:56:49
    我们都知道,Groovy语言,我们可以使用MOP特性运行期内动态添加属性或方法?/span>   这种添加包括两个层面的添加: 第一:是给一个类添加属性或方法。也就是说,如果我们运行期内给一个类添加了...
  • 今天我们主要解决一下使用xxl-job的一个痛点,就是动态创建任务。使用过xxl-job的朋友们都知道,xxl-job给我们提供一个管理后台,我们可以管理后台上,配置执行器,配置任务,管理任务。如下图。 这种
  • 数据库字段动态扩展设计

    万次阅读 多人点赞 2016-11-18 02:16:33
    最近讨论数据库有关产品方案的项目自动扩展问题,即每个方案都有多个项目,而每个方案的项目或多或少,也有不一样的,方案以后也坑能随之增加新的项目。因此需要数据库设计一套可扩展的方案。
  • 一.BeanDefinitionRegistryPostProcessor扩展点 1. 重写 postProcessBeanDefinitionRegistry BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor 需要重写 postProcessBeanDefinitionRegistry ...
  • python中为和实例动态增加方法

    万次阅读 2013-05-09 01:11:21
    类动态增加方法一:直接赋值 >>> Foo.func < unbound method Foo.func> >>>  >>> foo.func(4) <__main__.Foo object at 0x3f79db0> 4 >>> foo.func < bound method ...
  • Android 引导页动态添加圆点指示器

    万次阅读 2017-04-23 18:01:52
    昨晚实在是太无奈了,被兄弟拿枪顶着写了个引导页指示器的动态添加功能。描述的不详细,来张图片: 其实 实现原理很简单,一般都app的初次启动时出现,一个左右滑动的viewpager,页面底部再搭配一个标识位置...
  • 没有系统是交付后一成不变的,因为随着企业业务的发展及初始业务涉及的不完善都会随着时间一点点爆露出来,所以需要灵活的对系统进行扩展,并且不影响已有程序,所以插件是一个很好的解决办法,它既可以动态添加也...
  • 方法一: /// /// 实体属性处理 /// public class PropertyHandle { #region 反射控制只读、可见属性 //SetPropertyVisibility(obj, "名称 ", true); //obj指的就是你的SelectObject, “名称”是你
  • C#.NET中动态添加与删除控件

    千次阅读 2016-06-14 22:13:37
    C#.NET中动态添加与删除控件       数组为共享公用功能的一组控件一起工作提供了便捷的途径。例如,一组控件可能用于显示相关的数据,或者被点击时提供相关的行为。C#本身并不支持控件数组的建立,但是你...
  • 我现在用的 sping boot + ssm框架,现在遇到一个问题是,我的数据库表字段是动态的。随时新增、删除字段。我的实体现在不能同步,有没有什么技术让实体也同步更新?没有的话有什么方法处理?不然每次我都要从...
  • c#接口实现动态调用实现

    千次阅读 2016-03-29 20:04:57
    一个接口有多个实现,但是要程 序外(比如说配置文件或者数据库表里)定义到底应该掉用哪一个实现,这样 可以极大的提高程序的扩展性,调试也方便维护,多人同时使用一个程序时也可 以根据不同的需要写自己的...
  • 这就需要Product里定义一个Map属性来存放这些扩展属性,以便动态扩展。mybatis的xml可这么写: b.查询。 我这里的查询只是把数据友好的显示一个表格,表格需要表头与内容。因为这里涉及到一个动态...
  • 需求缘起 ... 通过扩展SpEL表达式主要配置具体的和实现的方法,如下示例 .access("@authService.canAccess(request,authentication)"); 其中authService是一个,canAccess是其中的方法: ...
  • C# 动态添加与删除控件

    千次阅读 2016-12-08 11:07:50
    C#.NET中动态添加与删除控件       数组为共享公用功能的一组控件一起工作提供了便捷的途径。例如,一组控件可能用于显示相关的数据,或者被点击时提供相关的行为。C#本身并不支持控件数组的建立,但是你...
  • Kotlin扩展

    千次阅读 2020-05-31 22:04:41
    //要扩展哪个类中方法,被扩展的类名就是哪个 fun 被扩展的类名.扩展函数名(..参数..){ 函数体 } 例如: Array中扩展一个元素交换的方法 fun Array<Int>.swap(pos1: Int, pos2: Int) { //this表示当前...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 313,240
精华内容 125,296
关键字:

在动态类中添加扩展方法