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