// This function could be re-entrant, so I have kept the flag to make it non-reentrant
// I had one call stack in whcih ----eblyLoader.GetTypes() called ServiceProvider.GetService()for which
// some one did Marshal.GetObjectForIUnknown() which caused the message pump to be executed
// which caused EnsureCurrentTypes to be called once again.
private void EnsureCurrentTypes()
{
if (this.executingEnsureCurrentTypes)
{
return;
}
try
{
bool hasTypeLoadErrors = false;
this.executingEnsureCurrentTypes = true;
if (this.addedAssemblies != null)
{
// cache it to local variable
string[] addedAssemblies2 = this.addedAssemblies.ToArray();
this.addedAssemblies = null;
foreach (string path in addedAssemblies2)
{
AssemblyLoader loader = null;
try
{
loader = new AssemblyLoader(this, path);
this.assemblyLoaders[path] = loader;
}
catch (Exception e)
{
this.typeLoadErrors[path] = e;
hasTypeLoadErrors = true;
}
}
}
if (this.addedCompileUnits != null)
{
// cache it to local variable
CodeCompileUnit[] addedCompileUnits2 = this.addedCompileUnits.ToArray();
this.addedCompileUnits = null;
foreach (CodeCompileUnit codeCompileUnit in addedCompileUnits2)
{
CodeDomLoader loader = null;
try
{
loader = new CodeDomLoader(this, codeCompileUnit);
this.compileUnitLoaders[codeCompileUnit] = loader;
}
catch (Exception e)
{
// this will cause it to remove types
if (loader != null)
{
loader.Dispose();
}
this.typeLoadErrors[codeCompileUnit] = e;
hasTypeLoadErrors = true;
}
}
}
if (this.needRefreshCompileUnits != null)
{
// cache it to local variable
Dictionary <CodeCompileUnit, EventHandler> needRefreshCompileUnits2 = new Dictionary <CodeCompileUnit, EventHandler>();
foreach (KeyValuePair <CodeCompileUnit, EventHandler> entry in this.needRefreshCompileUnits)
{
needRefreshCompileUnits2.Add(entry.Key, entry.Value);
}
this.needRefreshCompileUnits = null;
foreach (KeyValuePair <CodeCompileUnit, EventHandler> entry in needRefreshCompileUnits2)
{
CodeDomLoader codeDomLoader = this.compileUnitLoaders[entry.Key] as CodeDomLoader;
Debug.Assert(codeDomLoader != null, "How come we don't have CodeDOMLoader for the guy who needs refresh?");
if (codeDomLoader != null)
{
try
{
codeDomLoader.Refresh(entry.Value);
}
catch (Exception e)
{
this.typeLoadErrors[entry.Value] = e;
hasTypeLoadErrors = true;
}
}
}
}
if (hasTypeLoadErrors)
{
if (this.TypeLoadErrorsChanged != null)
{
FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
}
}
}
finally
{
this.executingEnsureCurrentTypes = false;
}
}
public Type[] GetTypes()
{
EnsureCurrentTypes();
bool hasTypeLoadErrors = false;
this.typeLoadErrors.Clear(); //clear all old errors
List <Type> typeList = new List <Type>();
// Design time types
foreach (Type type in this.designTimeTypes.Values)
{
typeList.Add(type);
}
foreach (DictionaryEntry dictionaryEntry in this.assemblyLoaders)
{
AssemblyLoader assemblyLoader = dictionaryEntry.Value as AssemblyLoader;
try
{
typeList.AddRange(assemblyLoader.GetTypes());
}
catch (Exception e)
{
ReflectionTypeLoadException typeLoadException = e as ReflectionTypeLoadException;
if (typeLoadException != null)
{
//we should at least add the types that did get loaded
foreach (Type type in typeLoadException.Types)
{
if (type != null)
{
typeList.Add(type);
}
}
}
//we should have the latest exception for every assembly (user might have copied required dlls over)
if (this.typeLoadErrors.Contains(dictionaryEntry.Key))
{
this.typeLoadErrors.Remove(dictionaryEntry.Key);
}
this.typeLoadErrors[dictionaryEntry.Key] = e;
hasTypeLoadErrors = true;
}
}
foreach (DictionaryEntry dictionaryEntry in this.rawAssemblyLoaders)
{
AssemblyLoader assemblyLoader = dictionaryEntry.Value as AssemblyLoader;
try
{
typeList.AddRange(assemblyLoader.GetTypes());
}
catch (Exception e)
{
ReflectionTypeLoadException typeLoadException = e as ReflectionTypeLoadException;
if (typeLoadException != null)
{
//we should at least add the types that did get loaded
foreach (Type type in typeLoadException.Types)
{
if (type != null)
{
typeList.Add(type);
}
}
}
//we should have the latest exception for every assembly (user might have copied required dlls over)
if (this.typeLoadErrors.Contains(dictionaryEntry.Key))
{
this.typeLoadErrors.Remove(dictionaryEntry.Key);
}
this.typeLoadErrors[dictionaryEntry.Key] = e;
hasTypeLoadErrors = true;
}
}
if (hasTypeLoadErrors)
{
if (this.TypeLoadErrorsChanged != null)
{
FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
}
}
return(typeList.ToArray());
}
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 Type[] GetTypes()
{
this.EnsureCurrentTypes();
bool flag = false;
this.typeLoadErrors.Clear();
List <Type> list = new List <Type>();
foreach (Type type in this.designTimeTypes.Values)
{
list.Add(type);
}
foreach (DictionaryEntry entry in this.assemblyLoaders)
{
AssemblyLoader loader = entry.Value as AssemblyLoader;
try
{
list.AddRange(loader.GetTypes());
}
catch (Exception exception)
{
ReflectionTypeLoadException exception2 = exception as ReflectionTypeLoadException;
if (exception2 != null)
{
foreach (Type type2 in exception2.Types)
{
if (type2 != null)
{
list.Add(type2);
}
}
}
if (this.typeLoadErrors.Contains(entry.Key))
{
this.typeLoadErrors.Remove(entry.Key);
}
this.typeLoadErrors[entry.Key] = exception;
flag = true;
}
}
foreach (DictionaryEntry entry2 in this.rawAssemblyLoaders)
{
AssemblyLoader loader2 = entry2.Value as AssemblyLoader;
try
{
list.AddRange(loader2.GetTypes());
}
catch (Exception exception3)
{
ReflectionTypeLoadException exception4 = exception3 as ReflectionTypeLoadException;
if (exception4 != null)
{
foreach (Type type3 in exception4.Types)
{
if (type3 != null)
{
list.Add(type3);
}
}
}
if (this.typeLoadErrors.Contains(entry2.Key))
{
this.typeLoadErrors.Remove(entry2.Key);
}
this.typeLoadErrors[entry2.Key] = exception3;
flag = true;
}
}
if (flag && (this.TypeLoadErrorsChanged != null))
{
FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
}
return(list.ToArray());
}
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);
}
private void EnsureCurrentTypes()
{
if (!this.executingEnsureCurrentTypes)
{
try
{
bool flag = false;
this.executingEnsureCurrentTypes = true;
if (this.addedAssemblies != null)
{
string[] strArray = this.addedAssemblies.ToArray();
this.addedAssemblies = null;
foreach (string str in strArray)
{
AssemblyLoader loader = null;
try
{
loader = new AssemblyLoader(this, str);
this.assemblyLoaders[str] = loader;
}
catch (Exception exception)
{
this.typeLoadErrors[str] = exception;
flag = true;
}
}
}
if (this.addedCompileUnits != null)
{
CodeCompileUnit[] unitArray = this.addedCompileUnits.ToArray();
this.addedCompileUnits = null;
foreach (CodeCompileUnit unit in unitArray)
{
CodeDomLoader loader2 = null;
try
{
loader2 = new CodeDomLoader(this, unit);
this.compileUnitLoaders[unit] = loader2;
}
catch (Exception exception2)
{
if (loader2 != null)
{
loader2.Dispose();
}
this.typeLoadErrors[unit] = exception2;
flag = true;
}
}
}
if (this.needRefreshCompileUnits != null)
{
Dictionary <CodeCompileUnit, EventHandler> dictionary = new Dictionary <CodeCompileUnit, EventHandler>();
foreach (KeyValuePair <CodeCompileUnit, EventHandler> pair in this.needRefreshCompileUnits)
{
dictionary.Add(pair.Key, pair.Value);
}
this.needRefreshCompileUnits = null;
foreach (KeyValuePair <CodeCompileUnit, EventHandler> pair2 in dictionary)
{
CodeDomLoader loader3 = this.compileUnitLoaders[pair2.Key] as CodeDomLoader;
if (loader3 != null)
{
try
{
loader3.Refresh(pair2.Value);
}
catch (Exception exception3)
{
this.typeLoadErrors[pair2.Value] = exception3;
flag = true;
}
}
}
}
if (flag && (this.TypeLoadErrorsChanged != null))
{
FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
}
}
finally
{
this.executingEnsureCurrentTypes = false;
}
}
}
