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