动态类型对象

 public class RONT_EXAMINE_VIEW_MODEL : DynamicObject
    {
        //保存对象动态定义的属性值
        private Dictionary<string, object> _values;
        public RONT_EXAMINE_VIEW_MODEL()
        {
            _values = new Dictionary<string, object>();
        }
        public Dictionary<string, object> Values
        {
            get
            {
                return _values;
            }
        }
        /// <summary>
        /// 获取属性值
        /// </summary>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        public object GetPropertyValue(string propertyName)
        {
            if (_values.ContainsKey(propertyName) == true)
            {
                return _values[propertyName];
            }
            return null;
        }
        /// <summary>
        /// 设置属性值
        /// </summary>
        /// <param name="propertyName"></param>
        /// <param name="value"></param>
        public void SetPropertyValue(string propertyName, object value)
        {
            if (_values.ContainsKey(propertyName) == true)
            {
                _values[propertyName] = value;
            }
            else
            {
                _values.Add(propertyName, value);
            }
        }
        /// <summary>
        /// 实现动态对象属性成员访问的方法,得到返回指定属性的值
        /// </summary>
        /// <param name="binder"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = GetPropertyValue(binder.Name);
            return result == null ? false : true;
        }
        /// <summary>
        /// 实现动态对象属性值设置的方法。
        /// </summary>
        /// <param name="binder"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            SetPropertyValue(binder.Name, value);
            return true;
        }
        /// <summary>
        /// 动态对象动态方法调用时执行的实际代码
        /// </summary>
        /// <param name="binder"></param>
        /// <param name="args"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            var theDelegateObj = GetPropertyValue(binder.Name) as DelegateObjs;
            if (theDelegateObj == null || theDelegateObj.CallMethod == null)
            {
                result = null;
                return false;
            }
            result = theDelegateObj.CallMethod(this, args);
            return true;
        }
        public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
        {
            return base.TryInvoke(binder, args, out result);
        }

    }
    public delegate object MyDelegates(dynamic Sender, params object[] PMs);

    public class DelegateObjs
    {
        private MyDelegates _delegate;

        public MyDelegates CallMethod
        {
            get { return _delegate; }
        }
        private DelegateObjs(MyDelegates D)
        {
            _delegate = D;
        }
        /// <summary>
        /// 构造委托对象,让它看起来有点javascript定义的味道.
        /// </summary>
        /// <param name="D"></param>
        /// <returns></returns>
        public static DelegateObjs Function(MyDelegates D)
        {
            return new DelegateObjs(D);
        }
    }

  

 dynamic view = new RONT_EXAMINE_VIEW_MODEL();

                            view.AC_VALUE = item.AC_VALUE;
                            view.CHECK_TOOL = item.CHECK_TOOL;
                            view.CHECK_TYPE = item.CHECK_TYPE;
                            view.DUTY_DEPARTMENT = item.DUTY_DEPARTMENT;
                            view.FAIL_DESC = item.FAIL_DESC;
                            view.FEATURES = item.FEATURES;
                            view.FEATURES_LEVEL = item.FEATURES_LEVEL;
                            view.FIX_NUM = item.FIX_NUM;
                            view.ID = item.ID;
                            view.INSPECTION_LEVEL = item.INSPECTION_LEVEL;
                            view.INSPECTION_RESULT = item.INSPECTION_RESULT;
                            view.IS_INSPECTOR = item.IS_INSPECTOR;
                            view.ISQUAL = item.ISQUAL;
                            view.ITEM_NAME = item.ITEM_NAME;
                            view.ITEM_TYPE = item.ITEM_TYPE;
                            view.OFFSET_VALUE_LOW = item.OFFSET_VALUE_LOW;
                            view.OFFSET_VALUE_UP = item.OFFSET_VALUE_UP;
                            view.RE_VALUE = item.RE_VALUE;
                            view.REFERENCE_VALUE = item.REFERENCE_VALUE;
                            view.ROW_INDEX = item.ROW_INDEX;
                            view.SAMPLE_INSPECTION_ID = item.SAMPLE_INSPECTION_ID;
                            view.SEQ = item.SEQ;
                            view.STANDARD_VALUE = item.STANDARD_VALUE;
                            view.STATE = item.STATE;
                            view.STATUS = item.STATUS;
                            view.TECH_REQUIREMENT = item.TECH_REQUIREMENT;
                            view.UNIT = item.UNIT;
                            view.RowOrder = item.ROW_INDEX;
                            foreach (var extend in extendColumns.FindAll(e => e.DETAIL_ID == item.ID))
                            {
                                view.SetPropertyValue(extend.COLUMN_NAME.Trim(), extend.COLUMN_VALUE);
                            }
                            retObjs.Add(view);

  

时间: 2024-08-29 13:44:33

动态类型对象的相关文章

Object-C中动态类型对象相关操作汇总

Object-C(以后简称OC)中有id类型,相对于明确定义类型的静态类型,称为动态类型. 使用动态类型,配合多态(不同类型拥有同名方法),动态绑定(运行时决定实际调用的方法)可以将很多判断延迟到运行时决定,比如运行时才决定对象是某个类型,决定调用哪个类型的方法等.这样提高了灵活性,但是同样带来了风险,所以和支持动态类型的其他面向对象的语言一样,需要提供机制来做运行时判断,这样可以一定程度规避运行时错误. 看到一个动态类型的实例对象,我们都会习惯提出的问题: 1. 这个对象是属于某个类么?或者这

【.NET深呼吸】动态类型(扩充篇)

前面两文中,老周已向大家介绍了关于动态类型对象的两种级别的使用方案,本篇呢,老周再讲一个自定义动态类型的例子. 前面给大家演示的例子中,动态类型中包装的是字典类型来存储数据的,这一次咱们换一种风味,老吃酸的不好,这回就吃点辣的吧,火锅就不吃了,据说火锅的汤底里面有罂粟果的皮,吸食微型鸦片不好. 本例在自定义的动态类型中包装一个XML文档,就用XML来存数据吧. 还是老方法,从DynamicObject类派生出来. 这里我主要实现以下几个功能: 1.可以设置属性,这个是肯定要的,不然怎么赋值数据呢

Json.net实现方便的Json转C#(dynamic动态类型)对象

以前需要将一段json字符串转换为C#对象时,一般都是定义一个与之对应的实体类来接收.这样做有一个很大的缺点,就是当字符串特别长,属性特别多,又有嵌套时,手敲这个实体类就非常痛苦. 比如之前做的一个接收百度七天天气预报的API,层层嵌套,很痛苦. C# 4.0 之后有了动态类型dynamic.用这个东西配合Json.net可以实现不用定义实体类的json转dynamic类型对象. 以下示例需要先引用Newtonsoft.Json.dll public class Person { public

C++ 对象的静态类型与动态类型

在C++当中:因为出现了继承: 继承导致对象的指针和引用具有两种不同的类型: 静态类型 和 动态类型 . 静态类型 :指针或者是引用声明时的类型. 动态类型 :由他实际指向的类型确定. class Base { } class Derived:public Base { } Base* base //base的静态类型是 Base* = new Derived;//base的动态类型是 Derived* Derived* derived //derived的静态类型是 Derived* = ne

python笔记2 python对象的动态类型

Python中的一切都是对象,并且这些对象都是Python的组成部分,即是内置对象,和python一同产生. 从更正式的角度来讲,在P ython中,数据以对象的形式出现一一无论是Py t hon提供的内置对象,还是使用Python或是像C扩展库这 样的扩展语言工具创建的对象.尽管在以后才能确定这一概念,但对象无非是内存中的一部分,包含数值和相关操作的集合. 内置对象 对象类型 例子常量/创建 数字 1234, 3.1415, 3+4j, Decimal. Fraction 字符串 'spam'

Python的动态类型

动态类型:                                                      在python中,类型是在运行过程中自动决定的,而不是通过代码声明的. 变量:                                                                                     变量是一个系统表的元素,拥有指向对象的连接的空间 python中,类型的概念是存在于对象中的,而不是变量中,变量是通用的. 变量的使用

OC多态,动态类型绑定

// //  main.m //  OC7类 // //  Created by Zoujie on 15/8/23. //  Copyright (c) 2015年 Zoujie. All rights reserved. // #import <Foundation/Foundation.h> #import "Fraction.h"//导入头文件 #import "Complex.h" #define Choose  0 int main(int 

python学习笔记17(动态类型)

动态类型 在我们接触的对象中,有一类特殊的对象,是用于存储数据的,常见的该类对象包括各种数字,字符串,表,词典.在C语言中,我们称这样一些数据结构为变量,而在Python中,这些是对象. 对象是储存在内存中的实体.但我们并不能直接接触到该对象.我们在程序中写的对象名,只是指向这一对象的引用(reference). 引用和对象分离,是动态类型的核心.引用可以随时指向一个新的对象: a = 3 a = 'python' 第一个语句中,3是储存在内存中的一个整数对象,通过赋值,引用a指向对象3. 第二

【java】java反射机制,动态获取对象的属性和对应的参数值,并属性按照字典序排序,Field.setAccessible()方法的说明【可用于微信支付 签名生成】

方法1:通过get()方法获取属性值 package com.sxd.test.controller; public class FirstCa{ private Integer num; private String name; private Boolean flag; public Integer getNum() { return num; } public void setNum(Integer num) { this.num = num; } public String getNam