private Assembly ResolveAssembly(string name)
{
if (this.resolving)
{
return(null);
}
// First look for the local assembly.
if (this.localAssembly != null && name == this.localAssembly.FullName)
{
return(this.localAssembly);
}
try
{
this.resolving = true;
AssemblyName assemblyName = new AssemblyName(name);
// Then try the referenced assemblies.
foreach (string assemblyPath in this.referencedAssemblies)
{
try
{
AssemblyName referenceAssemblyName = AssemblyName.GetAssemblyName(assemblyPath);
if (referenceAssemblyName != null && ParseHelpers.AssemblyNameEquals(referenceAssemblyName, assemblyName))
{
Assembly reference = null;
try
{
reference = Assembly.Load(referenceAssemblyName);
}
catch
{
reference = Assembly.LoadFrom(assemblyPath);
}
return(reference);
}
}
catch
{
// Eat up any exceptions!
}
}
}
finally
{
this.resolving = false;
}
return(null);
}
private Assembly ResolveAssembly(string name)
{
if (!this.resolving)
{
if ((this.localAssembly != null) && (name == this.localAssembly.FullName))
{
return(this.localAssembly);
}
try
{
this.resolving = true;
AssemblyName thatName = new AssemblyName(name);
foreach (string str in this.referencedAssemblies)
{
try
{
AssemblyName assemblyName = AssemblyName.GetAssemblyName(str);
if ((assemblyName != null) && ParseHelpers.AssemblyNameEquals(assemblyName, thatName))
{
try
{
return(Assembly.Load(assemblyName));
}
catch
{
return(Assembly.LoadFrom(str));
}
}
}
catch
{
}
}
}
finally
{
this.resolving = false;
}
}
return(null);
}
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);
}
internal static string FormatType(string type, SupportedLanguages language)
{
string formattedType = string.Empty;
string[] genericParamTypeNames = null;
string baseTypeName = string.Empty;
string elementDecorators = string.Empty;
if (ParseHelpers.ParseTypeName(type, ParseHelpers.ParseTypeNameLanguage.NetFramework, out baseTypeName, out genericParamTypeNames, out elementDecorators))
{
if (elementDecorators.Length > 0)
{
// VB uses '()' for arrays
if (language == SupportedLanguages.VB)
{
elementDecorators = elementDecorators.Replace('[', '(').Replace(']', ')');
}
formattedType = FormatType(baseTypeName, language) + elementDecorators;
}
else if (genericParamTypeNames != null && genericParamTypeNames.Length > 0)
{
// add generic type
formattedType = FormatType(baseTypeName, language);
// add generic arguments
if (language == SupportedLanguages.CSharp)
{
formattedType += '<';
}
else
{
formattedType += '(';
}
bool first = true;
foreach (string genericArgument in genericParamTypeNames)
{
if (!first)
{
formattedType += ", ";
}
else
{
if (language == SupportedLanguages.VB)
{
formattedType += "Of ";
}
first = false;
}
formattedType += FormatType(genericArgument, language);
}
if (language == SupportedLanguages.CSharp)
{
formattedType += '>';
}
else
{
formattedType += ')';
}
}
else
{
// non generic, non decorated type - simple cleanup
formattedType = baseTypeName.Replace('+', '.');
int indexOfSpecialChar = formattedType.IndexOf('`');
if (indexOfSpecialChar != -1)
{
formattedType = formattedType.Substring(0, indexOfSpecialChar);
}
indexOfSpecialChar = formattedType.IndexOf(',');
if (indexOfSpecialChar != -1)
{
formattedType = formattedType.Substring(0, indexOfSpecialChar);
}
}
}
return(formattedType);
}
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 object GetArgumentValueAs(IServiceProvider serviceProvider, int argumentIndex, Type requestedType)
{
if ((argumentIndex >= this.ArgumentValues.Count) || (argumentIndex < 0))
{
throw new ArgumentException(SR.GetString("Error_InvalidArgumentIndex"), "argumentIndex");
}
if (requestedType == null)
{
throw new ArgumentNullException("requestedType");
}
SupportedLanguages supportedLanguage = CompilerHelpers.GetSupportedLanguage(serviceProvider);
if (requestedType == typeof(string))
{
string str = this.ArgumentValues[argumentIndex] as string;
if (str != null)
{
try
{
str = Regex.Unescape(str);
}
catch
{
}
}
if (str != null)
{
if (str.EndsWith("\"", StringComparison.Ordinal))
{
str = str.Substring(0, str.Length - 1);
}
if ((supportedLanguage == SupportedLanguages.CSharp) && str.StartsWith("@\"", StringComparison.Ordinal))
{
return(str.Substring(2, str.Length - 2));
}
if (str.StartsWith("\"", StringComparison.Ordinal))
{
str = str.Substring(1, str.Length - 1);
}
}
return(str);
}
if (requestedType.IsEnum)
{
string str2 = "";
bool flag = true;
foreach (string str3 in (this.ArgumentValues[argumentIndex] as string).Split(new string[] { (supportedLanguage == SupportedLanguages.CSharp) ? "|" : "Or" }, StringSplitOptions.RemoveEmptyEntries))
{
if (!flag)
{
str2 = str2 + ",";
}
int num = str3.LastIndexOf('.');
if (num != -1)
{
str2 = str2 + str3.Substring(num + 1);
}
else
{
str2 = str2 + str3;
}
flag = false;
}
return(Enum.Parse(requestedType, str2));
}
if (requestedType == typeof(bool))
{
return(Convert.ToBoolean(this.ArgumentValues[argumentIndex], CultureInfo.InvariantCulture));
}
if (!(requestedType == typeof(Type)))
{
return(null);
}
string typeName = "";
if (this.ArgumentValues[argumentIndex] is CodeTypeOfExpression)
{
typeName = DesignTimeType.GetTypeNameFromCodeTypeReference((this.ArgumentValues[argumentIndex] as CodeTypeOfExpression).Type, null);
}
ITypeProvider service = serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (service == null)
{
throw new Exception(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).ToString() }));
}
Type type = ParseHelpers.ParseTypeName(service, supportedLanguage, typeName);
if (type != null)
{
return(type);
}
string[] parameters = null;
string str5 = string.Empty;
string elemantDecorator = string.Empty;
if ((!ParseHelpers.ParseTypeName(typeName, (supportedLanguage == SupportedLanguages.CSharp) ? ParseHelpers.ParseTypeNameLanguage.CSharp : ParseHelpers.ParseTypeNameLanguage.VB, out str5, out parameters, out elemantDecorator) || (str5 == null)) || (parameters == null))
{
return(type);
}
string str7 = str5 + "`" + parameters.Length.ToString(CultureInfo.InvariantCulture) + "[";
foreach (string str8 in parameters)
{
if (str8 != parameters[0])
{
str7 = str7 + ",";
}
Type type2 = ParseHelpers.ParseTypeName(service, supportedLanguage, str8);
if (type2 != null)
{
str7 = str7 + "[" + type2.FullName + "]";
}
else
{
str7 = str7 + "[" + str8 + "]";
}
}
str7 = str7 + "]";
return(ParseHelpers.ParseTypeName(service, supportedLanguage, str7));
}
public object GetArgumentValueAs(IServiceProvider serviceProvider, int argumentIndex, Type requestedType)
{
if (argumentIndex >= this.ArgumentValues.Count || argumentIndex < 0)
{
throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentIndex), "argumentIndex");
}
if (requestedType == null)
{
throw new ArgumentNullException("requestedType");
}
SupportedLanguages language = CompilerHelpers.GetSupportedLanguage(serviceProvider);
if (requestedType == typeof(string))
{
string returnValue = this.ArgumentValues[argumentIndex] as string;
// string values read by the code-dom parser are double escaped, so
// remove the 2nd escaping (we need to leave the escaping in at parse time)
// in case the attribute argument is never processed and emitted as
// the code snippet
if (returnValue != null)
{
try
{
returnValue = Regex.Unescape(returnValue);
}
catch
{
}
}
if (returnValue != null)
{
if (returnValue.EndsWith("\"", StringComparison.Ordinal))
{
returnValue = returnValue.Substring(0, returnValue.Length - 1);
}
if (language == SupportedLanguages.CSharp && returnValue.StartsWith("@\"", StringComparison.Ordinal))
{
returnValue = returnValue.Substring(2, returnValue.Length - 2);
}
else if (returnValue.StartsWith("\"", StringComparison.Ordinal))
{
returnValue = returnValue.Substring(1, returnValue.Length - 1);
}
}
return(returnValue);
}
else if (requestedType.IsEnum)
{
string parseableValue = "";
bool firstValue = true;
foreach (string enumValue in (this.ArgumentValues[argumentIndex] as string).Split(new string[] { language == SupportedLanguages.CSharp ? "|" : "Or" }, StringSplitOptions.RemoveEmptyEntries))
{
if (!firstValue)
{
parseableValue += ",";
}
int valueSep = enumValue.LastIndexOf('.');
if (valueSep != -1)
{
parseableValue += enumValue.Substring(valueSep + 1);
}
else
{
parseableValue += enumValue;
}
firstValue = false;
}
return(Enum.Parse(requestedType, parseableValue));
}
else if (requestedType == typeof(bool))
{
return(System.Convert.ToBoolean(this.ArgumentValues[argumentIndex], CultureInfo.InvariantCulture));
}
else if (requestedType == typeof(Type))
{
string typeName = "";
if (this.ArgumentValues[argumentIndex] is CodeTypeOfExpression)
{
typeName = DesignTimeType.GetTypeNameFromCodeTypeReference((this.ArgumentValues[argumentIndex] as CodeTypeOfExpression).Type, null);
}
ITypeProvider typeProvider = serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (typeProvider == null)
{
throw new Exception(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).ToString()));
}
Type returnType = ParseHelpers.ParseTypeName(typeProvider, language, typeName);
if (returnType == null)
{
// Try to parse the attribute value manually
string[] genericParamTypeNames = null;
string baseTypeName = string.Empty;
string elementDecorators = string.Empty;
if (ParseHelpers.ParseTypeName(typeName, language == SupportedLanguages.CSharp ? ParseHelpers.ParseTypeNameLanguage.CSharp : ParseHelpers.ParseTypeNameLanguage.VB, out baseTypeName, out genericParamTypeNames, out elementDecorators))
{
if (baseTypeName != null && genericParamTypeNames != null)
{
string parsedTypeName = baseTypeName + "`" + genericParamTypeNames.Length.ToString(CultureInfo.InvariantCulture) + "[";
foreach (string genericArg in genericParamTypeNames)
{
if (genericArg != genericParamTypeNames[0])
{
parsedTypeName += ",";
}
Type genericArgType = ParseHelpers.ParseTypeName(typeProvider, language, genericArg);
if (genericArgType != null)
{
parsedTypeName += "[" + genericArgType.FullName + "]";
}
else
{
parsedTypeName += "[" + genericArg + "]";
}
}
parsedTypeName += "]";
returnType = ParseHelpers.ParseTypeName(typeProvider, language, parsedTypeName);
}
}
}
return(returnType);
}
return(null);
}
