2

schangxiang@126.com

2024-06-20 46ef7eea68d020215c9a60ddb8fd6a1ad51afc17

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
 
namespace iWare.Wms.Core
{
    public class EntityPropHelper
    {
        /// <summary>
        /// 反射实现两个类的对象之间相同属性的值的复制
        /// 适用于初始化新实体
        /// </summary>
        /// <typeparam name="D">返回的实体</typeparam>
        /// <typeparam name="S">数据源实体</typeparam>
        /// <param name="s">数据源实体</param>
        /// <returns>返回的新实体</returns>
        public static D Mapper<D, S>(S s)
        {
            D d = Activator.CreateInstance<D>(); //构造新实例
            try
            {
                var Types = s.GetType();//获得类型  
                var Typed = typeof(D);
                foreach (PropertyInfo sp in Types.GetProperties())//获得类型的属性字段  
                {
                    foreach (PropertyInfo dp in Typed.GetProperties())
                    {
                        if (dp.Name == sp.Name && dp.PropertyType == sp.PropertyType && dp.Name != "Error" && dp.Name != "Item")//判断属性名是否相同  
                        {
                            dp.SetValue(d, sp.GetValue(s, null), null);//获得s对象属性的值复制给d对象的属性  
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return d;
        }
 
    }
    /// <summary>
    /// 用于属性属性赋值操作的帮助类
    /// </summary>
    /// <typeparam name="T">原对象类</typeparam>
    /// <typeparam name="S">目标对象类</typeparam>
    public class EntityPropHelper<T,S> where T:class where S:class
    {
        /// <summary>
        /// 将t中的各个对于的属性值赋值到s中相应的属性
        /// </summary>
        /// <param name="t">原对象</param>
        /// <param name="s">目标对象</param>
        /// <param name="columnMap">以T中的属性名为键，S中的属性名为值的字典  t赋值给S</param>
        public static void CopyProp(T t, S s, Dictionary<string,string> columnMap) 
        {
            Type typeT = typeof(T);
            Type typeS = typeof(S);
                       
            var sProps = typeS.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
            var sPropDic = new Dictionary<string, PropertyInfo>();
 
            var keys = columnMap.Keys;
            var values = columnMap.Values;
 
            //遍历S的所有属性,将符合修改的存入字典中 
            sProps.ForEach(p => { if (values.Contains(p.Name)) { sPropDic.Add(p.Name, p); } });
 
            var tProps = typeT.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
            var tPropDic = new Dictionary<string, PropertyInfo>();
 
            //遍历S的所有属性,将符合修改的存入字典中 
            tProps.ForEach(p => { if (keys.Contains(p.Name)) { tPropDic.Add(p.Name, p); } });
 
            foreach(var key in keys)
            {
                var propValue = tPropDic[key].GetValue(t, null);
                sPropDic[columnMap[key]].SetValue(s, propValue, null);
            }
 
        }
 
 
        /// <summary>
        /// 将s中的各个对于的属性值赋值到t中相应的属性
        /// </summary>
        /// <param name="t">目标对象</param>
        /// <param name="s">原对象</param>
        /// <param name="columnMap">以T中的属性名为键，S中的属性名为值的字典  </param>
        public static void CopyProp(S s,T t , Dictionary<string, string> columnMap)
        {
 
 
                Type typeT = typeof(T);
                Type typeS = typeof(S);
 
                var sProps = typeS.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
                var sPropDic = new Dictionary<string, PropertyInfo>();
 
                var keys = columnMap.Keys;
                var values = columnMap.Values;
 
                //遍历S的所有属性,将符合修改的存入字典中 
                sProps.ForEach(p => { if (values.Contains(p.Name)) { sPropDic.Add(p.Name, p); } });
 
                var tProps = typeT.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
                var tPropDic = new Dictionary<string, PropertyInfo>();
 
                //遍历S的所有属性,将符合修改的存入字典中 
                tProps.ForEach(p => { if (keys.Contains(p.Name)) { tPropDic.Add(p.Name, p); } });
 
                foreach (var key in keys)
                {
                    var propValue = sPropDic[columnMap[key]].GetValue(s, null);
 
                    tPropDic[key].SetValue(t, propValue, null);
                }
 
 
        }
 
        /// <summary>
        /// 将t中的各个对于的属性值赋值到s中相应的属性
        /// </summary>
        /// <param name="t">原对象</param>
        /// <param name="s">目标对象</param>
        /// <param name="columnMap">以T中的属性名为键，S中的属性名为值的字典</param>
        public static void CopyProp(T t, S s,List<string> propNames)
        {
            Type typeT = typeof(T);
            Type typeS = typeof(S);
 
            var sProps = typeS.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
            var sPropDic = new Dictionary<string, PropertyInfo>();
 
           
            //遍历S的所有属性,将符合修改的存入字典中 
            sProps.ForEach(p => { if (propNames.Contains(p.Name)) { sPropDic.Add(p.Name, p); } });
 
            var tProps = typeT.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
            var tPropDic = new Dictionary<string, PropertyInfo>();
 
            //遍历S的所有属性,将符合修改的存入字典中 
            tProps.ForEach(p => { if (propNames.Contains(p.Name)) { tPropDic.Add(p.Name, p); } });
 
            foreach (var propName in propNames)
            {
                var propValue = tPropDic[propName].GetValue(t, null);
                sPropDic[propName].SetValue(s, propValue, null);
            }
        }
    }
}