public Generator() { Logger.CatchAll(); Logger.Trace($"KY Generator v{Assembly.GetCallingAssembly().GetName().Version}"); Logger.Trace("Current Directory: " + Environment.CurrentDirectory); Logger.Trace("Log Directory: " + Logger.File.Path); NugetPackageDependencyLoader.Activate(); this.output = new FileOutput(AppDomain.CurrentDomain.BaseDirectory); this.resolver = new DependencyResolver(); this.resolver.Bind <ITypeMapping>().ToSingleton <TypeMapping>(); this.resolver.Bind <CommandRunner>().ToSelf(); this.resolver.Bind <ModuleFinder>().ToSelf(); this.resolver.Bind <IConfigurationReaderVersion>().To <ConfigurationReaderVersion2>(); this.resolver.Bind <ReaderConfigurationMapping>().ToSingleton(); this.resolver.Bind <WriterConfigurationMapping>().ToSingleton(); this.resolver.Bind <ConfigurationRunner>().ToSelf(); this.resolver.Bind <ModelWriter>().ToSelf(); StaticResolver.Resolver = this.resolver; ModuleFinder moduleFinder = this.resolver.Get <ModuleFinder>(); moduleFinder.LoadFromAssemblies(); this.Modules = moduleFinder.Modules; foreach (ModuleBase module in this.Modules) { Logger.Trace($"{module.GetType().Name.Replace("Module", "")}-{module.GetType().Assembly.GetName().Version} module loaded"); } this.Modules.ForEach(module => this.resolver.Bind <ModuleBase>().To(module)); this.Modules.ForEach(module => module.Initialize()); }
public void LoadAnAlphaVersion() { NugetAssemblyLocator locator = NugetPackageDependencyLoader.CreateLocator(); // Assembly assembly = locator.Locate("Polly, Version=6.0.0.0, Culture=neutral, PublicKeyToken=c8a3ffc3f8f825cc"); Assembly assembly = locator.Locate("amotiq.base.api, Version=0.0.1.1, Culture=neutral, PublicKeyToken=c8a3ffc3f8f825cc"); Assert.IsNotNull(assembly); }
public static Assembly Locate(string assemblyName, params SearchLocation[] locations) { NugetAssemblyLocator locator = NugetPackageDependencyLoader.CreateLocator(); locator.Locations.InsertRange(0, locations); Version defaultVersion = typeof(CoreModule).Assembly.GetName().Version; return(locator.Locate(assemblyName, defaultVersion)); }
public static bool Run(string[] args) { #if DEBUG if (args.Length > 0 && args[0] != "statistics") { System.Diagnostics.Debugger.Launch(); } #endif Generator.InitializeLogger(args); NugetPackageDependencyLoader.Activate(); NugetPackageDependencyLoader.Locations.Insert(0, new SearchLocation(SharedPath)); return(Generator.Initialize() .PreloadModules(SharedPath, "KY.Generator.*.dll") .SetParameters(args) .Run()); }
public static LocateAssemblyResult Locate(string assemblyName, bool isBeforeBuild, params SearchLocation[] locations) { foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies().Where(x => !x.IsDynamic)) { if (assembly.Location.Equals(assemblyName, StringComparison.CurrentCultureIgnoreCase) || assembly.GetName().Name.Equals(assemblyName, StringComparison.CurrentCultureIgnoreCase)) { return(new LocateAssemblyResult(assembly)); } } Assembly entryAssembly = Assembly.GetEntryAssembly(); ProcessorArchitecture entryArchitecture = entryAssembly.GetName().ProcessorArchitecture; try { ProcessorArchitecture assemblyArchitecture = AssemblyName.GetAssemblyName(assemblyName).ProcessorArchitecture; bool isCompatible64 = (entryArchitecture == ProcessorArchitecture.Amd64 || entryArchitecture == ProcessorArchitecture.MSIL) && (assemblyArchitecture == ProcessorArchitecture.Amd64 || assemblyArchitecture == ProcessorArchitecture.MSIL); bool isCompatible86 = entryArchitecture == ProcessorArchitecture.X86 && assemblyArchitecture == ProcessorArchitecture.X86; if (!isCompatible64 && !isCompatible86) { return(new LocateAssemblyResult(assemblyArchitecture)); } } catch (FileNotFoundException) { if (isBeforeBuild) { return(new LocateAssemblyResult()); } throw; } try { SwitchableFramework? assemblyFramework = null; string[] frameworkFiles = FileSystem.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll"); IEnumerable <string> loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(x => !x.IsDynamic).Select(x => x.Location); PathAssemblyResolver resolver = new PathAssemblyResolver(loadedAssemblies.Concat(frameworkFiles)); MetadataLoadContext metadataLoadContext = new MetadataLoadContext(resolver); using (metadataLoadContext) { Assembly assemblyData = metadataLoadContext.LoadFromAssemblyPath(assemblyName); IList <CustomAttributeData> customAttributeData = assemblyData.GetCustomAttributesData(); foreach (CustomAttributeData attributeData in customAttributeData) { try { assemblyFramework = assemblyFramework ?? attributeData.ConstructorArguments.Select(x => x.Value as string) .Where(x => x != null) .Select(TryParseFrameworkName) .FirstOrDefault()? .GetSwitchableFramework(); } catch { // Some unnecessary attributes can not be read by a assembly with the wrong framework version, so ignore them } } assemblyFramework = assemblyFramework ?? SwitchableFramework.None; } SwitchableFramework entryFramework = entryAssembly.GetSwitchableFramework(); if (entryFramework != assemblyFramework && assemblyFramework != SwitchableFramework.None) { return(new LocateAssemblyResult(assemblyFramework.Value)); } } catch (TypeLoadException exception) { Logger.Warning($"Could not check framework compatibility, because {exception.TypeName} could not be loaded\n{exception.Message}"); } catch (FileNotFoundException exception) { Logger.Warning($"Could not check framework compatibility, because an assembly could not be found\n{exception.Message}"); } catch (Exception exception) { Logger.Warning($"Could not check framework compatibility, because an error occurred\n{exception.Message}"); } NugetAssemblyLocator locator = NugetPackageDependencyLoader.CreateLocator(); locator.Locations.InsertRange(0, locations); Version defaultVersion = typeof(CoreModule).Assembly.GetName().Version; return(new LocateAssemblyResult(locator.Locate(assemblyName, defaultVersion))); }