/// <summary> /// Load an assembly given its AssemblyLoadInfo /// </summary> /// <param name="assemblyLoadInfo"></param> /// <returns></returns> private static Assembly LoadAssembly(AssemblyLoadInfo assemblyLoadInfo) { Assembly loadedAssembly = null; try { if (assemblyLoadInfo.AssemblyName != null) { #if !FEATURE_ASSEMBLYLOADCONTEXT loadedAssembly = Assembly.Load(assemblyLoadInfo.AssemblyName); #else loadedAssembly = Assembly.Load(new AssemblyName(assemblyLoadInfo.AssemblyName)); #endif } else { #if !FEATURE_ASSEMBLYLOADCONTEXT loadedAssembly = Assembly.UnsafeLoadFrom(assemblyLoadInfo.AssemblyFile); #else loadedAssembly = s_coreClrAssemblyLoader.LoadFromPath(assemblyLoadInfo.AssemblyFile); #endif } } catch (ArgumentException e) { // Assembly.Load() and Assembly.LoadFrom() will throw an ArgumentException if the assembly name is invalid // convert to a FileNotFoundException because it's more meaningful // NOTE: don't use ErrorUtilities.VerifyThrowFileExists() here because that will hit the disk again throw new FileNotFoundException(null, assemblyLoadInfo.AssemblyLocation, e); } return(loadedAssembly); }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> /// <returns>The loaded type, or null if the type was not found.</returns> internal LoadedType ReflectionOnlyLoad ( string typeName, AssemblyLoadInfo assembly ) { return(GetLoadedType(s_cacheOfReflectionOnlyLoadedTypesByFilter, typeName, assembly)); }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> internal LoadedType Load ( string typeName, AssemblyLoadInfo assembly ) { return(GetLoadedType(s_cacheOfLoadedTypesByFilterLock, s_loadInfoToTypeLock, s_cacheOfLoadedTypesByFilter, typeName, assembly)); }
/// <summary> /// Given a type filter, and an assembly to load the type information from determine if a given type name is in the assembly or not. /// </summary> internal AssemblyInfoToLoadedTypes(Func <Type, object, bool> typeFilter, AssemblyLoadInfo loadInfo) { ErrorUtilities.VerifyThrowArgumentNull(typeFilter, "typefilter"); ErrorUtilities.VerifyThrowArgumentNull(loadInfo, "loadInfo"); _isDesiredType = typeFilter; _assemblyLoadInfo = loadInfo; _typeNameToType = new ConcurrentDictionary <string, Type>(StringComparer.OrdinalIgnoreCase); _publicTypeNameToType = new Dictionary <string, Type>(StringComparer.OrdinalIgnoreCase); }
/// <summary> /// Given a type filter, and an assembly to load the type information from determine if a given type name is in the assembly or not. /// </summary> internal AssemblyInfoToLoadedTypes(TypeFilter typeFilter, AssemblyLoadInfo loadInfo) { ErrorUtilities.VerifyThrowArgumentNull(typeFilter, "typefilter"); ErrorUtilities.VerifyThrowArgumentNull(loadInfo, "loadInfo"); this.isDesiredType = typeFilter; this.assemblyLoadInfo = loadInfo; this.typeNameToType = new Dictionary <string, Type>(StringComparer.OrdinalIgnoreCase); this.publicTypeNameToType = new Dictionary <string, Type>(StringComparer.OrdinalIgnoreCase); }
/// <summary> /// Creates an instance of this class for the given type. /// </summary> /// <param name="type">The Type to be loaded</param> /// <param name="assemblyLoadInfo">Information used to load the assembly</param> /// <param name="loadedAssembly">The assembly which has been loaded, if any</param> internal LoadedType(Type type, AssemblyLoadInfo assemblyLoadInfo, Assembly loadedAssembly) { ErrorUtilities.VerifyThrow(type != null, "We must have the type."); ErrorUtilities.VerifyThrow(assemblyLoadInfo != null, "We must have the assembly the type was loaded from."); _type = type; _assembly = assemblyLoadInfo; _loadedAssembly = loadedAssembly; CheckForHardcodedSTARequirement(); HasLoadInSeparateAppDomainAttribute(); HasSTAThreadAttribute(); }
/// <summary> /// Load an assembly given its AssemblyLoadInfo /// </summary> /// <param name="assemblyLoadInfo"></param> /// <returns></returns> private static Assembly LoadAssembly(AssemblyLoadInfo assemblyLoadInfo) { Assembly loadedAssembly = null; try { if (assemblyLoadInfo.AssemblyName != null) { #if FEATURE_ASSEMBLY_LOADFROM loadedAssembly = Assembly.Load(assemblyLoadInfo.AssemblyName); #else loadedAssembly = Assembly.Load(new AssemblyName(assemblyLoadInfo.AssemblyName)); #endif } else { #if FEATURE_ASSEMBLY_LOADFROM loadedAssembly = Assembly.UnsafeLoadFrom(assemblyLoadInfo.AssemblyFile); #else // If the Assembly is provided via a file path, the following rules are used to load the assembly: // - if the simple name of the assembly exists in the same folder as msbuild.exe, then that assembly gets loaded, indifferent of the user specified path // - otherwise, the assembly from the user specified path is loaded, if it exists. var assemblyNameInExecutableDirectory = Path.Combine(BuildEnvironmentHelper.Instance.CurrentMSBuildToolsDirectory, Path.GetFileName(assemblyLoadInfo.AssemblyFile)); if (FileSystems.Default.FileExists(assemblyNameInExecutableDirectory)) { var simpleName = Path.GetFileNameWithoutExtension(assemblyLoadInfo.AssemblyFile); loadedAssembly = Assembly.Load(new AssemblyName(simpleName)); } else { var baseDir = Path.GetDirectoryName(assemblyLoadInfo.AssemblyFile); s_coreClrAssemblyLoader.AddDependencyLocation(baseDir); loadedAssembly = s_coreClrAssemblyLoader.LoadFromPath(assemblyLoadInfo.AssemblyFile); } #endif } } catch (ArgumentException e) { // Assembly.Load() and Assembly.LoadFrom() will throw an ArgumentException if the assembly name is invalid // convert to a FileNotFoundException because it's more meaningful // NOTE: don't use ErrorUtilities.VerifyThrowFileExists() here because that will hit the disk again throw new FileNotFoundException(null, assemblyLoadInfo.AssemblyLocation, e); } return(loadedAssembly); }
/// <summary> /// Determines if two AssemblyLoadInfos are effectively the same. /// </summary> public override bool Equals(Object obj) { if (obj == null) { return(false); } AssemblyLoadInfo otherAssemblyInfo = obj as AssemblyLoadInfo; if (otherAssemblyInfo == null) { return(false); } return((this.AssemblyName == otherAssemblyInfo.AssemblyName) && (this.AssemblyFile == otherAssemblyInfo.AssemblyFile)); }
internal void CreateFromStream(BinaryReader reader) { #region LoggerClassName if (reader.ReadByte() == 0) { _loggerClassName = null; } else { _loggerClassName = reader.ReadString(); } #endregion #region LoggerSwitchParameters if (reader.ReadByte() == 0) { _loggerSwitchParameters = null; } else { _loggerSwitchParameters = reader.ReadString(); } #endregion #region LoggerAssembly if (reader.ReadByte() == 0) { _loggerAssembly = null; } else { string assemblyName = null; string assemblyFile = null; if (reader.ReadByte() != 0) { assemblyFile = reader.ReadString(); } if (reader.ReadByte() != 0) { assemblyName = reader.ReadString(); } _loggerAssembly = AssemblyLoadInfo.Create(assemblyName, assemblyFile); } #endregion _verbosity = (LoggerVerbosity)reader.ReadInt32(); _loggerId = reader.ReadInt32(); }
/// <summary> /// Creates an instance of this class for the given type. /// </summary> internal LoadedType(Type type, AssemblyLoadInfo assemblyLoadInfo) : this(type, assemblyLoadInfo, null) { }
/// <summary> /// Given a type filter, and an assembly to load the type information from determine if a given type name is in the assembly or not. /// </summary> internal AssemblyInfoToLoadedTypes(TypeFilter typeFilter, AssemblyLoadInfo loadInfo) { ErrorUtilities.VerifyThrowArgumentNull(typeFilter, "typefilter"); ErrorUtilities.VerifyThrowArgumentNull(loadInfo, "loadInfo"); _isDesiredType = typeFilter; _assemblyLoadInfo = loadInfo; _typeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase); _publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase); }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> private LoadedType GetLoadedType(object cacheLock, object loadInfoToTypeLock, ConcurrentDictionary<TypeFilter, ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes>> cache, string typeName, AssemblyLoadInfo assembly) { // A given typefilter have been used on a number of assemblies, Based on the typefilter we will get another dictionary which // will map a specific AssemblyLoadInfo to a AssemblyInfoToLoadedTypes class which knows how to find a typeName in a given assembly. ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes> loadInfoToType = null; lock (cacheLock) { if (!cache.TryGetValue(_isDesiredType, out loadInfoToType)) { loadInfoToType = new ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes>(); cache.TryAdd(_isDesiredType, loadInfoToType); } } // Get an object which is able to take a typename and determine if it is in the assembly pointed to by the AssemblyInfo. AssemblyInfoToLoadedTypes typeNameToType = null; lock (loadInfoToTypeLock) { if (!loadInfoToType.TryGetValue(assembly, out typeNameToType)) { typeNameToType = new AssemblyInfoToLoadedTypes(_isDesiredType, assembly); loadInfoToType.TryAdd(assembly, typeNameToType); } } return typeNameToType.GetLoadedTypeByTypeName(typeName); }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> /// <returns>The loaded type, or null if the type was not found.</returns> internal LoadedType ReflectionOnlyLoad ( string typeName, AssemblyLoadInfo assembly ) { return GetLoadedType(s_cacheOfReflectionOnlyLoadedTypesByFilterLock, s_reflectionOnlyloadInfoToTypeLock, s_cacheOfReflectionOnlyLoadedTypesByFilter, typeName, assembly); }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> private LoadedType GetLoadedType(ConcurrentDictionary <Func <Type, object, bool>, ConcurrentDictionary <AssemblyLoadInfo, AssemblyInfoToLoadedTypes> > cache, string typeName, AssemblyLoadInfo assembly) { // A given type filter have been used on a number of assemblies, Based on the type filter we will get another dictionary which // will map a specific AssemblyLoadInfo to a AssemblyInfoToLoadedTypes class which knows how to find a typeName in a given assembly. ConcurrentDictionary <AssemblyLoadInfo, AssemblyInfoToLoadedTypes> loadInfoToType = cache.GetOrAdd(_isDesiredType, (_) => new ConcurrentDictionary <AssemblyLoadInfo, AssemblyInfoToLoadedTypes>()); // Get an object which is able to take a typename and determine if it is in the assembly pointed to by the AssemblyInfo. AssemblyInfoToLoadedTypes typeNameToType = loadInfoToType.GetOrAdd(assembly, (_) => new AssemblyInfoToLoadedTypes(_isDesiredType, _)); return(typeNameToType.GetLoadedTypeByTypeName(typeName)); }
/// <summary> /// Creates an instance of this class for the given type. /// </summary> /// <param name="type"></param> /// <param name="assembly"></param> internal LoadedType(Type type, AssemblyLoadInfo assemblyLoadInfo) : this(type, assemblyLoadInfo, null) { }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> private LoadedType GetLoadedType(object cacheLock, object loadInfoToTypeLock, ConcurrentDictionary <TypeFilter, ConcurrentDictionary <AssemblyLoadInfo, AssemblyInfoToLoadedTypes> > cache, string typeName, AssemblyLoadInfo assembly) { // A given typefilter have been used on a number of assemblies, Based on the typefilter we will get another dictionary which // will map a specific AssemblyLoadInfo to a AssemblyInfoToLoadedTypes class which knows how to find a typeName in a given assembly. ConcurrentDictionary <AssemblyLoadInfo, AssemblyInfoToLoadedTypes> loadInfoToType = null; lock (cacheLock) { if (!cache.TryGetValue(_isDesiredType, out loadInfoToType)) { loadInfoToType = new ConcurrentDictionary <AssemblyLoadInfo, AssemblyInfoToLoadedTypes>(); cache.TryAdd(_isDesiredType, loadInfoToType); } } // Get an object which is able to take a typename and determine if it is in the assembly pointed to by the AssemblyInfo. AssemblyInfoToLoadedTypes typeNameToType = null; lock (loadInfoToTypeLock) { if (!loadInfoToType.TryGetValue(assembly, out typeNameToType)) { typeNameToType = new AssemblyInfoToLoadedTypes(_isDesiredType, assembly); loadInfoToType.TryAdd(assembly, typeNameToType); } } return(typeNameToType.GetLoadedTypeByTypeName(typeName)); }
/// <summary> /// Loads the specified type if it exists in the given assembly. If the type name is fully qualified, then a match (if /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type /// found will be returned. /// </summary> internal LoadedType Load ( string typeName, AssemblyLoadInfo assembly ) { return GetLoadedType(cacheOfLoadedTypesByFilterLock, loadInfoToTypeLock, cacheOfLoadedTypesByFilter, typeName, assembly); }
/// <summary> /// Abstract out the creation of the new AssemblyTaskFactory with default task, and /// with some basic validation. /// </summary> private void SetupTaskFactory(IDictionary<string, string> factoryParameters, bool explicitlyLaunchTaskHost) { _taskFactory = new AssemblyTaskFactory(); _loadInfo = AssemblyLoadInfo.Create(null, Assembly.GetAssembly(typeof(TaskToTestFactories)).Location); _loadedType = _taskFactory.InitializeFactory(_loadInfo, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, factoryParameters, explicitlyLaunchTaskHost, null, ElementLocation.Create("NONE"), String.Empty); Assert.True(_loadedType.Assembly.Equals(_loadInfo)); // "Expected the AssemblyLoadInfo to be equal" }
/// <summary> /// Initialize the factory from the task registry /// </summary> internal LoadedType InitializeFactory ( AssemblyLoadInfo loadInfo, string taskName, IDictionary<string, TaskPropertyInfo> taskParameters, string taskElementContents, IDictionary<string, string> taskFactoryIdentityParameters, bool taskHostFactoryExplicitlyRequested, TargetLoggingContext targetLoggingContext, ElementLocation elementLocation, string taskProjectFile ) { ErrorUtilities.VerifyThrowArgumentNull(loadInfo, "loadInfo"); VerifyThrowIdentityParametersValid(taskFactoryIdentityParameters, elementLocation, taskName, "Runtime", "Architecture"); if (taskFactoryIdentityParameters != null) { _factoryIdentityParameters = new Dictionary<string, string>(taskFactoryIdentityParameters, StringComparer.OrdinalIgnoreCase); } _taskHostFactoryExplicitlyRequested = taskHostFactoryExplicitlyRequested; try { ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName"); _taskName = taskName; _loadedType = _typeLoader.Load(taskName, loadInfo); ProjectErrorUtilities.VerifyThrowInvalidProject(_loadedType != null, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, String.Empty); } catch (TargetInvocationException e) { // Exception thrown by the called code itself // Log the stack, so the task vendor can fix their code ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, Environment.NewLine + e.InnerException.ToString()); } catch (ReflectionTypeLoadException e) { // ReflectionTypeLoadException.LoaderExceptions may contain nulls foreach (Exception exception in e.LoaderExceptions) { if (exception != null) { targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, exception.Message); } } ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message); } catch (ArgumentNullException e) { // taskName may be null ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message); } catch (Exception e) // Catching Exception, but rethrowing unless it's a well-known exception. { if (ExceptionHandling.NotExpectedReflectionException(e)) { throw; } ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message); } return _loadedType; }
public void TearDownAttribute() { _taskFactory = null; _loadInfo = null; _loadedType = null; }