public Type GetType(string name, bool throwOnError) { if (name == null) { throw new ArgumentNullException("name"); } this.EnsureCurrentTypes(); bool flag = false; Type type = null; string typeName = string.Empty; string[] parameters = null; string elemantDecorator = string.Empty; if (ParseHelpers.ParseTypeName(name, ParseHelpers.ParseTypeNameLanguage.NetFramework, out typeName, out parameters, out elemantDecorator)) { if ((parameters != null) && (parameters.Length > 0)) { Type type2 = this.GetType(typeName, throwOnError); if ((type2 == null) || !type2.IsGenericTypeDefinition) { return null; } Type[] typeArguments = new Type[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { Type type3 = this.GetType(parameters[i], throwOnError); if (type3 == null) { return null; } typeArguments[i] = type3; } return type2.MakeGenericType(typeArguments); } if (elemantDecorator != string.Empty) { Type type4 = this.GetType(typeName); if (type4 != null) { StringBuilder builder = new StringBuilder(type4.FullName); for (int j = 0; j < elemantDecorator.Length; j++) { if (elemantDecorator[j] != ' ') { builder.Append(elemantDecorator[j]); } } name = builder.ToString(); if (type4.Assembly != null) { type = type4.Assembly.GetType(name, false); } if (type == null) { if (this.hashOfDTTypes.Contains(name)) { return (this.hashOfDTTypes[name] as Type); } type = new DesignTimeType(null, name, this); this.hashOfDTTypes.Add(name, type); return type; } } } else { string thatName = string.Empty; int index = name.IndexOf(','); if (index != -1) { typeName = name.Substring(0, index); thatName = name.Substring(index + 1).Trim(); } typeName = typeName.Trim(); if (typeName.Length > 0) { type = this.designTimeTypes[typeName] as Type; if (type == null) { foreach (DictionaryEntry entry in this.rawAssemblyLoaders) { AssemblyLoader loader = entry.Value as AssemblyLoader; if ((thatName.Length == 0) || ParseHelpers.AssemblyNameEquals(loader.AssemblyName, thatName)) { try { type = loader.GetType(typeName); } catch (Exception exception) { if (!this.typeLoadErrors.Contains(entry.Key)) { this.typeLoadErrors[entry.Key] = exception; flag = true; } if (throwOnError) { throw exception; } } if (type != null) { break; } } } } if (type == null) { foreach (DictionaryEntry entry2 in this.assemblyLoaders) { AssemblyLoader loader2 = entry2.Value as AssemblyLoader; if ((thatName.Length == 0) || ParseHelpers.AssemblyNameEquals(loader2.AssemblyName, thatName)) { try { type = loader2.GetType(typeName); } catch (Exception exception2) { if (!this.typeLoadErrors.Contains(entry2.Key)) { this.typeLoadErrors[entry2.Key] = exception2; flag = true; } if (throwOnError) { throw exception2; } } if (type != null) { break; } } } } if (flag && (this.TypeLoadErrorsChanged != null)) { FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty }); } if (((type == null) && (this.localAssembly != null)) && (thatName == this.localAssembly.FullName)) { type = this.localAssembly.GetType(typeName); } } } } if (type == null) { if (throwOnError) { throw new Exception(TypeSystemSR.GetString(CultureInfo.CurrentCulture, "Error_TypeResolution", new object[] { name })); } return null; } if (((this.designTimeTypes == null) || (this.designTimeTypes.Count <= 0)) || ((type.Assembly == null) || !type.IsGenericTypeDefinition)) { return type; } if (this.hashOfRTTypes.Contains(type)) { return (Type) this.hashOfRTTypes[type]; } Type type5 = new RTTypeWrapper(this, type); this.hashOfRTTypes.Add(type, type5); return type5; }
public RTPropertyInfoWrapper(RTTypeWrapper rtTypeWrapper, PropertyInfo propertyInfo) { this.rtTypeWrapper = rtTypeWrapper; this.propertyInfo = propertyInfo; }
public Type GetType(string name, bool throwOnError) { if (name == null) throw new ArgumentNullException("name"); EnsureCurrentTypes(); bool hasTypeLoadErrors = false; Type returnType = null; string typeName = string.Empty; string[] parameters = null; string elementDecorator = string.Empty; if (ParseHelpers.ParseTypeName(name, ParseHelpers.ParseTypeNameLanguage.NetFramework, out typeName, out parameters, out elementDecorator)) { if ((parameters != null) && (parameters.Length > 0)) { //Generic type Type templateType = GetType(typeName, throwOnError); if ((templateType == null) || (!templateType.IsGenericTypeDefinition)) return null; Type[] templateParamTypes = new Type[parameters.Length]; for (int index = 0; index < parameters.Length; index++) { Type templateParameter = GetType(parameters[index], throwOnError); if (templateParameter == null) return null; templateParamTypes[index] = templateParameter; } return templateType.MakeGenericType(templateParamTypes); } else if (elementDecorator != string.Empty) { //type with element (Array, ByRef, Pointer) Type elementType = this.GetType(typeName); if (elementType != null) { // first we verify the name is formated well (AssemblyQualifiedName for generic // parameters + no spaces in array brackets) System.Text.StringBuilder nameBuilder = new System.Text.StringBuilder(elementType.FullName); for (int loop = 0; loop < elementDecorator.Length; loop++) if (elementDecorator[loop] != ' ') nameBuilder.Append(elementDecorator[loop]); name = nameBuilder.ToString(); // let tha assembly of the element type a chance to find a type (will fail only // if element contains parameter from external assembly if (elementType.Assembly != null) returnType = elementType.Assembly.GetType(name, false); if (returnType == null) { // now we can fetch or create the type if (this.hashOfDTTypes.Contains(name)) { returnType = this.hashOfDTTypes[name] as Type; } else { returnType = new DesignTimeType(null, name, this); this.hashOfDTTypes.Add(name, returnType); } return returnType; } } } else { // regular type, get the type name string assemblyName = string.Empty; int indexOfComma = name.IndexOf(','); if (indexOfComma != -1) { typeName = name.Substring(0, indexOfComma); assemblyName = name.Substring(indexOfComma + 1).Trim(); } typeName = typeName.Trim(); if (typeName.Length > 0) { returnType = this.designTimeTypes[typeName] as Type; if (returnType == null) { foreach (DictionaryEntry dictionaryEntry in this.rawAssemblyLoaders) { AssemblyLoader assemblyLoader = dictionaryEntry.Value as AssemblyLoader; if ((assemblyName.Length == 0) || (ParseHelpers.AssemblyNameEquals(assemblyLoader.AssemblyName, assemblyName))) { try { returnType = assemblyLoader.GetType(typeName); } catch (Exception e) { if (!this.typeLoadErrors.Contains(dictionaryEntry.Key)) { this.typeLoadErrors[dictionaryEntry.Key] = e; hasTypeLoadErrors = true; } // bubble up exceptions only when appropiate if (throwOnError) throw e; } if (returnType != null) break; } } } if (returnType == null) { foreach (DictionaryEntry dictionaryEntry in this.assemblyLoaders) { AssemblyLoader assemblyLoader = dictionaryEntry.Value as AssemblyLoader; if ((assemblyName.Length == 0) || (ParseHelpers.AssemblyNameEquals(assemblyLoader.AssemblyName, assemblyName))) { try { returnType = assemblyLoader.GetType(typeName); } catch (Exception e) { if (!this.typeLoadErrors.Contains(dictionaryEntry.Key)) { this.typeLoadErrors[dictionaryEntry.Key] = e; hasTypeLoadErrors = true; } // bubble up exceptions only when appropiate if (throwOnError) throw e; } if (returnType != null) break; } } } if (hasTypeLoadErrors) { if (this.TypeLoadErrorsChanged != null) FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty }); } if (returnType == null && this.localAssembly != null && assemblyName == this.localAssembly.FullName) returnType = this.localAssembly.GetType(typeName); } } } if (returnType == null) { if (throwOnError) throw new Exception(TypeSystemSR.GetString(CultureInfo.CurrentCulture, "Error_TypeResolution", name)); else return null; } // replace the System.Type with RTTypeWrapper for generic types. // WinOE if (this.designTimeTypes != null && this.designTimeTypes.Count > 0 && returnType.Assembly != null && returnType.IsGenericTypeDefinition) { if (this.hashOfRTTypes.Contains(returnType)) { returnType = (Type)this.hashOfRTTypes[returnType]; } else { Type returnType2 = new RTTypeWrapper(this, returnType); this.hashOfRTTypes.Add(returnType, returnType2); returnType = returnType2; } } return returnType; }
public RTConstructorInfoWrapper(RTTypeWrapper rtTypeWrapper, ConstructorInfo ctorInfo) { this.rtTypeWrapper = rtTypeWrapper; this.ctorInfo = ctorInfo; }
public RTFieldInfoWrapper(RTTypeWrapper rtTypeWrapper, FieldInfo fieldInfo) { this.rtTypeWrapper = rtTypeWrapper; this.fieldInfo = fieldInfo; }
public override Type MakeGenericType(params Type[] typeArgs) { if (typeArgs == null) throw new ArgumentNullException("typeArgs"); Type[] types = new Type[typeArgs.Length]; if (!IsGenericTypeDefinition) throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "typeArgs"); for (int i = 0; i < typeArgs.Length; i++) { types[i] = typeArgs[i]; if (types[i] == null) throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "typeArgs"); } Type returnType = this.boundedTypes[typeArgs] as Type; if (returnType == null) { // handle Nullable<T> specially if ((typeArgs.Length == 1) && (this.runtimeType == typeof(Nullable<>)) && !(typeArgs[0].IsEnum)) { switch (Type.GetTypeCode(typeArgs[0])) { case TypeCode.Boolean: returnType = typeof(bool?); break; case TypeCode.Byte: returnType = typeof(byte?); break; case TypeCode.Char: returnType = typeof(char?); break; case TypeCode.DateTime: returnType = typeof(DateTime?); break; case TypeCode.Decimal: returnType = typeof(decimal?); break; case TypeCode.Double: returnType = typeof(double?); break; case TypeCode.Int16: returnType = typeof(short?); break; case TypeCode.Int32: returnType = typeof(int?); break; case TypeCode.Int64: returnType = typeof(long?); break; case TypeCode.SByte: returnType = typeof(sbyte?); break; case TypeCode.Single: returnType = typeof(float?); break; case TypeCode.UInt16: returnType = typeof(ushort?); break; case TypeCode.UInt32: returnType = typeof(uint?); break; case TypeCode.UInt64: returnType = typeof(ulong?); break; default: // no special handling, so make it as usual returnType = new RTTypeWrapper(this.typeProvider, this.runtimeType, typeArgs); break; } } else { returnType = new RTTypeWrapper(this.typeProvider, this.runtimeType, typeArgs); } this.boundedTypes[typeArgs] = returnType; } return returnType; }
public RTParameterInfoWrapper(RTTypeWrapper rtTypeWrapper, MemberInfo parentMember, ParameterInfo paramInfo) { this.parentMember = parentMember; this.rtTypeWrapper = rtTypeWrapper; this.paramInfo = paramInfo; }
public RTEventInfoWrapper(RTTypeWrapper rtTypeWrapper, EventInfo eventInfo) { this.rtTypeWrapper = rtTypeWrapper; this.eventInfo = eventInfo; }
public RTMethodInfoWrapper(RTTypeWrapper rtTypeWrapper, MethodInfo methodInfo) { this.rtTypeWrapper = rtTypeWrapper; this.methodInfo = methodInfo; }
public override Type MakeGenericType(params Type[] typeArgs) { if (typeArgs == null) { throw new ArgumentNullException("typeArgs"); } Type[] typeArray = new Type[typeArgs.Length]; if (!this.IsGenericTypeDefinition) { throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "typeArgs"); } for (int i = 0; i < typeArgs.Length; i++) { typeArray[i] = typeArgs[i]; if (typeArray[i] == null) { throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "typeArgs"); } } Type type = this.boundedTypes[typeArgs] as Type; if (type != null) { return type; } if (((typeArgs.Length == 1) && (this.runtimeType == typeof(Nullable<>))) && !typeArgs[0].IsEnum) { switch (Type.GetTypeCode(typeArgs[0])) { case TypeCode.Boolean: type = typeof(bool?); goto Label_01F7; case TypeCode.Char: type = typeof(char?); goto Label_01F7; case TypeCode.SByte: type = typeof(sbyte?); goto Label_01F7; case TypeCode.Byte: type = typeof(byte?); goto Label_01F7; case TypeCode.Int16: type = typeof(short?); goto Label_01F7; case TypeCode.UInt16: type = typeof(ushort?); goto Label_01F7; case TypeCode.Int32: type = typeof(int?); goto Label_01F7; case TypeCode.UInt32: type = typeof(uint?); goto Label_01F7; case TypeCode.Int64: type = typeof(long?); goto Label_01F7; case TypeCode.UInt64: type = typeof(ulong?); goto Label_01F7; case TypeCode.Single: type = typeof(float?); goto Label_01F7; case TypeCode.Double: type = typeof(double?); goto Label_01F7; case TypeCode.Decimal: type = typeof(decimal?); goto Label_01F7; case TypeCode.DateTime: type = typeof(DateTime?); goto Label_01F7; } type = new RTTypeWrapper(this.typeProvider, this.runtimeType, typeArgs); } else { type = new RTTypeWrapper(this.typeProvider, this.runtimeType, typeArgs); } Label_01F7: this.boundedTypes[typeArgs] = type; return type; }