/// <summary> /// Gets a list of all types inside the <see cref="AppDomain"/>. /// </summary> /// <param name="appDomain">The app domain.</param> /// <returns>List of types found in the <see cref="AppDomain"/>.</returns> /// <remarks> /// This class must only be used by Catel. To make sure that an application performs, make sure to use /// <see cref="TypeCache.GetTypes()"/> instead. /// </remarks> internal static Type[] GetTypes(this AppDomain appDomain) { Argument.IsNotNull("appDomain", appDomain); List <Assembly> assemblies = AssemblyHelper.GetLoadedAssemblies(appDomain); var types = new List <Type>(); foreach (var assembly in assemblies) { types.AddRange(from assemblyType in AssemblyHelper.GetAllTypesSafely(assembly) select assemblyType); } return(types.ToArray()); }
/// <summary> /// Initializes the types. It does this by looping through all loaded assemblies and /// registering the type by type name and assembly name. /// <para/> /// The types initialized by this method are used by <see cref="object.GetType"/>. /// </summary> /// <param name="assemblyName">Name of the assembly. If <c>null</c>, all assemblies will be checked.</param> /// <param name="forceFullInitialization">If <c>true</c>, the types are initialized, even when the types are already initialized.</param> /// <param name="allowMultithreadedInitialization">If <c>true</c>, allow multithreaded initialization.</param> /// <exception cref="ArgumentException">The <paramref name="assemblyName"/> is <c>null</c> or whitespace.</exception> public static void InitializeTypes(string assemblyName, bool forceFullInitialization, bool allowMultithreadedInitialization = false) { // Important note: only allow explicit multithreaded initialization Argument.IsNotNullOrWhitespace("assemblyName", assemblyName); lock (_lockObject) { if (_loadedAssemblies.Any(x => { var assemblyNameWithoutVersion = TypeHelper.GetAssemblyNameWithoutOverhead(x); if (string.Equals(assemblyNameWithoutVersion, assemblyName)) { return(true); } return(false); })) { // No need to initialize (or get the loaded assemblies) return; } var loadedAssemblies = AssemblyHelper.GetLoadedAssemblies(); foreach (var assembly in loadedAssemblies) { try { if (assembly.FullName.Contains(assemblyName)) { InitializeTypes(assembly, forceFullInitialization, allowMultithreadedInitialization); } } catch (Exception ex) { Log.Warning(ex, $"Failed to get all types in assembly '{assembly.FullName}'"); } } } }
/// <summary> /// Initializes the types in Silverlight. It does this by looping through all loaded assemblies and /// registering the type by type name and assembly name. /// <para/> /// The types initialized by this method are used by <see cref="object.GetType"/>. /// </summary> /// <param name="forceFullInitialization">If <c>true</c>, the types are initialized, even when the types are already initialized.</param> /// <param name="assemblyName">Name of the assembly. If <c>null</c>, all assemblies will be checked.</param> /// <exception cref="ArgumentException">The <paramref name="assemblyName"/> is <c>null</c> or whitespace.</exception> public static void InitializeTypes(bool forceFullInitialization, string assemblyName) { Argument.IsNotNullOrWhitespace("assemblyName", assemblyName); lock (_lockObject) { foreach (var assembly in AssemblyHelper.GetLoadedAssemblies()) { try { if (assembly.FullName.Contains(assemblyName)) { InitializeTypes(forceFullInitialization, assembly); } } catch (Exception ex) { Log.Warning(ex, "Failed to get all types in assembly '{0}'", assembly.FullName); } } } }
/// <summary> /// Initializes the types in the specified assembly. It does this by looping through all loaded assemblies and /// registering the type by type name and assembly name. /// <para/> /// The types initialized by this method are used by <see cref="object.GetType"/>. /// </summary> /// <param name="forceFullInitialization">If <c>true</c>, the types are initialized, even when the types are already initialized.</param> /// <param name="assembly">The assembly to initialize the types from. If <c>null</c>, all assemblies will be checked.</param> public static void InitializeTypes(bool forceFullInitialization, Assembly assembly = null) { bool checkSingleAssemblyOnly = assembly != null; if (!forceFullInitialization && !checkSingleAssemblyOnly && (_typesWithAssembly != null)) { return; } lock (_lockObject) { if (forceFullInitialization) { _typesWithAssembly.Clear(); _typesWithAssembly = null; _typesWithAssemblyLowerCase.Clear(); _typesWithAssemblyLowerCase = null; _typesWithoutAssembly.Clear(); _typesWithoutAssembly = null; _typesWithoutAssemblyLowerCase.Clear(); _typesWithoutAssemblyLowerCase = null; } if (_typesWithAssembly == null) { _typesWithAssembly = new Dictionary <string, Type>(); } if (_typesWithAssemblyLowerCase == null) { _typesWithAssemblyLowerCase = new Dictionary <string, Type>(); } if (_typesWithoutAssembly == null) { _typesWithoutAssembly = new Dictionary <string, string>(); } if (_typesWithoutAssemblyLowerCase == null) { _typesWithoutAssemblyLowerCase = new Dictionary <string, string>(); } var typesToAdd = new HashSet <Type>(); var assembliesToLoad = new List <Assembly>(); if (assembly != null) { assembliesToLoad.Add(assembly); } else { assembliesToLoad.AddRange(AssemblyHelper.GetLoadedAssemblies()); } foreach (var loadedAssembly in assembliesToLoad) { try { foreach (var type in AssemblyHelper.GetAllTypesSafely(loadedAssembly)) { typesToAdd.Add(type); } } catch (Exception ex) { Log.Warning(ex, "Failed to get all types in assembly '{0}'", loadedAssembly.FullName); } } foreach (var type in typesToAdd) { if (ShouldIgnoreType(type)) { continue; } var newAssemblyName = TypeHelper.GetAssemblyNameWithoutOverhead(type.GetAssemblyFullNameEx()); string newFullType = TypeHelper.FormatType(newAssemblyName, type.FullName); if (!_typesWithAssembly.ContainsKey(newFullType)) { _typesWithAssembly[newFullType] = type; _typesWithAssemblyLowerCase[newFullType.ToLowerInvariant()] = type; var typeNameWithoutAssembly = TypeHelper.GetTypeName(newFullType); _typesWithoutAssembly[typeNameWithoutAssembly] = newFullType; _typesWithoutAssemblyLowerCase[typeNameWithoutAssembly.ToLowerInvariant()] = newFullType.ToLowerInvariant(); } } } }
public static void InitializeTypes(Assembly assembly = null, bool forceFullInitialization = false, bool allowMultithreadedInitialization = false) { // Important note: only allow explicit multithreaded initialization var checkSingleAssemblyOnly = assembly != null; lock (_lockObject) { if (_hasInitializedOnce && !forceFullInitialization && !checkSingleAssemblyOnly) { return; } if (!checkSingleAssemblyOnly) { _hasInitializedOnce = true; } // CTL-877 Only clear when assembly != null if (forceFullInitialization && assembly is null) { _loadedAssemblies.Clear(); _typesByAssembly?.Clear(); _typesWithAssembly?.Clear(); _typesWithAssemblyIgnoreCase?.Clear(); _typesWithoutAssembly?.Clear(); _typesWithoutAssemblyIgnoreCase?.Clear(); } var assembliesToInitialize = checkSingleAssemblyOnly ? (IEnumerable <Assembly>) new [] { assembly } : AssemblyHelper.GetLoadedAssemblies(); InitializeAssemblies(assembliesToInitialize, forceFullInitialization, allowMultithreadedInitialization); } }
/// <summary> /// Initializes the types in the specified assembly. It does this by looping through all loaded assemblies and /// registering the type by type name and assembly name. /// <para/> /// The types initialized by this method are used by <see cref="object.GetType"/>. /// </summary> /// <param name="assembly">The assembly to initialize the types from. If <c>null</c>, all assemblies will be checked.</param> /// <param name="forceFullInitialization">If <c>true</c>, the types are initialized, even when the types are already initialized.</param> public static void InitializeTypes(Assembly assembly = null, bool forceFullInitialization = false) { bool checkSingleAssemblyOnly = assembly != null; if (!forceFullInitialization && !checkSingleAssemblyOnly && (_typesWithAssembly != null)) { return; } lock (_lockObject) { // CTL-877 Only clear when assembly != null if (forceFullInitialization && assembly == null) { _loadedAssemblies.Clear(); if (_typesByAssembly != null) { _typesByAssembly.Clear(); _typesByAssembly = null; } if (_typesWithAssembly != null) { _typesWithAssembly.Clear(); _typesWithAssembly = null; } if (_typesWithAssemblyLowerCase != null) { _typesWithAssemblyLowerCase.Clear(); _typesWithAssemblyLowerCase = null; } if (_typesWithoutAssembly != null) { _typesWithoutAssembly.Clear(); _typesWithoutAssembly = null; } if (_typesWithoutAssemblyLowerCase != null) { _typesWithoutAssemblyLowerCase.Clear(); _typesWithoutAssemblyLowerCase = null; } } if (_typesByAssembly == null) { _typesByAssembly = new Dictionary <string, Dictionary <string, Type> >(); } if (_typesWithAssembly == null) { _typesWithAssembly = new Dictionary <string, Type>(); } if (_typesWithAssemblyLowerCase == null) { _typesWithAssemblyLowerCase = new Dictionary <string, Type>(); } if (_typesWithoutAssembly == null) { _typesWithoutAssembly = new Dictionary <string, string>(); } if (_typesWithoutAssemblyLowerCase == null) { _typesWithoutAssemblyLowerCase = new Dictionary <string, string>(); } var assembliesToInitialize = checkSingleAssemblyOnly ? new List <Assembly>(new[] { assembly }) : AssemblyHelper.GetLoadedAssemblies(); InitializeAssemblies(assembliesToInitialize, forceFullInitialization); } }
/// <summary> /// Initializes the types in the specified assembly. It does this by looping through all loaded assemblies and /// registering the type by type name and assembly name. /// <para/> /// The types initialized by this method are used by <see cref="object.GetType"/>. /// </summary> /// <param name="assembly">The assembly to initialize the types from. If <c>null</c>, all assemblies will be checked.</param> /// <param name="forceFullInitialization">If <c>true</c>, the types are initialized, even when the types are already initialized.</param> public static void InitializeTypes(Assembly assembly = null, bool forceFullInitialization = false) { var checkSingleAssemblyOnly = assembly != null; if (!forceFullInitialization && !checkSingleAssemblyOnly && _typesWithAssembly.Count > 0) { return; } lock (_lockObject) { // CTL-877 Only clear when assembly != null if (forceFullInitialization && assembly == null) { _loadedAssemblies.Clear(); _typesByAssembly?.Clear(); _typesWithAssembly?.Clear(); _typesWithAssemblyLowerCase?.Clear(); _typesWithoutAssembly?.Clear(); _typesWithoutAssemblyLowerCase?.Clear(); } var assembliesToInitialize = checkSingleAssemblyOnly ? new List <Assembly>(new[] { assembly }) : AssemblyHelper.GetLoadedAssemblies(); InitializeAssemblies(assembliesToInitialize, forceFullInitialization); } }