1 #pragma warning disable 1634, 1691
2 namespace System.Workflow.ComponentModel.Compiler
3 {
4     using System;
5     using System.Collections;
6     using System.Collections.Generic;
7     using System.ComponentModel;
8     using System.Globalization;
9     using System.Reflection;
10     using System.CodeDom;
11     using System.Text;
12 
13     internal sealed class RTTypeWrapper : Type, ICloneable
14     {
15         #region BoundedTypeArray Comparer
16 
17         private class TypeArrayComparer : IEqualityComparer
18         {
19             #region IEqualityComparer Members
20 
IEqualityComparer.Equals(object x, object y)21             bool IEqualityComparer.Equals(object x, object y)
22             {
23                 Array xArray = x as Array;
24                 Array yArray = y as Array;
25                 if (xArray == null || yArray == null || xArray.Rank != 1 || yArray.Rank != 1)
26                     return false;
27 
28                 bool mismatch = false;
29                 if (xArray.Length == yArray.Length)
30                 {
31                     for (int index = 0; !mismatch && index < xArray.Length; index++)
32                         mismatch = (xArray.GetValue(index) != yArray.GetValue(index));
33                 }
34                 else
35                 {
36                     mismatch = true;
37                 }
38                 return !mismatch;
39             }
40 
IEqualityComparer.GetHashCode(object obj)41             int IEqualityComparer.GetHashCode(object obj)
42             {
43                 return 0;
44             }
45             #endregion
46         }
47 
48         #endregion
49 
50         #region Members and Constructors
51         private Type runtimeType = null;
52         private Type[] typeArgs = null;
53         private ITypeProvider typeProvider = null;
54         private Hashtable memberMapping = new Hashtable();
55         private Hashtable boundedTypes = new Hashtable(new TypeArrayComparer());
56 
RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType)57         internal RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType)
58         {
59             if (runtimeType == null)
60                 throw new ArgumentNullException("runtimeType");
61 
62             //we dont expect DesignTimeType to be passed to this class for wrapping purposes
63             if (runtimeType.Assembly == null)
64                 throw new ArgumentException(SR.GetString(SR.Error_InvalidRuntimeType), "runtimeType");
65 
66             this.typeProvider = typeProvider;
67             this.runtimeType = runtimeType;
68         }
69 
70         internal ITypeProvider Provider
71         {
72             get
73             {
74                 return this.typeProvider;
75             }
76         }
77 
RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType, Type[] typeArgs)78         private RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType, Type[] typeArgs)
79         {
80             if (runtimeType == null)
81                 throw new ArgumentNullException("runtimeType");
82 
83             //we dont expect DesignTimeType to be passed to this class for wrapping purposes
84             if (runtimeType.Assembly == null)
85                 throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "runtimeType");
86 
87             this.typeProvider = typeProvider;
88             this.runtimeType = runtimeType;
89 
90             if (!IsGenericTypeDefinition)
91                 throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "runtimeType");
92 
93             this.typeArgs = new Type[typeArgs.Length];
94             for (int i = 0; i < typeArgs.Length; i++)
95             {
96                 this.typeArgs[i] = typeArgs[i];
97                 if (this.typeArgs[i] == null)
98                     throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "typeArgs");
99             }
100         }
101 
102         #endregion
103 
104         #region Properties
105 
106         public override int MetadataToken
107         {
108             get { return this.runtimeType.MetadataToken; }
109         }
110 
111         public override Assembly Assembly
112         {
113             get
114             {
115                 if (this.typeArgs != null)
116                 {
117                     foreach (Type type in this.typeArgs)
118                         if (type.Assembly == null)
119                             return null;
120                 }
121 
122                 return this.runtimeType.Assembly;
123             }
124         }
125         public override string AssemblyQualifiedName
126         {
127             get
128             {
129                 return this.FullName + ", " + this.runtimeType.Assembly.FullName;
130             }
131         }
132         public override Type BaseType
133         {
134             get
135             {
136                 return ResolveTypeFromTypeSystem(this.runtimeType.BaseType);
137             }
138         }
139         public override Type DeclaringType
140         {
141             get
142             {
143                 if (this.runtimeType.DeclaringType == null)
144                     return null;
145                 return this.typeProvider.GetType(this.runtimeType.DeclaringType.AssemblyQualifiedName);
146             }
147         }
148 
149         public override string FullName
150         {
151             get
152             {
153                 StringBuilder fullName = new StringBuilder(this.runtimeType.FullName);
154                 if (this.typeArgs != null && this.typeArgs.Length > 0)
155                 {
156                     fullName.Append("[");
157                     for (int index = 0; index < this.typeArgs.Length; index++)
158                     {
159                         fullName.Append("[");
160                         fullName.Append(this.typeArgs[index].AssemblyQualifiedName);
161                         fullName.Append("]");
162                         if (index < (this.typeArgs.Length - 1))
163                             fullName.Append(",");
164                     }
165                     fullName.Append("]");
166                 }
167                 return fullName.ToString();
168             }
169         }
170         public override Guid GUID
171         {
172             get
173             {
174                 return this.runtimeType.GUID;
175             }
176         }
177         public override Module Module
178         {
179             get
180             {
181                 return this.runtimeType.Module;
182             }
183         }
184         public override string Name
185         {
186             get
187             {
188                 if (IsGenericType && !IsGenericTypeDefinition)
189                     return GetGenericTypeDefinition().FullName.Substring(Namespace.Length + 1);
190                 else if (Namespace != null)
191                     return FullName.Substring(Namespace.Length + 1);
192                 else
193                     return FullName;
194             }
195         }
196         public override string Namespace
197         {
198             get
199             {
200                 return this.runtimeType.Namespace;
201             }
202         }
203         public override RuntimeTypeHandle TypeHandle
204         {
205             get
206             {
207                 return this.runtimeType.TypeHandle;
208             }
209         }
210         public override Type UnderlyingSystemType
211         {
212             get
213             {
214                 return this.runtimeType.UnderlyingSystemType;
215             }
216         }
IsAssignable(Type type1, Type type2)217         private bool IsAssignable(Type type1, Type type2)
218         {
219             Type typeTemp1 = ResolveTypeFromTypeSystem(type1);
220             Type typeTemp2 = ResolveTypeFromTypeSystem(type2);
221             return TypeProvider.IsAssignable(typeTemp1, typeTemp2);
222         }
223 
ResolveTypeFromTypeSystem(Type type)224         internal Type ResolveTypeFromTypeSystem(Type type)
225         {
226             if (type == null)
227                 return null;
228 
229             if (type.IsGenericParameter)
230                 if (this.typeArgs == null)
231                     return type;
232                 else
233                     type = this.typeArgs[type.GenericParameterPosition];
234 
235             Type returnType = null;
236             try
237             {
238                 if (!String.IsNullOrEmpty(type.AssemblyQualifiedName))
239                     returnType = this.typeProvider.GetType(type.AssemblyQualifiedName);
240             }
241             catch
242             {
243                 // Work aroundh: there are certain generic types whch we are not able to resolve
244                 // form type system, this fix will make sure that we are in thowse cases returning
245                 // the original types
246             }
247             if (returnType == null)
248                 returnType = type;
249 
250             if (returnType.IsGenericType)
251                 returnType = ResolveGenericTypeFromTypeSystem(returnType);
252 
253             return returnType;
254         }
255 
ResolveGenericTypeFromTypeSystem(Type type)256         internal Type ResolveGenericTypeFromTypeSystem(Type type)
257         {
258             if (this.runtimeType.IsGenericTypeDefinition)
259             {
260                 Type baseType = null;
261                 if (!type.IsNested)
262                     baseType = this.typeProvider.GetType(type.Namespace + "." + type.Name);
263                 else
264                 {
265                     baseType = type;
266                     string baseTypeName = type.Name;
267                     while (baseType.DeclaringType != null)
268                     {
269                         baseType = baseType.DeclaringType;
270                         baseTypeName = baseType.Name + "+" + baseTypeName;
271                     }
272                     baseTypeName = baseType.Namespace + "." + baseTypeName;
273                     baseType = this.typeProvider.GetType(baseTypeName);
274                 }
275 
276                 if (baseType != null)
277                     return baseType.MakeGenericType(this.typeArgs);
278                 else
279                     return type;
280             }
281             else
282                 return type;
283         }
284         #endregion
285 
286         #region public methods
287 
Equals(object obj)288         public override bool Equals(object obj)
289         {
290             Type otherType = obj as Type;
291             if (otherType is RTTypeWrapper)
292                 otherType = ((RTTypeWrapper)otherType).runtimeType;
293 
294             return this.runtimeType == otherType;
295         }
296 
GetCustomAttributes(bool inherit)297         public override object[] GetCustomAttributes(bool inherit)
298         {
299             return this.runtimeType.GetCustomAttributes(inherit);
300         }
GetCustomAttributes(Type attributeType, bool inherit)301         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
302         {
303             return this.runtimeType.GetCustomAttributes(attributeType, inherit);
304         }
GetConstructors(BindingFlags bindingAttr)305         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
306         {
307             List<ConstructorInfo> ctorInfos = new List<ConstructorInfo>();
308             foreach (ConstructorInfo ctorInfo in this.runtimeType.GetConstructors(bindingAttr))
309                 ctorInfos.Add(EnsureConstructorWrapped(ctorInfo));
310             return ctorInfos.ToArray();
311         }
GetEvent(string name, BindingFlags bindingAttr)312         public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
313         {
314             EventInfo eventInfo = this.runtimeType.GetEvent(name, bindingAttr);
315             if (eventInfo != null)
316                 eventInfo = EnsureEventWrapped(eventInfo);
317             return eventInfo;
318         }
GetEvents(BindingFlags bindingAttr)319         public override EventInfo[] GetEvents(BindingFlags bindingAttr)
320         {
321             List<EventInfo> eventInfos = new List<EventInfo>();
322             foreach (EventInfo eventInfo in this.runtimeType.GetEvents(bindingAttr))
323                 eventInfos.Add(EnsureEventWrapped(eventInfo));
324             return eventInfos.ToArray();
325         }
GetField(string name, BindingFlags bindingAttr)326         public override FieldInfo GetField(string name, BindingFlags bindingAttr)
327         {
328             FieldInfo field = this.runtimeType.GetField(name, bindingAttr);
329             if (field != null)
330                 field = EnsureFieldWrapped(field);
331             return field;
332         }
GetFields(BindingFlags bindingAttr)333         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
334         {
335             List<FieldInfo> fieldInfos = new List<FieldInfo>();
336             foreach (FieldInfo fieldInfo in this.runtimeType.GetFields(bindingAttr))
337                 fieldInfos.Add(EnsureFieldWrapped(fieldInfo));
338             return fieldInfos.ToArray();
339         }
GetMethods(BindingFlags bindingAttr)340         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
341         {
342             List<MethodInfo> methodInfos = new List<MethodInfo>();
343             foreach (MethodInfo methodInfo in this.runtimeType.GetMethods(bindingAttr))
344                 methodInfos.Add(EnsureMethodWrapped(methodInfo));
345             return methodInfos.ToArray();
346         }
GetProperties(BindingFlags bindingAttr)347         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
348         {
349             List<PropertyInfo> propInfos = new List<PropertyInfo>();
350             foreach (PropertyInfo propInfo in this.runtimeType.GetProperties(bindingAttr))
351                 propInfos.Add(EnsurePropertyWrapped(propInfo));
352             return propInfos.ToArray();
353         }
GetMember(string name, MemberTypes type, BindingFlags bindingAttr)354         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
355         {
356             List<MemberInfo> memberInfos = new List<MemberInfo>();
357             foreach (MemberInfo memberInfo in this.runtimeType.GetMember(name, type, bindingAttr))
358                 memberInfos.Add(EnsureMemberWrapped(memberInfo));
359             return memberInfos.ToArray();
360         }
GetMembers(BindingFlags bindingAttr)361         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
362         {
363             List<MemberInfo> memberInfos = new List<MemberInfo>();
364             foreach (MemberInfo memberInfo in this.runtimeType.GetMembers(bindingAttr))
365                 memberInfos.Add(EnsureMemberWrapped(memberInfo));
366             return memberInfos.ToArray();
367         }
GetNestedType(string name, BindingFlags bindingAttr)368         public override Type GetNestedType(string name, BindingFlags bindingAttr)
369         {
370             Type nestedType = this.runtimeType.GetNestedType(name, bindingAttr);
371             if (nestedType != null)
372                 nestedType = ResolveTypeFromTypeSystem(nestedType);
373             return nestedType;
374         }
GetNestedTypes(BindingFlags bindingAttr)375         public override Type[] GetNestedTypes(BindingFlags bindingAttr)
376         {
377             List<Type> nestedTypes = new List<Type>();
378             foreach (Type nestedType in this.runtimeType.GetNestedTypes(bindingAttr))
379                 nestedTypes.Add(ResolveTypeFromTypeSystem(nestedType));
380             return nestedTypes.ToArray();
381         }
GetInterface(string name, bool ignoreCase)382         public override Type GetInterface(string name, bool ignoreCase)
383         {
384             Type itfType = this.runtimeType.GetInterface(name, ignoreCase);
385             if (itfType != null)
386                 itfType = ResolveTypeFromTypeSystem(itfType);
387             return itfType;
388         }
GetInterfaces()389         public override Type[] GetInterfaces()
390         {
391             List<Type> itfTypes = new List<Type>();
392             foreach (Type itfType in this.runtimeType.GetInterfaces())
393             {
394                 Type interfaceType = ResolveTypeFromTypeSystem(itfType);
395                 itfTypes.Add(interfaceType);
396             }
397             return itfTypes.ToArray();
398         }
InvokeMember(string name, BindingFlags bindingFlags, Binder binder, object target, object[] providedArgs, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParams)399         public override object InvokeMember(string name, BindingFlags bindingFlags, Binder binder, object target, object[] providedArgs, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParams)
400         {
401             return this.runtimeType.InvokeMember(name, bindingFlags, binder, target, providedArgs, modifiers, culture, namedParams);
402         }
IsSubclassOf(Type potentialBaseType)403         public override bool IsSubclassOf(Type potentialBaseType)
404         {
405             return System.Workflow.ComponentModel.Compiler.TypeProvider.IsSubclassOf(this.runtimeType, potentialBaseType);
406         }
IsAssignableFrom(Type c)407         public override bool IsAssignableFrom(Type c)
408         {
409             Type rtType = this.runtimeType;
410             if (rtType.IsGenericTypeDefinition && this.IsGenericType)
411                 rtType = ResolveGenericTypeFromTypeSystem(rtType);
412 
413             return System.Workflow.ComponentModel.Compiler.TypeProvider.IsAssignable(rtType, c);
414         }
ToString()415         public override string ToString()
416         {
417             return this.runtimeType.ToString();
418         }
GetHashCode()419         public override int GetHashCode()
420         {
421             return this.runtimeType.GetHashCode();
422         }
IsDefined(Type attributeType, bool inherit)423         public override bool IsDefined(Type attributeType, bool inherit)
424         {
425             return this.runtimeType.IsDefined(attributeType, inherit);
426         }
GetElementType()427         public override Type GetElementType()
428         {
429             return ResolveTypeFromTypeSystem(this.runtimeType.GetElementType());
430         }
431 
432         #endregion
433 
434         #region Helpers
435 
EnsurePropertyWrapped(PropertyInfo realInfo)436         private PropertyInfo EnsurePropertyWrapped(PropertyInfo realInfo)
437         {
438             PropertyInfo wrapperInfo = (PropertyInfo)this.memberMapping[realInfo];
439             if (wrapperInfo == null)
440             {
441                 wrapperInfo = new RTPropertyInfoWrapper(this, realInfo);
442                 this.memberMapping.Add(realInfo, wrapperInfo);
443             }
444             return wrapperInfo;
445         }
EnsureMethodWrapped(MethodInfo realInfo)446         internal MethodInfo EnsureMethodWrapped(MethodInfo realInfo)
447         {
448             MethodInfo wrapperInfo = (MethodInfo)this.memberMapping[realInfo];
449             if (wrapperInfo == null)
450             {
451                 wrapperInfo = new RTMethodInfoWrapper(this, realInfo);
452                 this.memberMapping.Add(realInfo, wrapperInfo);
453             }
454             return wrapperInfo;
455 
456         }
EnsureMemberWrapped(MemberInfo memberInfo)457         private MemberInfo EnsureMemberWrapped(MemberInfo memberInfo)
458         {
459             MemberInfo returnMemberInfo = null;
460             if (memberInfo is PropertyInfo)
461                 returnMemberInfo = EnsurePropertyWrapped(memberInfo as PropertyInfo);
462             else if (memberInfo is ConstructorInfo)
463                 returnMemberInfo = EnsureConstructorWrapped(memberInfo as ConstructorInfo);
464             else if (memberInfo is EventInfo)
465                 returnMemberInfo = EnsureEventWrapped(memberInfo as EventInfo);
466             else if (memberInfo is FieldInfo)
467                 returnMemberInfo = EnsureFieldWrapped(memberInfo as FieldInfo);
468             else if (memberInfo is MethodInfo)
469                 returnMemberInfo = EnsureMethodWrapped(memberInfo as MethodInfo);
470             return returnMemberInfo;
471         }
EnsureConstructorWrapped(ConstructorInfo realInfo)472         private ConstructorInfo EnsureConstructorWrapped(ConstructorInfo realInfo)
473         {
474             ConstructorInfo wrapperInfo = (ConstructorInfo)this.memberMapping[realInfo];
475             if (wrapperInfo == null)
476             {
477                 wrapperInfo = new RTConstructorInfoWrapper(this, realInfo);
478                 this.memberMapping.Add(realInfo, wrapperInfo);
479             }
480             return wrapperInfo;
481 
482         }
EnsureEventWrapped(EventInfo realInfo)483         private EventInfo EnsureEventWrapped(EventInfo realInfo)
484         {
485             EventInfo wrapperInfo = (EventInfo)this.memberMapping[realInfo];
486             if (wrapperInfo == null)
487             {
488                 wrapperInfo = new RTEventInfoWrapper(this, realInfo);
489                 this.memberMapping.Add(realInfo, wrapperInfo);
490             }
491             return wrapperInfo;
492         }
EnsureFieldWrapped(FieldInfo realInfo)493         private FieldInfo EnsureFieldWrapped(FieldInfo realInfo)
494         {
495             FieldInfo wrapperInfo = (FieldInfo)this.memberMapping[realInfo];
496             if (wrapperInfo == null)
497             {
498                 wrapperInfo = new RTFieldInfoWrapper(this, realInfo);
499                 this.memberMapping.Add(realInfo, wrapperInfo);
500             }
501             return wrapperInfo;
502         }
503 
504         #endregion
505 
506         #region Support for generics
507         public override bool IsGenericTypeDefinition
508         {
509             get
510             {
511                 if (this.typeArgs != null && this.typeArgs.GetLength(0) > 0)
512                     return false;
513                 return this.runtimeType.IsGenericTypeDefinition;
514             }
515         }
516         public override bool IsGenericParameter
517         {
518             get
519             {
520                 return this.runtimeType.IsGenericParameter;
521             }
522         }
523         public override int GenericParameterPosition
524         {
525             get
526             {
527                 return this.runtimeType.GenericParameterPosition;
528             }
529         }
530         public override bool IsGenericType
531         {
532             get
533             {
534                 if (this.typeArgs != null && this.typeArgs.GetLength(0) > 0)
535                     return true;
536                 return this.runtimeType.IsGenericType;
537             }
538         }
539         public override bool ContainsGenericParameters
540         {
541             get
542             {
543                 if (this.typeArgs != null && this.typeArgs.GetLength(0) > 0)
544                     return false;
545                 return this.runtimeType.ContainsGenericParameters;
546             }
547         }
GetGenericArguments()548         public override Type[] GetGenericArguments()
549         {
550             return this.typeArgs;
551         }
GetGenericTypeDefinition()552         public override Type GetGenericTypeDefinition()
553         {
554             if (this.IsGenericType)
555                 return this.runtimeType;
556             return this;
557         }
MakeGenericType(params Type[] typeArgs)558         public override Type MakeGenericType(params Type[] typeArgs)
559         {
560             if (typeArgs == null)
561                 throw new ArgumentNullException("typeArgs");
562 
563             Type[] types = new Type[typeArgs.Length];
564 
565             if (!IsGenericTypeDefinition)
566                 throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "typeArgs");
567 
568             for (int i = 0; i < typeArgs.Length; i++)
569             {
570                 types[i] = typeArgs[i];
571                 if (types[i] == null)
572                     throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "typeArgs");
573             }
574 
575             Type returnType = this.boundedTypes[typeArgs] as Type;
576             if (returnType == null)
577             {
578                 // handle Nullable<T> specially
579                 if ((typeArgs.Length == 1) && (this.runtimeType == typeof(Nullable<>)) && !(typeArgs[0].IsEnum))
580                 {
581                     switch (Type.GetTypeCode(typeArgs[0]))
582                     {
583                         case TypeCode.Boolean:
584                             returnType = typeof(bool?);
585                             break;
586                         case TypeCode.Byte:
587                             returnType = typeof(byte?);
588                             break;
589                         case TypeCode.Char:
590                             returnType = typeof(char?);
591                             break;
592                         case TypeCode.DateTime:
593                             returnType = typeof(DateTime?);
594                             break;
595                         case TypeCode.Decimal:
596                             returnType = typeof(decimal?);
597                             break;
598                         case TypeCode.Double:
599                             returnType = typeof(double?);
600                             break;
601                         case TypeCode.Int16:
602                             returnType = typeof(short?);
603                             break;
604                         case TypeCode.Int32:
605                             returnType = typeof(int?);
606                             break;
607                         case TypeCode.Int64:
608                             returnType = typeof(long?);
609                             break;
610                         case TypeCode.SByte:
611                             returnType = typeof(sbyte?);
612                             break;
613                         case TypeCode.Single:
614                             returnType = typeof(float?);
615                             break;
616                         case TypeCode.UInt16:
617                             returnType = typeof(ushort?);
618                             break;
619                         case TypeCode.UInt32:
620                             returnType = typeof(uint?);
621                             break;
622                         case TypeCode.UInt64:
623                             returnType = typeof(ulong?);
624                             break;
625                         default:
626                             // no special handling, so make it as usual
627                             returnType = new RTTypeWrapper(this.typeProvider, this.runtimeType, typeArgs);
628                             break;
629                     }
630                 }
631                 else
632                 {
633                     returnType = new RTTypeWrapper(this.typeProvider, this.runtimeType, typeArgs);
634                 }
635                 this.boundedTypes[typeArgs] = returnType;
636             }
637             return returnType;
638         }
639 
MakeByRefType()640         public override Type MakeByRefType()
641         {
642             return this.typeProvider.GetType(this.FullName + "&");
643         }
644 
MakePointerType()645         public override Type MakePointerType()
646         {
647             return this.typeProvider.GetType(this.FullName + "*");
648         }
649 
OnAssemblyRemoved(Assembly removedAssembly)650         internal void OnAssemblyRemoved(Assembly removedAssembly)
651         {
652             ArrayList bindingArgs = new ArrayList(this.boundedTypes.Keys);
653             foreach (Type[] types in bindingArgs)
654             {
655                 foreach (Type type in types)
656                 {
657                     if (type.Assembly == removedAssembly)
658                     {
659                         this.boundedTypes.Remove(types);
660                         break;
661                     }
662                 }
663             }
664         }
665 
666         #endregion
667 
668         #region implementation overrides
669 
GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)670         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
671         {
672             foreach (ConstructorInfo ctorInfo in this.runtimeType.GetConstructors(bindingAttr))
673             {
674                 bool mismatch = false;
675                 if (types != null)
676                 {
677                     ParameterInfo[] parameters = ctorInfo.GetParameters();
678                     if (parameters.GetLength(0) == types.Length)
679                     {
680                         for (int index = 0; !mismatch && index < parameters.Length; index++)
681                             mismatch = !IsAssignable(parameters[index].ParameterType, types[index]);
682                     }
683                     else
684                     {
685                         mismatch = true;
686                     }
687                 }
688                 if (!mismatch)
689                     return EnsureConstructorWrapped(ctorInfo);
690             }
691             return null;
692         }
GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)693         protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
694         {
695             foreach (MethodInfo method in this.runtimeType.GetMethods(bindingAttr))
696             {
697                 bool matchName = ((bindingAttr & BindingFlags.IgnoreCase) == BindingFlags.IgnoreCase) ? string.Compare(method.Name, name, StringComparison.OrdinalIgnoreCase) == 0 : string.Compare(method.Name, name, StringComparison.Ordinal) == 0;
698                 if (matchName)
699                 {
700                     bool mismatch = false;
701                     if (types != null)
702                     {
703                         ParameterInfo[] parameters = method.GetParameters();
704                         if (parameters.GetLength(0) == types.Length)
705                         {
706                             for (int index = 0; !mismatch && index < parameters.Length; index++)
707                                 mismatch = !IsAssignable(parameters[index].ParameterType, types[index]);
708                         }
709                         else
710                         {
711                             mismatch = true;
712                         }
713                     }
714                     if (!mismatch)
715                         return EnsureMethodWrapped(method);
716                 }
717             }
718             return null;
719         }
GetPropertyImpl(String name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)720         protected override PropertyInfo GetPropertyImpl(String name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
721         {
722             foreach (PropertyInfo propInfo in this.runtimeType.GetProperties(bindingAttr))
723             {
724                 bool matchName = ((bindingAttr & BindingFlags.IgnoreCase) == BindingFlags.IgnoreCase) ? string.Compare(propInfo.Name, name, StringComparison.OrdinalIgnoreCase) == 0 : string.Compare(propInfo.Name, name, StringComparison.Ordinal) == 0;
725                 if (matchName && (returnType == null || (returnType.Equals(propInfo.PropertyType))))
726                 {
727                     bool mismatch = false;
728                     if (types != null)
729                     {
730                         ParameterInfo[] parameters = propInfo.GetIndexParameters();
731                         if (parameters.GetLength(0) == types.Length)
732                         {
733                             for (int index = 0; !mismatch && index < parameters.Length; index++)
734                                 mismatch = !IsAssignable(parameters[index].ParameterType, types[index]);
735                         }
736                         else
737                         {
738                             mismatch = true;
739                         }
740                     }
741                     if (!mismatch)
742                         return EnsurePropertyWrapped(propInfo);
743                 }
744             }
745             return null;
746         }
GetAttributeFlagsImpl()747         protected override TypeAttributes GetAttributeFlagsImpl()
748         {
749             return this.runtimeType.Attributes;
750         }
HasElementTypeImpl()751         protected override bool HasElementTypeImpl()
752         {
753             return this.runtimeType.HasElementType;
754         }
GetArrayRank()755         public override int GetArrayRank()
756         {
757             return this.runtimeType.GetArrayRank();
758         }
IsArrayImpl()759         protected override bool IsArrayImpl()
760         {
761             return this.runtimeType.IsArray;
762         }
IsByRefImpl()763         protected override bool IsByRefImpl()
764         {
765             return this.runtimeType.IsByRef;
766         }
IsCOMObjectImpl()767         protected override bool IsCOMObjectImpl()
768         {
769             return this.runtimeType.IsCOMObject;
770         }
IsContextfulImpl()771         protected override bool IsContextfulImpl()
772         {
773             return this.runtimeType.IsContextful;
774         }
IsMarshalByRefImpl()775         protected override bool IsMarshalByRefImpl()
776         {
777             return this.runtimeType.IsMarshalByRef;
778         }
IsPointerImpl()779         protected override bool IsPointerImpl()
780         {
781             return this.runtimeType.IsPointer;
782         }
IsPrimitiveImpl()783         protected override bool IsPrimitiveImpl()
784         {
785             return this.runtimeType.IsPrimitive;
786         }
787         #endregion
788 
789         #region ICloneable Members
Clone()790         public object Clone()
791         {
792             return this;
793         }
794         #endregion
795 
796         #region ConstructorInfo wrapper
797 
798         private class RTConstructorInfoWrapper : ConstructorInfo
799         {
800             private RTTypeWrapper rtTypeWrapper = null;
801             private ConstructorInfo ctorInfo = null;
802             private ParameterInfo[] wrappedParameters = null;
RTConstructorInfoWrapper(RTTypeWrapper rtTypeWrapper, ConstructorInfo ctorInfo)803             public RTConstructorInfoWrapper(RTTypeWrapper rtTypeWrapper, ConstructorInfo ctorInfo)
804             {
805                 this.rtTypeWrapper = rtTypeWrapper;
806                 this.ctorInfo = ctorInfo;
807             }
Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)808             public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
809             {
810                 return this.ctorInfo.Invoke(invokeAttr, binder, parameters, culture);
811             }
812             public override MethodAttributes Attributes
813             {
814                 get { return this.ctorInfo.Attributes; }
815             }
GetMethodImplementationFlags()816             public override MethodImplAttributes GetMethodImplementationFlags()
817             {
818                 return this.ctorInfo.GetMethodImplementationFlags();
819             }
GetParameters()820             public override ParameterInfo[] GetParameters()
821             {
822                 if (this.wrappedParameters == null)
823                 {
824                     List<ParameterInfo> parameters = new List<ParameterInfo>();
825                     foreach (ParameterInfo parameter in this.ctorInfo.GetParameters())
826                         parameters.Add(new RTParameterInfoWrapper(this.rtTypeWrapper, this.ctorInfo, parameter));
827                     this.wrappedParameters = parameters.ToArray();
828                 }
829                 return this.wrappedParameters;
830             }
Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)831             public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
832             {
833                 return this.ctorInfo.Invoke(obj, invokeAttr, binder, parameters, culture);
834             }
835             public override RuntimeMethodHandle MethodHandle
836             {
837                 get { return this.ctorInfo.MethodHandle; }
838             }
839             public override Type DeclaringType
840             {
841                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.ctorInfo.DeclaringType); }
842             }
GetCustomAttributes(Type attributeType, bool inherit)843             public override object[] GetCustomAttributes(Type attributeType, bool inherit)
844             {
845                 return this.ctorInfo.GetCustomAttributes(attributeType, inherit);
846             }
GetCustomAttributes(bool inherit)847             public override object[] GetCustomAttributes(bool inherit)
848             {
849                 return this.ctorInfo.GetCustomAttributes(inherit);
850             }
IsDefined(Type attributeType, bool inherit)851             public override bool IsDefined(Type attributeType, bool inherit)
852             {
853                 return this.ctorInfo.IsDefined(attributeType, inherit);
854             }
855             public override MemberTypes MemberType
856             {
857                 get { return this.ctorInfo.MemberType; }
858             }
859             public override string Name
860             {
861                 get { return this.ctorInfo.Name; }
862             }
863             public override Type ReflectedType
864             {
865                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.ctorInfo.ReflectedType); }
866             }
867         }
868 
869         #endregion
870 
871         #region FieldInfo Wrapper
872 
873         private class RTFieldInfoWrapper : FieldInfo
874         {
875             private RTTypeWrapper rtTypeWrapper = null;
876             private FieldInfo fieldInfo = null;
RTFieldInfoWrapper(RTTypeWrapper rtTypeWrapper, FieldInfo fieldInfo)877             public RTFieldInfoWrapper(RTTypeWrapper rtTypeWrapper, FieldInfo fieldInfo)
878             {
879                 this.rtTypeWrapper = rtTypeWrapper;
880                 this.fieldInfo = fieldInfo;
881             }
882             public override int MetadataToken
883             {
884                 get { return this.fieldInfo.MetadataToken; }
885             }
886             public override Module Module
887             {
888                 get { return this.fieldInfo.Module; }
889             }
890             public override FieldAttributes Attributes
891             {
892                 get { return this.fieldInfo.Attributes; }
893             }
894             public override RuntimeFieldHandle FieldHandle
895             {
896                 get { return this.fieldInfo.FieldHandle; }
897             }
898             public override Type FieldType
899             {
900                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.fieldInfo.FieldType); }
901             }
GetValue(object obj)902             public override object GetValue(object obj)
903             {
904                 return this.fieldInfo.GetValue(obj);
905             }
SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)906             public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
907             {
908                 this.fieldInfo.SetValue(obj, value, invokeAttr, binder, culture);
909             }
910             public override Type DeclaringType
911             {
912                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.fieldInfo.DeclaringType); }
913             }
GetCustomAttributes(Type attributeType, bool inherit)914             public override object[] GetCustomAttributes(Type attributeType, bool inherit)
915             {
916                 return this.fieldInfo.GetCustomAttributes(attributeType, inherit);
917             }
GetCustomAttributes(bool inherit)918             public override object[] GetCustomAttributes(bool inherit)
919             {
920                 return this.fieldInfo.GetCustomAttributes(inherit);
921             }
IsDefined(Type attributeType, bool inherit)922             public override bool IsDefined(Type attributeType, bool inherit)
923             {
924                 return this.fieldInfo.IsDefined(attributeType, inherit);
925             }
926             public override MemberTypes MemberType
927             {
928                 get { return this.fieldInfo.MemberType; }
929             }
930             public override string Name
931             {
932                 get { return this.fieldInfo.Name; }
933             }
934             public override Type ReflectedType
935             {
936                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.fieldInfo.ReflectedType); }
937             }
938         }
939 
940         #endregion
941 
942         #region PropertyInfo Wrapper
943 
944         private class RTPropertyInfoWrapper : PropertyInfo
945         {
946             private PropertyInfo propertyInfo = null;
947             private RTTypeWrapper rtTypeWrapper = null;
948             private ParameterInfo[] wrappedParameters = null;
RTPropertyInfoWrapper(RTTypeWrapper rtTypeWrapper, PropertyInfo propertyInfo)949             public RTPropertyInfoWrapper(RTTypeWrapper rtTypeWrapper, PropertyInfo propertyInfo)
950             {
951                 this.rtTypeWrapper = rtTypeWrapper;
952                 this.propertyInfo = propertyInfo;
953             }
954 
955             public override PropertyAttributes Attributes
956             {
957                 get { return this.propertyInfo.Attributes; }
958             }
959 
960             public override bool CanRead
961             {
962                 get { return this.propertyInfo.CanRead; }
963             }
964 
965             public override bool CanWrite
966             {
967                 get { return this.propertyInfo.CanWrite; }
968             }
GetAccessors(bool nonPublic)969             public override MethodInfo[] GetAccessors(bool nonPublic)
970             {
971                 List<MethodInfo> methods = new List<MethodInfo>();
972                 foreach (MethodInfo methodInfo in this.propertyInfo.GetAccessors(nonPublic))
973                     methods.Add(this.rtTypeWrapper.EnsureMethodWrapped(methodInfo));
974                 return methods.ToArray();
975             }
GetGetMethod(bool nonPublic)976             public override MethodInfo GetGetMethod(bool nonPublic)
977             {
978                 MethodInfo methodInfo = this.propertyInfo.GetGetMethod(nonPublic);
979                 if (methodInfo == null)
980                     return null;
981                 return this.rtTypeWrapper.EnsureMethodWrapped(methodInfo);
982             }
GetIndexParameters()983             public override ParameterInfo[] GetIndexParameters()
984             {
985                 if (this.wrappedParameters == null)
986                 {
987                     List<ParameterInfo> parameters = new List<ParameterInfo>();
988                     foreach (ParameterInfo parameter in this.propertyInfo.GetIndexParameters())
989                         parameters.Add(new RTParameterInfoWrapper(this.rtTypeWrapper, this.propertyInfo, parameter));
990                     this.wrappedParameters = parameters.ToArray();
991                 }
992                 return this.wrappedParameters;
993             }
GetSetMethod(bool nonPublic)994             public override MethodInfo GetSetMethod(bool nonPublic)
995             {
996                 MethodInfo methodInfo = this.propertyInfo.GetSetMethod(nonPublic);
997                 if (methodInfo == null)
998                     return null;
999                 return this.rtTypeWrapper.EnsureMethodWrapped(methodInfo);
1000             }
GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)1001             public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
1002             {
1003                 return this.propertyInfo.GetValue(obj, invokeAttr, binder, index, culture);
1004             }
1005             public override Type PropertyType
1006             {
1007                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.propertyInfo.PropertyType); }
1008             }
SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)1009             public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
1010             {
1011                 this.propertyInfo.SetValue(obj, value, invokeAttr, binder, index, culture);
1012             }
1013             public override Type DeclaringType
1014             {
1015                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.propertyInfo.DeclaringType); }
1016             }
GetCustomAttributes(Type attributeType, bool inherit)1017             public override object[] GetCustomAttributes(Type attributeType, bool inherit)
1018             {
1019                 return this.propertyInfo.GetCustomAttributes(attributeType, inherit);
1020             }
GetCustomAttributes(bool inherit)1021             public override object[] GetCustomAttributes(bool inherit)
1022             {
1023                 return this.propertyInfo.GetCustomAttributes(inherit);
1024             }
IsDefined(Type attributeType, bool inherit)1025             public override bool IsDefined(Type attributeType, bool inherit)
1026             {
1027                 return this.propertyInfo.IsDefined(attributeType, inherit);
1028             }
1029             public override MemberTypes MemberType
1030             {
1031                 get { return this.propertyInfo.MemberType; }
1032             }
1033             public override string Name
1034             {
1035                 get { return this.propertyInfo.Name; }
1036             }
1037             public override Type ReflectedType
1038             {
1039                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.propertyInfo.ReflectedType); }
1040             }
1041             public override int MetadataToken
1042             {
1043                 get { return this.propertyInfo.MetadataToken; }
1044             }
1045 
1046             public override Module Module
1047             {
1048                 get { return this.propertyInfo.Module; }
1049             }
1050         }
1051 
1052         #endregion
1053 
1054         #region MethodInfo Wrapper
1055 
1056         private class RTMethodInfoWrapper : MethodInfo
1057         {
1058             private MethodInfo methodInfo = null;
1059             private RTTypeWrapper rtTypeWrapper = null;
1060             private ParameterInfo[] wrappedParameters = null;
RTMethodInfoWrapper(RTTypeWrapper rtTypeWrapper, MethodInfo methodInfo)1061             public RTMethodInfoWrapper(RTTypeWrapper rtTypeWrapper, MethodInfo methodInfo)
1062             {
1063                 this.rtTypeWrapper = rtTypeWrapper;
1064                 this.methodInfo = methodInfo;
1065             }
1066             public override Module Module
1067             {
1068                 get { return this.methodInfo.Module; }
1069             }
GetMethodBody()1070             public override MethodBody GetMethodBody()
1071             {
1072                 return this.methodInfo.GetMethodBody();
1073             }
1074             public override int MetadataToken
1075             {
1076                 get { return this.methodInfo.MetadataToken; }
1077             }
1078             public override CallingConventions CallingConvention
1079             {
1080                 get { return this.methodInfo.CallingConvention; }
1081             }
1082             public override ParameterInfo ReturnParameter
1083             {
1084                 get { return new RTParameterInfoWrapper(this.rtTypeWrapper, this, this.methodInfo.ReturnParameter); }
1085             }
GetBaseDefinition()1086             public override MethodInfo GetBaseDefinition()
1087             {
1088                 return this.methodInfo.GetBaseDefinition();
1089             }
1090             public override Type ReturnType
1091             {
1092                 get
1093                 {
1094                     return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.methodInfo.ReturnType);
1095                 }
1096             }
1097             public override ICustomAttributeProvider ReturnTypeCustomAttributes
1098             {
1099                 get { return this.methodInfo.ReturnTypeCustomAttributes; }
1100             }
1101             public override MethodAttributes Attributes
1102             {
1103                 get { return this.methodInfo.Attributes; }
1104             }
GetMethodImplementationFlags()1105             public override MethodImplAttributes GetMethodImplementationFlags()
1106             {
1107                 return this.methodInfo.GetMethodImplementationFlags();
1108             }
GetParameters()1109             public override ParameterInfo[] GetParameters()
1110             {
1111                 if (this.wrappedParameters == null)
1112                 {
1113                     List<ParameterInfo> parameters = new List<ParameterInfo>();
1114                     foreach (ParameterInfo parameter in this.methodInfo.GetParameters())
1115                         parameters.Add(new RTParameterInfoWrapper(this.rtTypeWrapper, this.methodInfo, parameter));
1116                     this.wrappedParameters = parameters.ToArray();
1117                 }
1118                 return this.wrappedParameters;
1119             }
Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)1120             public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
1121             {
1122                 return this.methodInfo.Invoke(obj, invokeAttr, binder, parameters, culture);
1123             }
1124             public override RuntimeMethodHandle MethodHandle
1125             {
1126                 get { return this.methodInfo.MethodHandle; }
1127             }
1128 
1129             public override Type DeclaringType
1130             {
1131                 get
1132                 {
1133                     return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.methodInfo.DeclaringType);
1134                 }
1135             }
GetCustomAttributes(Type attributeType, bool inherit)1136             public override object[] GetCustomAttributes(Type attributeType, bool inherit)
1137             {
1138                 return this.methodInfo.GetCustomAttributes(attributeType, inherit);
1139             }
GetCustomAttributes(bool inherit)1140             public override object[] GetCustomAttributes(bool inherit)
1141             {
1142                 return this.methodInfo.GetCustomAttributes(inherit);
1143             }
IsDefined(Type attributeType, bool inherit)1144             public override bool IsDefined(Type attributeType, bool inherit)
1145             {
1146                 return this.methodInfo.IsDefined(attributeType, inherit);
1147             }
1148             public override MemberTypes MemberType
1149             {
1150                 get { return this.methodInfo.MemberType; }
1151             }
1152             public override string Name
1153             {
1154                 get { return this.methodInfo.Name; }
1155             }
1156             public override Type ReflectedType
1157             {
1158                 get
1159                 {
1160                     return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.methodInfo.ReflectedType);
1161                 }
1162             }
1163         }
1164 
1165         #endregion
1166 
1167         #region EventInfo Wrapper
1168 
1169         private class RTEventInfoWrapper : EventInfo
1170         {
1171             private RTTypeWrapper rtTypeWrapper = null;
1172             private EventInfo eventInfo = null;
RTEventInfoWrapper(RTTypeWrapper rtTypeWrapper, EventInfo eventInfo)1173             public RTEventInfoWrapper(RTTypeWrapper rtTypeWrapper, EventInfo eventInfo)
1174             {
1175                 this.rtTypeWrapper = rtTypeWrapper;
1176                 this.eventInfo = eventInfo;
1177             }
1178             public override EventAttributes Attributes
1179             {
1180                 get { return this.eventInfo.Attributes; }
1181             }
GetAddMethod(bool nonPublic)1182             public override MethodInfo GetAddMethod(bool nonPublic)
1183             {
1184                 MethodInfo methodInfo = this.eventInfo.GetAddMethod(nonPublic);
1185                 if (methodInfo == null)
1186                     return null;
1187                 return this.rtTypeWrapper.EnsureMethodWrapped(methodInfo);
1188             }
GetRaiseMethod(bool nonPublic)1189             public override MethodInfo GetRaiseMethod(bool nonPublic)
1190             {
1191                 MethodInfo methodInfo = this.eventInfo.GetRaiseMethod(nonPublic);
1192                 if (methodInfo == null)
1193                     return null;
1194                 return this.rtTypeWrapper.EnsureMethodWrapped(methodInfo);
1195             }
GetRemoveMethod(bool nonPublic)1196             public override MethodInfo GetRemoveMethod(bool nonPublic)
1197             {
1198                 MethodInfo methodInfo = this.eventInfo.GetRemoveMethod(nonPublic);
1199                 if (methodInfo == null)
1200                     return null;
1201                 return this.rtTypeWrapper.EnsureMethodWrapped(methodInfo);
1202             }
1203             public override Type DeclaringType
1204             {
1205                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.eventInfo.DeclaringType); }
1206             }
GetCustomAttributes(Type attributeType, bool inherit)1207             public override object[] GetCustomAttributes(Type attributeType, bool inherit)
1208             {
1209                 return this.eventInfo.GetCustomAttributes(attributeType, inherit);
1210             }
GetCustomAttributes(bool inherit)1211             public override object[] GetCustomAttributes(bool inherit)
1212             {
1213                 return this.eventInfo.GetCustomAttributes(inherit);
1214             }
IsDefined(Type attributeType, bool inherit)1215             public override bool IsDefined(Type attributeType, bool inherit)
1216             {
1217                 return this.eventInfo.IsDefined(attributeType, inherit);
1218             }
1219             public override MemberTypes MemberType
1220             {
1221                 get { return this.eventInfo.MemberType; }
1222             }
1223             public override string Name
1224             {
1225                 get { return this.eventInfo.Name; }
1226             }
1227             public override Type ReflectedType
1228             {
1229                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.eventInfo.ReflectedType); }
1230             }
1231 
1232             public override int MetadataToken
1233             {
1234                 get { return this.eventInfo.MetadataToken; }
1235             }
1236             public override Module Module
1237             {
1238                 get { return this.eventInfo.Module; }
1239             }
1240         }
1241 
1242         #endregion
1243 
1244         #region ParameterInfo wrapper
1245 
1246         private class RTParameterInfoWrapper : ParameterInfo
1247         {
1248             private RTTypeWrapper rtTypeWrapper = null;
1249             private ParameterInfo paramInfo = null;
1250             private MemberInfo parentMember = null;
1251 
RTParameterInfoWrapper(RTTypeWrapper rtTypeWrapper, MemberInfo parentMember, ParameterInfo paramInfo)1252             public RTParameterInfoWrapper(RTTypeWrapper rtTypeWrapper, MemberInfo parentMember, ParameterInfo paramInfo)
1253             {
1254                 this.parentMember = parentMember;
1255                 this.rtTypeWrapper = rtTypeWrapper;
1256                 this.paramInfo = paramInfo;
1257             }
1258             public override ParameterAttributes Attributes
1259             {
1260                 get { return this.paramInfo.Attributes; }
1261             }
GetCustomAttributes(bool inherit)1262             public override object[] GetCustomAttributes(bool inherit)
1263             {
1264                 return this.paramInfo.GetCustomAttributes(inherit);
1265             }
IsDefined(Type attributeType, bool inherit)1266             public override bool IsDefined(Type attributeType, bool inherit)
1267             {
1268                 return this.paramInfo.IsDefined(attributeType, inherit);
1269             }
1270             public override MemberInfo Member
1271             {
1272                 get { return this.parentMember; }
1273             }
GetOptionalCustomModifiers()1274             public override Type[] GetOptionalCustomModifiers()
1275             {
1276                 return this.paramInfo.GetOptionalCustomModifiers();
1277             }
1278             public override string Name
1279             {
1280                 get { return this.paramInfo.Name; }
1281             }
1282             public override Type ParameterType
1283             {
1284                 get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.paramInfo.ParameterType); }
1285             }
1286             public override int Position
1287             {
1288                 get { return this.paramInfo.Position; }
1289             }
GetRequiredCustomModifiers()1290             public override Type[] GetRequiredCustomModifiers()
1291             {
1292                 return this.paramInfo.GetRequiredCustomModifiers();
1293             }
1294             public override object DefaultValue
1295             {
1296                 get
1297                 {
1298 #pragma warning suppress 56503
1299                     throw new global::System.NotImplementedException();
1300                 }
1301             }
1302         }
1303         #endregion
1304     }
1305 }
1306