/// <summary> /// Gets the default assemblies. /// </summary> /// <param name="root">The root to where to find Cake related assemblies.</param> /// <returns>A list containing all default assemblies.</returns> public IReadOnlyList <Assembly> GetDefaultAssemblies(DirectoryPath root) { // Prepare the default assemblies. var result = new HashSet <Assembly>(new SimpleAssemblyComparer()); result.Add(typeof(Action).GetTypeInfo().Assembly); // mscorlib or System.Private.Core result.Add(typeof(IQueryable).GetTypeInfo().Assembly); // System.Core or System.Linq.Expressions // Load other Cake-related assemblies that we need. var cakeAssemblies = LoadCakeAssemblies(root); result.AddRange(cakeAssemblies); #if NETCORE // Load all referenced assemblies. foreach (var cakeAssembly in cakeAssemblies) { foreach (var reference in cakeAssembly.GetReferencedAssemblies()) { result.Add(_loader.Load(reference)); } } #else result.Add(typeof(Uri).GetTypeInfo().Assembly); // System result.Add(typeof(System.Xml.XmlReader).GetTypeInfo().Assembly); // System.Xml result.Add(typeof(System.Xml.Linq.XDocument).GetTypeInfo().Assembly); // System.Xml.Linq result.Add(typeof(System.Data.DataTable).GetTypeInfo().Assembly); // System.Data #endif // Return the assemblies. return(result.ToArray()); }
/// <inheritdoc/> public IReadOnlyList <Assembly> GetDefaultAssemblies(DirectoryPath root) { // Prepare the default assemblies. var result = new HashSet <Assembly>(new SimpleAssemblyComparer()); result.Add(typeof(Action).GetTypeInfo().Assembly); // mscorlib or System.Private.Core result.Add(typeof(IQueryable).GetTypeInfo().Assembly); // System.Core or System.Linq.Expressions result.Add(typeof(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo).Assembly); // Dynamic support result.AddRange(_referenceAssemblyResolver.GetReferenceAssemblies()); // Load other Cake-related assemblies that we need. var cakeAssemblies = LoadCakeAssemblies(root); result.AddRange(cakeAssemblies); // Load all referenced assemblies. foreach (var cakeAssembly in cakeAssemblies) { foreach (var reference in cakeAssembly.GetReferencedAssemblies()) { result.Add(_loader.Load(reference)); } } // Return the assemblies. return(result.ToArray()); }
private static void ValidateRoslynList(IAssemblyLoader loader) { if (s_validated) { return; } // Check to see if the Roslyn code fix and refactoring provider type names can be found. // If this fails, OmniSharp has updated to a new version of Roslyn and one of the type names changed. var assemblies = new[] { loader.Load(Configuration.RoslynCSharpFeatures), loader.Load(Configuration.RoslynFeatures), loader.Load(Configuration.RoslynWorkspaces) }; var typeNames = _roslynListToRemove.Concat(new[] { AddImportProviderName, RemoveUnnecessaryUsingsProviderName }); foreach (var typeName in typeNames) { if (!ExistsInAssemblyList(typeName, assemblies)) { throw new InvalidOperationException($"Could not find '{typeName}'. Has this type name changed?"); } } s_validated = true; }
private void AddDefaultClrMetadataReferences(ProjectContext projectContext, HashSet <MetadataReference> commonReferences) { if (projectContext == null || projectContext.TargetFramework?.Framework != ".NETCoreApp") { var assemblies = new[] { typeof(object).GetTypeInfo().Assembly, typeof(Enumerable).GetTypeInfo().Assembly, typeof(Stack <>).GetTypeInfo().Assembly, typeof(Lazy <,>).GetTypeInfo().Assembly, _assemblyLoader.Load("System.Runtime"), _assemblyLoader.Load("mscorlib") }; var references = assemblies .Where(a => a != null) .Select(a => a.Location) .Distinct() .Select(l => _metadataFileReferenceCache.GetMetadataReference(l)); foreach (var reference in references) { commonReferences.Add(reference); } } }
/// <summary> /// Gets the default assemblies. /// </summary> /// <param name="root">The root to where to find Cake related assemblies.</param> /// <returns>A list containing all default assemblies.</returns> public IReadOnlyList <Assembly> GetDefaultAssemblies(DirectoryPath root) { // Prepare the default assemblies. var result = new HashSet <Assembly>(new SimpleAssemblyComparer()); result.Add(typeof(Action).GetTypeInfo().Assembly); // mscorlib or System.Private.Core result.Add(typeof(IQueryable).GetTypeInfo().Assembly); // System.Core or System.Linq.Expressions // Load other Cake-related assemblies that we need. var cakeAssemblies = LoadCakeAssemblies(root); result.AddRange(cakeAssemblies); #if NETCORE // Load all referenced assemblies. foreach (var cakeAssembly in cakeAssemblies) { foreach (var reference in cakeAssembly.GetReferencedAssemblies()) { result.Add(_loader.Load(reference)); } } #else result.Add(typeof(Uri).GetTypeInfo().Assembly); // System result.Add(typeof(System.Xml.XmlReader).GetTypeInfo().Assembly); // System.Xml result.Add(typeof(System.Xml.Linq.XDocument).GetTypeInfo().Assembly); // System.Xml.Linq result.Add(typeof(System.Data.DataTable).GetTypeInfo().Assembly); // System.Data // This is just to please Roslyn when running under Mono. See issue https://github.com/dotnet/roslyn/issues/19364 result.Add(_loader.Load(new AssemblyName("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"))); // System.Runtime #endif // Return the assemblies. return(result.ToArray()); }
public void AddReference(FilePath path) { if (path == null) { throw new ArgumentNullException(nameof(path)); } _log.Debug("Adding reference to {0}...", path.GetFilename().FullPath); References.Add(_loader.Load(path, true)); }
public void Load(byte[] rawAssembly) { try { Assembly = _assemblyLoader.Load(rawAssembly); } catch (Exception ex) { throw new DynamicAssemblyLoadingException(ex); } }
/// <summary> /// Gets the default assemblies. /// </summary> /// <param name="root">The root to where to find Cake related assemblies.</param> /// <returns>A list containing all default assemblies.</returns> public IReadOnlyList <Assembly> GetDefaultAssemblies(DirectoryPath root) { // Prepare the default assemblies. var result = new HashSet <Assembly>(new SimpleAssemblyComparer()); result.Add(typeof(Action).GetTypeInfo().Assembly); // mscorlib or System.Private.Core result.Add(typeof(IQueryable).GetTypeInfo().Assembly); // System.Core or System.Linq.Expressions // Load other Cake-related assemblies that we need. var cakeAssemblies = LoadCakeAssemblies(root); result.AddRange(cakeAssemblies); #if NETCORE // Load all referenced assemblies. foreach (var cakeAssembly in cakeAssemblies) { foreach (var reference in cakeAssembly.GetReferencedAssemblies()) { result.Add(_loader.Load(reference)); } } #else result.Add(typeof(Uri).GetTypeInfo().Assembly); // System result.Add(typeof(System.Xml.XmlReader).GetTypeInfo().Assembly); // System.Xml result.Add(typeof(System.Xml.Linq.XDocument).GetTypeInfo().Assembly); // System.Xml.Linq result.Add(typeof(System.Data.DataTable).GetTypeInfo().Assembly); // System.Data // This is just to please Roslyn when running under Mono. See issue https://github.com/dotnet/roslyn/issues/19364 result.Add(_loader.Load(new AssemblyName("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"))); // System.Runtime result.Add(_loader.Load(new AssemblyName("System.Collections, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"))); // System.Collections try { result.Add(_loader.Load(new AssemblyName("netstandard, Version=2.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51"))); // NETStandard.Library } catch { /* * Silently continue instead and let it blow up during runtime if netstandard assembly was not found. * TODO: Log that netstandard assembly was not found. * Unfortunately, logger is not available in this class, and that would be too big of a change for the 0.26.1 hotfix release. */ } #endif // Return the assemblies. return(result.ToArray()); }
/// <summary> /// Loads a dependency map using the assemblies located in the target directory. /// </summary> /// <param name="directory">The directory that contains the assemblies that will be loaded into the dependency map.</param> /// <param name="filePattern">The search pattern that describes which assemblies will be loaded.</param> /// <param name="assemblyLoader">The assembly loader that will load assemblies into memory.</param> /// <returns>A dependency map.</returns> public DependencyMap LoadFrom(string directory, string filePattern, IAssemblyLoader assemblyLoader) { if (assemblyLoader == null) { throw new ArgumentNullException("assemblyLoader"); } // Load the assemblies from the target directory var files = Directory.GetFiles(directory, filePattern); var assemblies = new List <Assembly>(); foreach (var file in files) { var assembly = assemblyLoader.Load(file); if (assembly == null) { continue; } assemblies.Add(assembly); } return(LoadFrom(assemblies)); }
private static List <Assembly> DiscoverOmniSharpAssemblies(IAssemblyLoader loader, ILogger logger) { // Iterate through all runtime libraries in the dependency context and // load them if they depend on OmniSharp. var assemblies = new List <Assembly>(); var dependencyContext = DependencyContext.Default; foreach (var runtimeLibrary in dependencyContext.RuntimeLibraries) { if (DependsOnOmniSharp(runtimeLibrary)) { foreach (var name in runtimeLibrary.GetDefaultAssemblyNames(dependencyContext)) { var assembly = loader.Load(name); if (assembly != null) { assemblies.Add(assembly); logger.LogDebug($"Loaded {assembly.FullName}"); } } } } return(assemblies); }
public GeneratorParametersReader(IAssemblyLoader assemblyLoader) { _assemblyLoader = assemblyLoader; _readerFunctions = new Dictionary<string, Action<GeneratorParameters, string>>(StringComparer.OrdinalIgnoreCase) { { "assembly", (arguments, s) => arguments.SetAssembly(_assemblyLoader.Load(s))}, { "reference", (arguments, s) => arguments.AddReference(_assemblyLoader.Load(s))}, { "withDocs", (arguments, s) => arguments.SetWithDocumentation(s.ToBool())}, { "ignoreNamespace", (arguments, s) => arguments.AddIgnoreNamespace(s)}, { "ignoreNamespaceRegex", (arguments, s) => arguments.AddIgnoreNamespaceByRegex(s)}, { "headerLine", (arguments, s) => arguments.AddHeaderLine(s)}, { "headerFile", (arguments, s) => arguments.AddHeaderFile(s)}, { "outputFilePath", (arguments, s) => arguments.SetOutputFilePath(s)} }; }
System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) { foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) { if (a.FullName == args.Name) { return(a); } } // Console.Out.WriteLine("{1}: load '{0}' in AppD '{2}'", args.Name.Split(',')[0], this, AppDomain.CurrentDomain.FriendlyName); IAssemblyLoader loader = locator.GetLoader(args.Name); // Console.Out.WriteLine("{0}: Got '{1}' as the loader result. In AppDomain {2}", this, loader == null ? "null" : loader.AssemblyName, AppDomain.CurrentDomain.FriendlyName); if (loader == null) { return(null); } Assembly assembly = loader.Load(); // Console.Out.WriteLine("{0}: Assembly '{1}' loaded from loader", this, assembly.FullName); return(assembly); }
public RoslynFeaturesHostServicesProvider(IAssemblyLoader loader) { var builder = ImmutableArray.CreateBuilder <Assembly>(); builder.AddRange(loader.Load(Configuration.RoslynFeatures, Configuration.RoslynCSharpFeatures, Configuration.RoslynOmniSharpExternalAccess, Configuration.RoslynOmniSharpExternalAccessCSharp)); Assemblies = builder.ToImmutable(); }
public ISuiteResult Run(IIntent assemblyIntent) { using (SetupTraceListeners()) { var suiteProvider = _assemblyLoader.Load(assemblyIntent); return(_suiteRunner.Run(assemblyIntent, suiteProvider)); } }
public System.Reflection.Assembly GetReferencedAssembly(string name) { if (!HasReferencedAssembly(name)) { return(null); } return(_assemblyLoader.Load(name)); }
Ref.Assembly IAssemblyLoader.Load(AssemblyIdentity identity) { if (dynamicModule != null && identity.Name == dynamicAssemblyName.Name) { return(dynamicModule.Assembly); } return(assemblyLoader.Load(identity)); }
public Assembly GetReferencedAssembly(string name) { if (!HasReferencedAssembly(name)) { return(null); } return(_assemblyLoader.Load(name)); }
/// <summary> /// Tries to attach available module assemblies from working modules directory. /// </summary> public void AddUploadedModules() { if (Log.IsTraceEnabled) { Log.Trace("Add uploaded Better Cms modules."); } var availableModuleFiles = workingDirectory.GetAvailableModules(); var runtimeModuleFiles = new List <FileInfo>(); foreach (var moduleInfo in availableModuleFiles) { try { var runtimeModuleInfo = workingDirectory.RecopyModulesToRuntimeFolder(moduleInfo); runtimeModuleFiles.Add(runtimeModuleInfo); } catch (Exception ex) { throw new CmsException("Failed to recopy module " + moduleInfo.FullName + ".", ex); } } foreach (var runtimeModuleFile in runtimeModuleFiles) { try { if (runtimeModuleFile.FullName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { var runtimeModuleAssembly = assemblyLoader.Load(AssemblyName.GetAssemblyName(runtimeModuleFile.FullName)); BuildManager.AddReferencedAssembly(runtimeModuleAssembly); embeddedResourcesProvider.AddEmbeddedResourcesFrom(runtimeModuleAssembly); modulesRegistration.AddModuleDescriptorTypeFromAssembly(runtimeModuleAssembly); } } catch (Exception ex) { throw new CmsException("Failed to add reference to runtime module " + runtimeModuleFile.FullName + ".", ex); } } }
/// <summary> /// Builds a report model from the assembly specified via <paramref name="assemblyName"/>. /// </summary> /// <param name="assemblyName">Specifies the name of an assembly or the full path to an assembly</param> /// <returns> /// The <see cref="Report"/> model extracted from the specified assembly. /// </returns> /// <exception cref="ArgumentException"> /// Thrown when <paramref name="assemblyName"/> is <c>null</c> or empty. /// </exception> public IReport BuildModel(string assemblyName) { Guard.AgainstNullOrEmptyString(assemblyName, "assemblyName"); var assembly = _assemblyLoader.Load(assemblyName); Debug.Assert(assembly != null); return(BuildModelFrom(assembly)); }
public Assembly LoadAssembly(string moduleName) { var path = PrecompiledAssemblyPath(moduleName); if (!_appDataFolder.FileExists(path)) { return(null); } return(_assemblyLoader.Load(moduleName)); }
public static Assembly Load(this IAssemblyLoader loader, string name) { var assemblyName = name; if (name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { assemblyName = name.Substring(0, name.Length - 4); } return(loader.Load(new AssemblyName(assemblyName))); }
static Assembly AssemblyLoader(object source, ResolveEventArgs e) { if (_assemblyLoader != null) { Console.WriteLine("Resolving {0}", e.Name); return(_assemblyLoader.Load(e.Name)); } else { return(null); } }
/// <summary> /// Tries to attach available module assemblies from working modules directory. /// </summary> public void AddUploadedModules() { if (Log.IsTraceEnabled) { Log.Trace("Add uploaded modules."); } var availableModuleFiles = workingDirectory.GetAvailableModules(); var runtimeModuleFiles = new List <FileInfo>(); foreach (var moduleInfo in availableModuleFiles) { try { var runtimeModuleInfo = workingDirectory.RecopyModulesToRuntimeFolder(moduleInfo); runtimeModuleFiles.Add(runtimeModuleInfo); } catch (Exception ex) { throw new CoreException("Failed to recopy module " + moduleInfo.FullName + ".", ex); } } foreach (var runtimeModuleFile in runtimeModuleFiles) { try { if (runtimeModuleFile.FullName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { var runtimeModuleAssembly = assemblyLoader.Load(AssemblyName.GetAssemblyName(runtimeModuleFile.FullName)); AddUploadedModule(runtimeModuleAssembly); } } catch (Exception ex) { throw new CoreException("Failed to add reference to runtime module " + runtimeModuleFile.FullName + ".", ex); } } }
/// <summary> /// 根据程序集描述符装载一个程序集。 /// </summary> /// <param name="assemblyLoader">程序集装载机。</param> /// <param name="descriptor">程序集描述符。</param> /// <returns>程序集。</returns> /// <exception cref="ArgumentNullException"><paramref name="descriptor"/> 为null。</exception> public static Assembly Load(this IAssemblyLoader assemblyLoader, AssemblyDescriptor descriptor) { if (assemblyLoader == null) { throw new ArgumentNullException("assemblyLoader"); } if (descriptor == null) { throw new ArgumentNullException("descriptor"); } return(assemblyLoader.Load(descriptor.FullName)); }
public void Load() { this.assembly = Assembly.Load(File.ReadAllBytes(@"./Controller.dll")); foreach (Component <World> component in this.GetComponents()) { IAssemblyLoader assemblyLoader = component as IAssemblyLoader; if (assemblyLoader != null) { assemblyLoader.Load(this.assembly); } } }
public static Assembly LoadByAssemblyNameOrPath( this IAssemblyLoader loader, string assemblyName) { if (File.Exists(assemblyName)) { return(loader.LoadFrom(assemblyName)); } else { return(loader.Load(assemblyName)); } }
protected override ExtensionEntry LoadWorker(ExtensionDescriptor descriptor) { if (Disabled) { return(null); } var assembly = _assemblyLoader.Load(CoreAssemblyName); if (assembly == null) { Logger.Error("Core modules cannot be activated because assembly '{0}' could not be loaded", CoreAssemblyName); return(null); } Logger.Information("Loaded core module \"{0}\": assembly name=\"{1}\"", descriptor.Name, assembly.FullName); return(new ExtensionEntry { Descriptor = descriptor, Assembly = assembly, ExportedTypes = assembly.GetExportedTypes().Where(x => IsTypeFromModule(x, descriptor)) }); }
/// <summary> /// Gets the embedded resource virtual file. /// </summary> /// <param name="virtualPath">The virtual path.</param> /// <returns>Embedded resource virtual file.</returns> public EmbeddedResourcesVirtualFile GetEmbeddedResourceVirtualFile(string virtualPath) { string resourceName; if (TryConvertVirtualPathToEmbeddedResourceName(virtualPath, out resourceName)) { var embeddedResourceDescriptor = resourceNameEmbeddedResource[resourceName]; var assembly = assemblyLoader.Load(embeddedResourceDescriptor.AssemblyName); return(new EmbeddedResourcesVirtualFile(assembly, embeddedResourceDescriptor.ResourceName, virtualPath)); } return(null); }
static System.Reflection.Assembly CurrentDomain_TypeResolve(object sender, ResolveEventArgs args) { Console.Out.WriteLine(".. Probing Type {0}", args.Name); string tmp = ""; foreach (string sub in args.Name.Split('.')) { tmp = tmp == "" ? sub : tmp + "." + sub; if (tmp == string.Empty) { continue; } System.Reflection.Assembly asm = assemblyLoader.Load(tmp); if (asm.GetType(args.Name) != null) { return(asm); } } Console.Out.WriteLine("> Failed to get type {0}", args.Name); return(null); }
public void Create(Func <IEnumerable <Assembly>, IEnumerable <Assembly> > func) { var thisAssembly = GetType().GetTypeInfo().Assembly; var thisAssemblyFullName = thisAssembly.FullName; var assemblies = _assemblyLoader.Load(func) .Where(a => a.GetReferencedAssemblies().Any(asb => string.CompareOrdinal(asb.FullName, thisAssemblyFullName) == 0)); _assemblyHandler.Process(thisAssembly); foreach (var assembly in assemblies) { _assemblyHandler.Process(assembly); } }
private static Assembly[] GetAssembliesWithServices() { List <Assembly> assemblies = new List <Assembly>(); ICmsModulesRegistration modulesRegistry; IAssemblyLoader assemblyLoader = null; using (var container = ContextScopeProvider.CreateChildContainer()) { modulesRegistry = container.Resolve <ICmsModulesRegistration>(); if (modulesRegistry == null) { throw new CmsApiException("Failed to resolve ICmsModulesRegistration."); } assemblyLoader = container.Resolve <IAssemblyLoader>(); if (assemblyLoader == null) { throw new CmsApiException("Failed to resolve IAssemblyLoader."); } foreach (var module in modulesRegistry.GetModules()) { try { var assembly = assemblyLoader.Load(module.ModuleDescriptor.AssemblyName); if (assembly != null) { var types = assemblyLoader.GetLoadableTypes(assembly); foreach (var type in types) { if (typeof(ServiceStack.ServiceInterface.Service).IsAssignableFrom(type) && type != null && type.IsPublic && type.IsClass && !type.IsAbstract) { assemblies.Add(assembly); break; } } } } catch (Exception ex) { logger.ErrorFormat("Failed to check for ServiceStack services in the assembly {0}.", ex, module.ModuleDescriptor.AssemblyName); } } } return(assemblies.ToArray()); }
/// <summary> /// Loads a dependency map using the assemblies located in the target directory. /// </summary> /// <param name="directory">The directory that contains the assemblies that will be loaded into the dependency map.</param> /// <param name="filePattern">The search pattern that describes which assemblies will be loaded.</param> /// <param name="assemblyLoader">The assembly loader that will load assemblies into memory.</param> /// <returns>A dependency map.</returns> public DependencyMap LoadFrom(string directory, string filePattern, IAssemblyLoader assemblyLoader) { if (assemblyLoader == null) throw new ArgumentNullException("assemblyLoader"); // Load the assemblies from the target directory var files = Directory.GetFiles(directory, filePattern); var assemblies = new List<Assembly>(); foreach (var file in files) { var assembly = assemblyLoader.Load(file); if (assembly == null) continue; assemblies.Add(assembly); } return LoadFrom(assemblies); }