Mercurial > pub > bltoolkit

comparison Source/Reflection/TypeAccessor.cs @ 0:f990fcb411a9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Копия текущей версии из github
author cin
date Thu, 27 Mar 2014 21:46:09 +0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f990fcb411a9
1 using System;
2 using System.Collections;
3 using System.Collections.Generic;
4 using System.ComponentModel;
5 using System.Data;
6 using System.Data.SqlTypes;
7 using System.Diagnostics;
8 using System.Diagnostics.CodeAnalysis;
9 using System.IO;
10 using System.Reflection;
11
12 using BLToolkit.Common;
13 #if !SILVERLIGHT && !DATA
14 using BLToolkit.ComponentModel;
15 using BLToolkit.EditableObjects;
16 #endif
17 using BLToolkit.Mapping;
18 using BLToolkit.TypeBuilder;
19 using BLToolkit.TypeBuilder.Builders;
20
21 using JNotNull = JetBrains.Annotations.NotNullAttribute;
22
23 namespace BLToolkit.Reflection
24 {
25 public delegate object NullValueProvider(Type type);
26 public delegate bool IsNullHandler (object obj);
27
28 [DebuggerDisplay("Type = {Type}, OriginalType = {OriginalType}")]
29 public abstract class TypeAccessor : ICollection<MemberAccessor>
30 #if !SILVERLIGHT && !DATA
31 , ITypeDescriptionProvider
32 #endif
33 {
34 #region Protected Emit Helpers
35
36 protected MemberInfo GetMember(int memberType, string memberName)
37 {
38 const BindingFlags allInstaceMembers =
39 BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
40 MemberInfo mi;
41
42 switch (memberType)
43 {
44 case 1: mi = Type.GetField (memberName, allInstaceMembers); break;
45 case 2:
46 mi =
47 Type. GetProperty(memberName, allInstaceMembers) ??
48 OriginalType.GetProperty(memberName, allInstaceMembers);
49 break;
50 default:
51 throw new InvalidOperationException();
52 }
53
54 return mi;
55 }
56
57 protected void AddMember(MemberAccessor member)
58 {
59 if (member == null) throw new ArgumentNullException("member");
60
61 _members.Add(member);
62 _memberNames.Add(member.MemberInfo.Name, member);
63 }
64
65 #endregion
66
67 #region CreateInstance
68
69 [DebuggerStepThrough]
70 public virtual object CreateInstance()
71 {
72 throw new TypeBuilderException(string.Format(
73 "The '{0}' type must have public default or init constructor.",
74 OriginalType.Name));
75 }
76
77 [DebuggerStepThrough]
78 public virtual object CreateInstance(InitContext context)
79 {
80 return CreateInstance();
81 }
82
83 [DebuggerStepThrough]
84 public object CreateInstanceEx()
85 {
86 return _objectFactory != null?
87 _objectFactory.CreateInstance(this, null): CreateInstance((InitContext)null);
88 }
89
90 [DebuggerStepThrough]
91 public object CreateInstanceEx(InitContext context)
92 {
93 return _objectFactory != null? _objectFactory.CreateInstance(this, context): CreateInstance(context);
94 }
95
96 #endregion
97
98 #region ObjectFactory
99
100 private IObjectFactory _objectFactory;
101 public IObjectFactory ObjectFactory
102 {
103 get { return _objectFactory; }
104 set { _objectFactory = value; }
105 }
106
107 #endregion
108
109 #region Copy & AreEqual
110
111 internal static object CopyInternal(object source, object dest, TypeAccessor ta)
112 {
113 #if !SILVERLIGHT && !DATA
114 var isDirty = false;
115 var sourceEditable = source as IMemberwiseEditable;
116 var destEditable = dest as IMemberwiseEditable;
117
118 if (sourceEditable != null && destEditable != null)
119 {
120 foreach (MemberAccessor ma in ta)
121 {
122 ma.CloneValue(source, dest);
123 if (sourceEditable.IsDirtyMember(null, ma.MemberInfo.Name, ref isDirty) && !isDirty)
124 destEditable.AcceptMemberChanges(null, ma.MemberInfo.Name);
125 }
126 }
127 else
128 #endif
129 {
130 foreach (MemberAccessor ma in ta)
131 ma.CloneValue(source, dest);
132 }
133
134 return dest;
135 }
136
137 public static object Copy(object source, object dest)
138 {
139 if (source == null) throw new ArgumentNullException("source");
140 if (dest == null) throw new ArgumentNullException("dest");
141
142 TypeAccessor ta;
143
144 var sType = source.GetType();
145 var dType = dest. GetType();
146
147 if (TypeHelper.IsSameOrParent(sType, dType)) ta = GetAccessor(sType);
148 else if (TypeHelper.IsSameOrParent(dType, sType)) ta = GetAccessor(dType);
149 else
150 throw new ArgumentException();
151
152 return CopyInternal(source, dest, ta);
153 }
154
155 public static object Copy(object source)
156 {
157 if (source == null) throw new ArgumentNullException("source");
158
159 var ta = GetAccessor(source.GetType());
160
161 return CopyInternal(source, ta.CreateInstanceEx(), ta);
162 }
163
164 public static bool AreEqual(object obj1, object obj2)
165 {
166 if (ReferenceEquals(obj1, obj2))
167 return true;
168
169 if (obj1 == null || obj2 == null)
170 return false;
171
172 TypeAccessor ta;
173
174 var sType = obj1.GetType();
175 var dType = obj2.GetType();
176
177 if (TypeHelper.IsSameOrParent(sType, dType)) ta = GetAccessor(sType);
178 else if (TypeHelper.IsSameOrParent(dType, sType)) ta = GetAccessor(dType);
179 else
180 return false;
181
182 foreach (MemberAccessor ma in ta)
183 if ((!Equals(ma.GetValue(obj1), ma.GetValue(obj2))))
184 return false;
185
186 return true;
187 }
188
189 public static int GetHashCode(object obj)
190 {
191 if (obj == null)
192 throw new ArgumentNullException("obj");
193
194 var hash = 0;
195 object value;
196
197 foreach (MemberAccessor ma in GetAccessor(obj.GetType()))
198 {
199 value = ma.GetValue(obj);
200 hash = ((hash << 5) + hash) ^ (value == null ? 0 : value.GetHashCode());
201 }
202
203 return hash;
204 }
205
206 #endregion
207
208 #region Abstract Members
209
210 public abstract Type Type { get; }
211 public abstract Type OriginalType { get; }
212
213 #endregion
214
215 #region Items
216
217 private readonly List<MemberAccessor> _members = new List<MemberAccessor>();
218 private readonly Dictionary<string,MemberAccessor> _memberNames = new Dictionary<string,MemberAccessor>();
219
220 public MemberAccessor this[string memberName]
221 {
222 get
223 {
224 MemberAccessor ma;
225 return _memberNames.TryGetValue(memberName, out ma) ? ma : null;
226 }
227 }
228
229 public MemberAccessor this[int index]
230 {
231 get { return _members[index]; }
232 }
233
234 public MemberAccessor this[NameOrIndexParameter nameOrIndex]
235 {
236 get
237 {
238 return nameOrIndex.ByName ? _memberNames[nameOrIndex.Name] : _members[nameOrIndex.Index];
239 }
240 }
241
242 #endregion
243
244 #region Static Members
245
246 [Obsolete("Use TypeFactory.LoadTypes instead")]
247 public static bool LoadTypes
248 {
249 get { return TypeFactory.LoadTypes; }
250 set { TypeFactory.LoadTypes = value; }
251 }
252
253 private static readonly Dictionary<Type,TypeAccessor> _accessors = new Dictionary<Type,TypeAccessor>(10);
254
255 public static TypeAccessor GetAccessor(Type originalType)
256 {
257 if (originalType == null) throw new ArgumentNullException("originalType");
258
259 lock (_accessors)
260 {
261 TypeAccessor accessor;
262
263 if (_accessors.TryGetValue(originalType, out accessor))
264 return accessor;
265
266 if (IsAssociatedType(originalType))
267 return _accessors[originalType];
268
269 var instanceType = (IsClassBulderNeeded(originalType) ? null : originalType) ?? TypeFactory.GetType(originalType);
270
271 var accessorType = TypeFactory.GetType(originalType, originalType, new TypeAccessorBuilder(instanceType, originalType));
272
273 accessor = (TypeAccessor)Activator.CreateInstance(accessorType);
274
275 _accessors.Add(originalType, accessor);
276
277 if (originalType != instanceType)
278 _accessors.Add(instanceType, accessor);
279
280 return accessor;
281 }
282 }
283
284 public static TypeAccessor GetAccessor([JNotNull] object obj)
285 {
286 if (obj == null) throw new ArgumentNullException("obj");
287 return GetAccessor(obj.GetType());
288 }
289
290 public static TypeAccessor GetAccessor<T>()
291 {
292 return TypeAccessor<T>.Instance;
293 }
294
295 private static bool IsClassBulderNeeded(Type type)
296 {
297 if (type.IsAbstract && !type.IsSealed)
298 {
299 if (!type.IsInterface)
300 {
301 if (TypeHelper.GetDefaultConstructor(type) != null)
302 return true;
303
304 if (TypeHelper.GetConstructor(type, typeof(InitContext)) != null)
305 return true;
306 }
307 else
308 {
309 var attrs = TypeHelper.GetAttributes(type, typeof(AutoImplementInterfaceAttribute));
310
311 if (attrs != null && attrs.Length > 0)
312 return true;
313 }
314 }
315
316 return false;
317 }
318
319 internal static bool IsInstanceBuildable(Type type)
320 {
321 if (!type.IsInterface)
322 return true;
323
324 lock (_accessors)
325 {
326 if (_accessors.ContainsKey(type))
327 return true;
328
329 if (IsAssociatedType(type))
330 return true;
331 }
332
333 var attrs = TypeHelper.GetAttributes(type, typeof(AutoImplementInterfaceAttribute));
334
335 return attrs != null && attrs.Length > 0;
336 }
337
338 private static bool IsAssociatedType(Type type)
339 {
340 if (AssociatedTypeHandler != null)
341 {
342 var child = AssociatedTypeHandler(type);
343
344 if (child != null)
345 {
346 AssociateType(type, child);
347 return true;
348 }
349 }
350
351 return false;
352 }
353
354 public static object CreateInstance(Type type)
355 {
356 return GetAccessor(type).CreateInstance();
357 }
358
359 public static object CreateInstance(Type type, InitContext context)
360 {
361 return GetAccessor(type).CreateInstance(context);
362 }
363
364 public static object CreateInstanceEx(Type type)
365 {
366 return GetAccessor(type).CreateInstanceEx();
367 }
368
369 public static object CreateInstanceEx(Type type, InitContext context)
370 {
371 return GetAccessor(type).CreateInstance(context);
372 }
373
374 public static T CreateInstance<T>()
375 {
376 return TypeAccessor<T>.CreateInstance();
377 }
378
379 public static T CreateInstance<T>(InitContext context)
380 {
381 return TypeAccessor<T>.CreateInstance(context);
382 }
383
384 public static T CreateInstanceEx<T>()
385 {
386 return TypeAccessor<T>.CreateInstanceEx();
387 }
388
389 public static T CreateInstanceEx<T>(InitContext context)
390 {
391 return TypeAccessor<T>.CreateInstance(context);
392 }
393
394 public static TypeAccessor AssociateType(Type parent, Type child)
395 {
396 if (!TypeHelper.IsSameOrParent(parent, child))
397 throw new ArgumentException(
398 string.Format("'{0}' must be a base type of '{1}'", parent, child),
399 "child");
400
401 var accessor = GetAccessor(child);
402
403 accessor = (TypeAccessor)Activator.CreateInstance(accessor.GetType());
404
405 lock (_accessors)
406 _accessors.Add(parent, accessor);
407
408 return accessor;
409 }
410
411 public delegate Type GetAssociatedType(Type parent);
412 public static event GetAssociatedType AssociatedTypeHandler;
413
414 #endregion
415
416 #region GetNullValue
417
418 private static NullValueProvider _getNullValue = GetNullInternal;
419 public static NullValueProvider GetNullValue
420 {
421 get { return _getNullValue ?? (_getNullValue = GetNullInternal);}
422 set { _getNullValue = value; }
423 }
424
425 private static object GetNullInternal(Type type)
426 {
427 if (type == null) throw new ArgumentNullException("type");
428
429 if (type.IsValueType)
430 {
431 if (type.IsEnum)
432 return GetEnumNullValue(type);
433
434 if (type.IsPrimitive)
435 {
436 if (type == typeof(Int32)) return Common.Configuration.NullableValues.Int32;
437 if (type == typeof(Double)) return Common.Configuration.NullableValues.Double;
438 if (type == typeof(Int16)) return Common.Configuration.NullableValues.Int16;
439 if (type == typeof(Boolean)) return Common.Configuration.NullableValues.Boolean;
440 if (type == typeof(SByte)) return Common.Configuration.NullableValues.SByte;
441 if (type == typeof(Int64)) return Common.Configuration.NullableValues.Int64;
442 if (type == typeof(Byte)) return Common.Configuration.NullableValues.Byte;
443 if (type == typeof(UInt16)) return Common.Configuration.NullableValues.UInt16;
444 if (type == typeof(UInt32)) return Common.Configuration.NullableValues.UInt32;
445 if (type == typeof(UInt64)) return Common.Configuration.NullableValues.UInt64;
446 if (type == typeof(Single)) return Common.Configuration.NullableValues.Single;
447 if (type == typeof(Char)) return Common.Configuration.NullableValues.Char;
448 }
449 else
450 {
451 if (type == typeof(DateTime)) return Common.Configuration.NullableValues.DateTime;
452 if (type == typeof(DateTimeOffset)) return Common.Configuration.NullableValues.DateTimeOffset;
453 if (type == typeof(Decimal)) return Common.Configuration.NullableValues.Decimal;
454 if (type == typeof(Guid)) return Common.Configuration.NullableValues.Guid;
455
456 #if !SILVERLIGHT
457
458 if (type == typeof(SqlInt32)) return SqlInt32. Null;
459 if (type == typeof(SqlString)) return SqlString. Null;
460 if (type == typeof(SqlBoolean)) return SqlBoolean. Null;
461 if (type == typeof(SqlByte)) return SqlByte. Null;
462 if (type == typeof(SqlDateTime)) return SqlDateTime.Null;
463 if (type == typeof(SqlDecimal)) return SqlDecimal. Null;
464 if (type == typeof(SqlDouble)) return SqlDouble. Null;
465 if (type == typeof(SqlGuid)) return SqlGuid. Null;
466 if (type == typeof(SqlInt16)) return SqlInt16. Null;
467 if (type == typeof(SqlInt64)) return SqlInt64. Null;
468 if (type == typeof(SqlMoney)) return SqlMoney. Null;
469 if (type == typeof(SqlSingle)) return SqlSingle. Null;
470 if (type == typeof(SqlBinary)) return SqlBinary. Null;
471
472 #endif
473 }
474 }
475 else
476 {
477 if (type == typeof(String)) return Common.Configuration.NullableValues.String;
478 if (type == typeof(DBNull)) return DBNull.Value;
479 if (type == typeof(Stream)) return Stream.Null;
480 #if !SILVERLIGHT
481 if (type == typeof(SqlXml)) return SqlXml.Null;
482 #endif
483 }
484
485 return null;
486 }
487
488 const FieldAttributes EnumField = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal;
489
490 static readonly Dictionary<Type,object> _nullValues = new Dictionary<Type,object>();
491
492 static object GetEnumNullValue(Type type)
493 {
494 object nullValue;
495
496 lock (_nullValues)
497 if (_nullValues.TryGetValue(type, out nullValue))
498 return nullValue;
499
500 var fields = type.GetFields();
501
502 foreach (var fi in fields)
503 {
504 if ((fi.Attributes & EnumField) == EnumField)
505 {
506 var attrs = Attribute.GetCustomAttributes(fi, typeof(NullValueAttribute));
507
508 if (attrs.Length > 0)
509 {
510 nullValue = Enum.Parse(type, fi.Name, false);
511 break;
512 }
513 }
514 }
515
516 lock (_nullValues)
517 if (!_nullValues.ContainsKey(type))
518 _nullValues.Add(type, nullValue);
519
520 return nullValue;
521 }
522
523 private static IsNullHandler _isNull = IsNullInternal;
524 public static IsNullHandler IsNull
525 {
526 get { return _isNull ?? (_isNull = IsNullInternal); }
527 set { _isNull = value; }
528 }
529
530 private static bool IsNullInternal(object value)
531 {
532 if (value == null)
533 return true;
534
535 var nullValue = GetNullValue(value.GetType());
536
537 return nullValue != null && value.Equals(nullValue);
538 }
539
540 #endregion
541
542 #region ICollection Members
543
544 void ICollection<MemberAccessor>.Add(MemberAccessor item)
545 {
546 _members.Add(item);
547 }
548
549 void ICollection<MemberAccessor>.Clear()
550 {
551 _members.Clear();
552 }
553
554 bool ICollection<MemberAccessor>.Contains(MemberAccessor item)
555 {
556 return _members.Contains(item);
557 }
558
559 void ICollection<MemberAccessor>.CopyTo(MemberAccessor[] array, int arrayIndex)
560 {
561 _members.CopyTo(array, arrayIndex);
562 }
563
564 bool ICollection<MemberAccessor>.Remove(MemberAccessor item)
565 {
566 return _members.Remove(item);
567 }
568
569 public int Count
570 {
571 get { return _members.Count; }
572 }
573
574 bool ICollection<MemberAccessor>.IsReadOnly
575 {
576 get { return ((ICollection<MemberAccessor>)_members).IsReadOnly; }
577 }
578
579 public int IndexOf(MemberAccessor ma)
580 {
581 return _members.IndexOf(ma);
582 }
583
584 #endregion
585
586 #region IEnumerable Members
587
588 public IEnumerator GetEnumerator()
589 {
590 return _members.GetEnumerator();
591 }
592
593 #endregion
594
595 #region IEnumerable<MemberAccessor> Members
596
597 IEnumerator<MemberAccessor> IEnumerable<MemberAccessor>.GetEnumerator()
598 {
599 foreach (MemberAccessor member in _members)
600 yield return member;
601 }
602
603 #endregion
604
605 #region Write Object Info
606
607 public static void WriteDebug(object o)
608 {
609 #if DEBUG
610 Write(o, DebugWriteLine);
611 #endif
612 }
613
614 private static void DebugWriteLine(string text)
615 {
616 Debug.WriteLine(text);
617 }
618
619 public static void WriteConsole(object o)
620 {
621 Write(o, Console.WriteLine);
622 }
623
624 [SuppressMessage("Microsoft.Performance", "CA1818:DoNotConcatenateStringsInsideLoops")]
625 private static string MapTypeName(Type type)
626 {
627 if (type.IsGenericType)
628 {
629 if (type.GetGenericTypeDefinition() == typeof(Nullable<>))
630 return string.Format("{0}?", MapTypeName(Nullable.GetUnderlyingType(type)));
631
632 var name = type.Name;
633 var idx = name.IndexOf('`');
634
635 if (idx >= 0)
636 name = name.Substring(0, idx);
637
638 name += "<";
639
640 foreach (var t in type.GetGenericArguments())
641 name += MapTypeName(t) + ',';
642
643 if (name[name.Length - 1] == ',')
644 name = name.Substring(0, name.Length - 1);
645
646 name += ">";
647
648 return name;
649 }
650
651 if (type.IsPrimitive ||
652 type == typeof(string) ||
653 type == typeof(object) ||
654 type == typeof(decimal))
655 {
656 if (type == typeof(int)) return "int";
657 if (type == typeof(bool)) return "bool";
658 if (type == typeof(short)) return "short";
659 if (type == typeof(long)) return "long";
660 if (type == typeof(ushort)) return "ushort";
661 if (type == typeof(uint)) return "uint";
662 if (type == typeof(ulong)) return "ulong";
663 if (type == typeof(float)) return "float";
664
665 return type.Name.ToLower();
666 }
667
668 return type.Name;
669 }
670
671 public delegate void WriteLine(string text);
672
673 [SuppressMessage("Microsoft.Usage", "CA2241:ProvideCorrectArgumentsToFormattingMethods")]
674 public static void Write(object o, WriteLine writeLine)
675 {
676 if (o == null)
677 {
678 writeLine("*** (null) ***");
679 return;
680 }
681
682 MemberAccessor ma;
683
684 var ta = GetAccessor(o.GetType());
685 var nameLen = 0;
686 var typeLen = 0;
687
688 foreach (var de in ta._memberNames)
689 {
690 if (nameLen < de.Key.Length)
691 nameLen = de.Key.Length;
692
693 ma = de.Value;
694
695 if (typeLen < MapTypeName(ma.Type).Length)
696 typeLen = MapTypeName(ma.Type).Length;
697 }
698
699 var text = "*** " + o.GetType().FullName + ": ***";
700
701 writeLine(text);
702
703 var format = string.Format("{{0,-{0}}} {{1,-{1}}} : {{2}}", typeLen, nameLen);
704
705 foreach (var de in ta._memberNames)
706 {
707 ma = de.Value;
708
709 var value = ma.GetValue(o);
710
711 if (value == null)
712 value = "(null)";
713 else if (value is ICollection)
714 value = string.Format("(Count = {0})", ((ICollection)value).Count);
715
716 text = string.Format(format, MapTypeName(ma.Type), de.Key, value);
717
718 writeLine(text);
719 }
720
721 writeLine("***");
722 }
723
724 #endregion
725
726 #region TypeDescriptor
727
728 #if !SILVERLIGHT && !DATA
729
730 #region CustomTypeDescriptor
731
732 private static readonly Hashtable _descriptors = new Hashtable();
733
734 public static ICustomTypeDescriptor GetCustomTypeDescriptor(Type type)
735 {
736 var descriptor = (ICustomTypeDescriptor)_descriptors[type];
737
738 if (descriptor == null)
739 {
740 lock (_descriptors.SyncRoot)
741 {
742 descriptor = (ICustomTypeDescriptor)_descriptors[type];
743
744 if (descriptor == null)
745 {
746 descriptor = new CustomTypeDescriptorImpl(type);
747
748 _descriptors.Add(type, descriptor);
749 }
750 }
751 }
752 return descriptor;
753 }
754
755 private ICustomTypeDescriptor _customTypeDescriptor;
756 public ICustomTypeDescriptor CustomTypeDescriptor
757 {
758 get { return _customTypeDescriptor ?? (_customTypeDescriptor = GetCustomTypeDescriptor(OriginalType)); }
759 }
760
761 #endregion
762
763 #region Property Descriptors
764
765 private PropertyDescriptorCollection _propertyDescriptors;
766 public PropertyDescriptorCollection PropertyDescriptors
767 {
768 get
769 {
770 if (_propertyDescriptors == null)
771 {
772 if (TypeHelper.IsSameOrParent(typeof(ICustomTypeDescriptor), OriginalType))
773 {
774 var descriptor = CreateInstance() as ICustomTypeDescriptor;
775
776 if (descriptor != null)
777 _propertyDescriptors = descriptor.GetProperties();
778 }
779
780 if (_propertyDescriptors == null)
781 _propertyDescriptors = CreatePropertyDescriptors();
782 }
783
784 return _propertyDescriptors;
785 }
786 }
787
788 public PropertyDescriptorCollection CreatePropertyDescriptors()
789 {
790 if (Data.DbManager.TraceSwitch.TraceInfo)
791 Data.DbManager.WriteTraceLine(OriginalType.FullName, "CreatePropertyDescriptors");
792
793 var pd = new PropertyDescriptor[Count];
794
795 var i = 0;
796 foreach (MemberAccessor ma in _members)
797 pd[i++] = ma.PropertyDescriptor;
798
799 return new PropertyDescriptorCollection(pd);
800 }
801
802 public PropertyDescriptorCollection CreateExtendedPropertyDescriptors(
803 Type objectViewType,
804 IsNullHandler isNull)
805 {
806 // This is definitely wrong.
807 //
808 //if (isNull == null)
809 // isNull = _isNull;
810
811 var pdc = CreatePropertyDescriptors();
812
813 if (objectViewType != null)
814 {
815 var viewAccessor = GetAccessor(objectViewType);
816 var objectView = (IObjectView)viewAccessor.CreateInstanceEx();
817 var list = new List<PropertyDescriptor>();
818
819 var viewpdc = viewAccessor.PropertyDescriptors;
820
821 foreach (PropertyDescriptor pd in viewpdc)
822 list.Add(new ObjectViewPropertyDescriptor(pd, objectView));
823
824 foreach (PropertyDescriptor pd in pdc)
825 if (viewpdc.Find(pd.Name, false) == null)
826 list.Add(pd);
827
828 pdc = new PropertyDescriptorCollection(list.ToArray());
829 }
830
831 pdc = pdc.Sort(new PropertyDescriptorComparer());
832
833 pdc = GetExtendedProperties(pdc, OriginalType, String.Empty, Type.EmptyTypes, new PropertyDescriptor[0], isNull);
834
835 return pdc;
836 }
837
838 private static PropertyDescriptorCollection GetExtendedProperties(
839 PropertyDescriptorCollection pdc,
840 Type itemType,
841 string propertyPrefix,
842 Type[] parentTypes,
843 PropertyDescriptor[] parentAccessors,
844 IsNullHandler isNull)
845 {
846 var list = new ArrayList(pdc.Count);
847 var objects = new ArrayList();
848 var isDataRow = itemType.IsSubclassOf(typeof(DataRow));
849
850 foreach (PropertyDescriptor p in pdc)
851 {
852 var propertyType = p.PropertyType;
853
854 if (p.Attributes.Matches(BindableAttribute.No) ||
855 //propertyType == typeof(Type) ||
856 isDataRow && p.Name == "ItemArray")
857 continue;
858
859 var isList = false;
860 var explicitlyBound = p.Attributes.Contains(BindableAttribute.Yes);
861 var pd = p;
862
863 if (propertyType.GetInterface("IList") != null)
864 {
865 //if (!explicitlyBound)
866 // continue;
867
868 isList = true;
869 pd = new ListPropertyDescriptor(pd);
870 }
871
872 if (!isList &&
873 !propertyType.IsValueType &&
874 !propertyType.IsArray &&
875 (!propertyType.FullName.StartsWith("System.") || explicitlyBound
876 || propertyType.IsGenericType) &&
877 propertyType != typeof(Type) &&
878 propertyType != typeof(string) &&
879 propertyType != typeof(object) &&
880 Array.IndexOf(parentTypes, propertyType) == -1)
881 {
882 var childParentTypes = new Type[parentTypes.Length + 1];
883
884 parentTypes.CopyTo(childParentTypes, 0);
885 childParentTypes[parentTypes.Length] = itemType;
886
887 var childParentAccessors = new PropertyDescriptor[parentAccessors.Length + 1];
888
889 parentAccessors.CopyTo(childParentAccessors, 0);
890 childParentAccessors[parentAccessors.Length] = pd;
891
892 var pdch = GetAccessor(propertyType).PropertyDescriptors;
893
894 pdch = pdch.Sort(new PropertyDescriptorComparer());
895 pdch = GetExtendedProperties(
896 pdch,
897 propertyType,
898 propertyPrefix + pd.Name + "+",
899 childParentTypes,
900 childParentAccessors,
901 isNull);
902
903 objects.AddRange(pdch);
904 }
905 else
906 {
907 if (propertyPrefix.Length != 0 || isNull != null)
908 pd = new StandardPropertyDescriptor(pd, propertyPrefix, parentAccessors, isNull);
909
910 list.Add(pd);
911 }
912 }
913
914 list.AddRange(objects);
915
916 return new PropertyDescriptorCollection(
917 (PropertyDescriptor[])list.ToArray(typeof(PropertyDescriptor)));
918 }
919
920 #region PropertyDescriptorComparer
921
922 class PropertyDescriptorComparer : IComparer
923 {
924 public int Compare(object x, object y)
925 {
926 return String.Compare(((PropertyDescriptor)x).Name, ((PropertyDescriptor)y).Name);
927 }
928 }
929
930 #endregion
931
932 #region ListPropertyDescriptor
933
934 class ListPropertyDescriptor : PropertyDescriptorWrapper
935 {
936 public ListPropertyDescriptor(PropertyDescriptor descriptor)
937 : base(descriptor)
938 {
939 }
940
941 public override object GetValue(object component)
942 {
943 var value = base.GetValue(component);
944
945 if (value == null)
946 return value;
947
948 if (value is IBindingList && value is ITypedList)
949 return value;
950
951 return EditableArrayList.Adapter((IList)value);
952 }
953 }
954
955 #endregion
956
957 #region StandardPropertyDescriptor
958
959 class StandardPropertyDescriptor : PropertyDescriptorWrapper
960 {
961 protected readonly PropertyDescriptor _descriptor;
962 protected readonly IsNullHandler _isNull;
963
964 protected readonly string _prefixedName;
965 protected readonly PropertyDescriptor[] _chainAccessors;
966
967 public StandardPropertyDescriptor(
968 PropertyDescriptor pd,
969 string namePrefix,
970 PropertyDescriptor[] chainAccessors,
971 IsNullHandler isNull)
972 : base(pd)
973 {
974 _descriptor = pd;
975 _isNull = isNull;
976 _prefixedName = namePrefix + pd.Name;
977 _chainAccessors = chainAccessors;
978 }
979
980 protected object GetNestedComponent(object component)
981 {
982 for (var i = 0;
983 i < _chainAccessors.Length && component != null && !(component is DBNull);
984 i++)
985 {
986 component = _chainAccessors[i].GetValue(component);
987 }
988
989 return component;
990 }
991
992 public override void SetValue(object component, object value)
993 {
994 component = GetNestedComponent(component);
995
996 if (component != null && !(component is DBNull))
997 _descriptor.SetValue(component, value);
998 }
999
1000 public override object GetValue(object component)
1001 {
1002 component = GetNestedComponent(component);
1003
1004 return CheckNull(
1005 component != null && !(component is DBNull)? _descriptor.GetValue(component): null);
1006 }
1007
1008 public override string Name
1009 {
1010 get { return _prefixedName; }
1011 }
1012
1013 protected object CheckNull(object value)
1014 {
1015 if (_isNull != null && _isNull(value))
1016 {
1017 switch (Common.Configuration.CheckNullReturnIfNull)
1018 {
1019 case Common.Configuration.NullEquivalent.DBNull:
1020 return DBNull.Value;
1021 case Common.Configuration.NullEquivalent.Null:
1022 return null;
1023 case Common.Configuration.NullEquivalent.Value:
1024 return value;
1025 }
1026
1027 return DBNull.Value;
1028 }
1029
1030 return value;
1031 }
1032 }
1033
1034 #endregion
1035
1036 #region objectViewPropertyDescriptor
1037
1038 class ObjectViewPropertyDescriptor : PropertyDescriptorWrapper
1039 {
1040 public ObjectViewPropertyDescriptor(PropertyDescriptor pd, IObjectView objectView)
1041 : base(pd)
1042 {
1043 _objectView = objectView;
1044 }
1045
1046 private readonly IObjectView _objectView;
1047
1048 public override object GetValue(object component)
1049 {
1050 _objectView.Object = component;
1051
1052 return base.GetValue(_objectView);
1053 }
1054
1055 public override void SetValue(object component, object value)
1056 {
1057 _objectView.Object = component;
1058
1059 base.SetValue(_objectView, value);
1060 }
1061 }
1062
1063 #endregion
1064
1065 #endregion
1066
1067 #region ITypeDescriptionProvider Members
1068
1069 string ITypeDescriptionProvider.ClassName
1070 {
1071 get { return OriginalType.Name; }
1072 }
1073
1074 string ITypeDescriptionProvider.ComponentName
1075 {
1076 get { return OriginalType.Name; }
1077 }
1078
1079 EventDescriptor ITypeDescriptionProvider.GetEvent(string name)
1080 {
1081 return new CustomEventDescriptor(OriginalType.GetEvent(name));
1082 }
1083
1084 PropertyDescriptor ITypeDescriptionProvider.GetProperty(string name)
1085 {
1086 var ma = this[name];
1087 return ma != null ? ma.PropertyDescriptor : null;
1088 }
1089
1090 AttributeCollection ITypeDescriptionProvider.GetAttributes()
1091 {
1092 var attributesAsObj = new TypeHelper(OriginalType).GetAttributes();
1093 var attributes = new Attribute[attributesAsObj.Length];
1094
1095 for (var i = 0; i < attributesAsObj.Length; i++)
1096 attributes[i] = attributesAsObj[i] as Attribute;
1097
1098 return new AttributeCollection(attributes);
1099 }
1100
1101 EventDescriptorCollection ITypeDescriptionProvider.GetEvents()
1102 {
1103 var ei = OriginalType.GetEvents();
1104 var ed = new EventDescriptor[ei.Length];
1105
1106 for (var i = 0; i < ei.Length; i++)
1107 ed[i] = new CustomEventDescriptor(ei[i]);
1108
1109 return new EventDescriptorCollection(ed);
1110 }
1111
1112 PropertyDescriptorCollection ITypeDescriptionProvider.GetProperties()
1113 {
1114 return CreatePropertyDescriptors();
1115 }
1116
1117 #region CustomEventDescriptor
1118
1119 class CustomEventDescriptor : EventDescriptor
1120 {
1121 public CustomEventDescriptor(EventInfo eventInfo)
1122 : base(eventInfo.Name, null)
1123 {
1124 _eventInfo = eventInfo;
1125 }
1126
1127 private readonly EventInfo _eventInfo;
1128
1129 public override void AddEventHandler(object component, Delegate value)
1130 {
1131 _eventInfo.AddEventHandler(component, value);
1132 }
1133
1134 public override void RemoveEventHandler(object component, Delegate value)
1135 {
1136 _eventInfo.RemoveEventHandler(component, value);
1137 }
1138
1139 public override Type ComponentType { get { return _eventInfo.DeclaringType; } }
1140 public override Type EventType { get { return _eventInfo.EventHandlerType; } }
1141 public override bool IsMulticast { get { return _eventInfo.IsMulticast; } }
1142 }
1143
1144 #endregion
1145
1146 #endregion
1147
1148 #endif
1149
1150 #endregion
1151 }
1152 }