// 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; } } }