对象属性赋值后续（集合对象的属性赋值）

（一）前言

继《对象属性之间的相互赋值 》后，关于集合对象属性的赋值，主要可以通过循环遍历集合中的对象来进行属性间的赋值。这些可以运用于不同对象之间、相关属性类似的情况。最常见的是web services与silverlight之间的对象赋值（对象之间的属性值只有一部分是需要的），这样可以减少silverlight对web services的依赖。

（二）具体实现

通过反射将源对象与目标对象之间的属性赋值。源对象的属性名、属性类型必须与目标对象的属性名、属性类型一致，并且源对象的属性必须是可读的，目标对象的属性是可写的（仅针对于需要赋值的属性来说）。具体的源代码如下：

 1     public class ObjectMapper  
 2     {
 3         private static readonly Dictionary<string, IList<PropertyMapper>> _mappers =
 4             new Dictionary<string, IList<PropertyMapper>>();
 5 
 6         public static IList<PropertyMapper> GetMapperProperties(
 7             Type sourceType, Type targetType)
 8         {
 9             var sourceProperties = sourceType.GetProperties();
10             var targetProperties = targetType.GetProperties();
11 
12             return (from s in sourceProperties
13                     from t in targetProperties
14                     where s.Name == t.Name && s.CanRead && t.CanWrite && s.PropertyType == t.PropertyType
15                     select new PropertyMapper
16                               {
17                                   SourceProperty = s,
18                                   TargetProperty = t
19                               }).ToList();
20         }
21 
22         public static void CopyProperties<T1, T2>(List<T1> sources, List<T2> targets) where T2:new()
23         {
24             if (sources == null || sources.Count == 0 || targets == null)
25             {
26                 return;
27             }
28 
29             T2 target;
30             foreach (T1 source in sources)
31             {
32                 target = new T2();
33                 CopyProperties(source, target);
34                 targets.Add(target);
35             }
36         }
37 
38         public static void CopyProperties(object source, object target)
39         {
40             if (source == null || target == null)
41             {
42                 return;
43             }
44             var sourceType = source.GetType();
45             var targetType = target.GetType();
46             string key = GetMapperKey(sourceType, targetType);
47             if (!_mappers.ContainsKey(key))
48             {
49                 MapperProperties(sourceType, targetType);
50             }
51 
52             var mapperProperties = _mappers[key];
53 
54             SetPropertityValue(source, target, mapperProperties);
55         }
56 
57         private static void SetPropertityValue(object source, 
58             object target, IList<PropertyMapper> mapperProperties)
59         {
60             for (int index = 0, count = mapperProperties.Count; index < count; index++)
61             {
62                 var property = mapperProperties[index];
63                 var sourceValue = property.SourceProperty.GetValue(source, null);
64                 property.TargetProperty.SetValue(target, sourceValue, null);
65             }
66         }
67 
68         protected static string GetMapperKey(Type sourceType, Type targetType)
69         {
70             return string.Format("{0}_{1}", sourceType.FullName,
71                 targetType.FullName);
72         }
73 
74         public static void MapperProperties(Type source, Type target)
75         {
76             if (source == null || target == null)
77             {
78                 return;
79             }
80 
81             string key = GetMapperKey(source, target);
82             if (_mappers.ContainsKey(key))
83             {
84                 return;
85             }
86 
87             var properties = GetMapperProperties(source, target);
88             _mappers.Add(key, properties);
89         }
90     }

有效的方法主要为如下2个:

(1)第22-36行CopyProperties<T1, T2>(List<T1> sources, List<T2> targets) where T2:new()

目标对象集合必须添加约束（where T2:new()）---必须有默认构造函数。从如下的代码可以看出 target = new T2()必须通过实例化，才能将其添加到目标集合中。

                T2 target;
30             foreach (T1 source in sources)
31             {
32                 target = new T2();
33                 CopyProperties(source, target);
34                 targets.Add(target);
35             }

（2）CopyProperties(object source, object target)
这个方法才是最关键的，因为集合对象之间的赋值主要是通过循环该方法来赋值的。

 

（三）单元测试

对象集合对象之间的赋值，相关的单元测试代码如下（仅考虑了简单的对象），通过下面的测试，可以检测到集合对象属性赋值赋值后，值是相同的：

 1         [TestMethod()]
 2         public void CopyPropertiesTest1()
 3         {
 4             List<Jasen.Core.Info> sources = new List<Core.Info>();
 5             for (int index = 0; index < 10; index++)
 6             {
 7                 sources.Add(new Jasen.Core.Info()
 8                 {
 9                     Name = "jasen",
10                     CreateTime = "2011-5-13".AsDateTime(),
11                     Exist = true,
12                     ConflictOption = ConflictOption.OverwriteChanges,
13                     Index = index
14                 });
15             }
16             List<Info> targets = new List<Info>();    
17             ObjectMapper.CopyProperties(sources, targets);
18             for (int index = 0, count = sources.Count; index < count; index++)
19             {
20                 Assert.AreEqual(sources[index].ConflictOption, targets[index].ConflictOption);
21                 Assert.AreEqual(sources[index].CreateTime, targets[index].CreateTime);
22                 Assert.AreEqual(sources[index].Exist, targets[index].Exist);
23                 Assert.AreEqual(sources[index].Name, targets[index].Name);
24                 //Assert.AreEqual(sources[index].Index, targets[index].Index);
25             }
26         }

（四）总结

以上的代码仅仅针对于简单的属性之间的赋值，对于对象包含IList集合属性的赋值，可以将该IList再进行一次赋值即可。上文中采用字典来使性能提高，当第一次赋值的时候保存需要赋值的相关联的属性对集合。第二次的时候就直接通过键值获取该属性对，不需要再次查找相关的属性对集合。

 

源代码下载：Jasen.CopyObjectToObjectSample.rar