internal List <ExportedAssembly> GetAssemblies(string pathResolveRoot, DnaLibrary dnaLibrary) { List <ExportedAssembly> list = new List <ExportedAssembly>(); try { string realPath = Path; if (Path.StartsWith("packed:")) { // The ExternalLibrary is packed. // We'll have to load it from resources. string resourceName = Path.Substring(7); if (Path.EndsWith(".DNA", StringComparison.OrdinalIgnoreCase)) { byte[] dnaContent = ExcelIntegration.GetDnaFileBytes(resourceName); DnaLibrary lib = DnaLibrary.LoadFrom(dnaContent, pathResolveRoot); if (lib == null) { Logger.Initialization.Error("External library could not be registered - Path: {0}\r\n - Packed DnaLibrary could not be loaded", Path); return(list); } return(lib.GetAssemblies(pathResolveRoot)); } else { // DOCUMENT: TypeLibPath which is a resource in a library is denoted as fileName.dll\4 // For packed assemblies, we set TypeLibPath="packed:2" string typeLibPath = null; if (!string.IsNullOrEmpty(TypeLibPath) && TypeLibPath.StartsWith("packed:")) { typeLibPath = DnaLibrary.XllPath + @"\" + TypeLibPath.Substring(7); } // It would be nice to check here whether the assembly is loaded already. // But because of the name mangling in the packing we can't easily check. // So we make the following assumptions: // 1. Packed assemblies won't also be loadable from files (else they might be loaded twice) // 2. ExternalLibrary loads will happen before reference loads via AssemblyResolve. // Under these assumptions we should not have assemblies loaded more than once, // even if not checking here. byte[] rawAssembly = ExcelIntegration.GetAssemblyBytes(resourceName); byte[] rawPdb = ExcelIntegration.GetPdbBytes(resourceName); Assembly assembly = ExcelIntegration.LoadFromAssemblyBytes(rawAssembly, rawPdb); list.Add(new ExportedAssembly(assembly, ExplicitExports, ExplicitRegistration, ComServer, false, typeLibPath, dnaLibrary)); return(list); } } if (Uri.IsWellFormedUriString(Path, UriKind.Absolute)) { // Here is support for loading ExternalLibraries from http. Uri uri = new Uri(Path, UriKind.Absolute); if (uri.IsUnc) { realPath = uri.LocalPath; // Will continue to load later with the regular file load part below... } else { string scheme = uri.Scheme.ToLowerInvariant(); if (scheme != "http" && scheme != "file" && scheme != "https") { Logger.Initialization.Error("The ExternalLibrary path {0} is not a valid Uri scheme.", Path); return(list); } else { if (uri.AbsolutePath.EndsWith("dna", StringComparison.InvariantCultureIgnoreCase)) { DnaLibrary lib = DnaLibrary.LoadFrom(uri); if (lib == null) { Logger.Initialization.Error("External library could not be registered - Path: {0} - DnaLibrary could not be loaded" + Path); return(list); } // CONSIDER: Should we add a resolve story for .dna files at Uris? return(lib.GetAssemblies(null)); // No explicit resolve path } else { // Load as a regular assembly - TypeLib not supported. Assembly assembly = ExcelIntegration.LoadFromAssemblyPath(Path); list.Add(new ExportedAssembly(assembly, ExplicitExports, ExplicitRegistration, ComServer, false, null, dnaLibrary)); return(list); } } } } // Keep trying with the current value of realPath. string resolvedPath = DnaLibrary.ResolvePath(realPath, pathResolveRoot); if (resolvedPath == null) { Logger.Initialization.Error("External library could not be registered - Path: {0} - The library could not be found at this location" + Path); return(list); } if (System.IO.Path.GetExtension(resolvedPath).Equals(".DNA", StringComparison.OrdinalIgnoreCase)) { // Load as a DnaLibrary DnaLibrary lib = DnaLibrary.LoadFrom(resolvedPath); if (lib == null) { Logger.Initialization.Error("External library could not be registered - Path: {0} - DnaLibrary could not be loaded" + Path); return(list); } string pathResolveRelative = System.IO.Path.GetDirectoryName(resolvedPath); return(lib.GetAssemblies(pathResolveRelative)); } else { Assembly assembly; // Load as a regular assembly // First check if it is already loaded (e.g. as a reference from another assembly) // DOCUMENT: Some cases might still have assemblies loaded more than once. // E.g. for an assembly that is both ExternalLibrary and references from another assembly, // having the assembly LoadFromBytes and in the file system would load it twice, // because LoadFromBytes here happens before the .NET loaders assembly resolution. string assemblyName = System.IO.Path.GetFileNameWithoutExtension(resolvedPath); assembly = GetAssemblyIfLoaded(assemblyName); if (assembly == null) { // Really have to load it. if (LoadFromBytes) { // We need to be careful here to not re-load the assembly if it had already been loaded, // e.g. as a dependency of an assembly loaded earlier. // In that case we won't be able to have the library 'LoadFromBytes'. byte[] bytes = File.ReadAllBytes(resolvedPath); byte[] pdbBytes = null; string pdbPath = System.IO.Path.ChangeExtension(resolvedPath, "pdb"); if (File.Exists(pdbPath)) { pdbBytes = File.ReadAllBytes(pdbPath); } assembly = ExcelIntegration.LoadFromAssemblyBytes(bytes, pdbBytes); } else { assembly = ExcelIntegration.LoadFromAssemblyPath(resolvedPath); } } string resolvedTypeLibPath = null; if (!string.IsNullOrEmpty(TypeLibPath)) { resolvedTypeLibPath = DnaLibrary.ResolvePath(TypeLibPath, pathResolveRoot); // null is unresolved if (resolvedTypeLibPath == null) { resolvedTypeLibPath = DnaLibrary.ResolvePath(TypeLibPath, System.IO.Path.GetDirectoryName(resolvedPath)); } } else { // Check for .tlb with same name next to resolvedPath string tlbCheck = System.IO.Path.ChangeExtension(resolvedPath, "tlb"); if (System.IO.File.Exists(tlbCheck)) { resolvedTypeLibPath = tlbCheck; } } list.Add(new ExportedAssembly(assembly, ExplicitExports, ExplicitRegistration, ComServer, false, resolvedTypeLibPath, dnaLibrary)); return(list); } } catch (Exception e) { // Assembly could not be loaded. Logger.Initialization.Error(e, "External library could not be registered - Path: {0}", Path); return(list); } }
public List <string> GetReferencePaths(string pathResolveRoot, CodeDomProvider provider) { List <string> refPaths = new List <string>(); if (References != null) { foreach (Reference rf in References) { bool isResolved = false; if (rf.Path != null) { if (rf.Path.StartsWith("packed:")) { string assName = rf.Path.Substring(7); string assPath = Path.GetTempFileName(); tempAssemblyPaths.Add(assPath); File.WriteAllBytes(assPath, ExcelIntegration.GetAssemblyBytes(assName)); refPaths.Add(assPath); isResolved = true; } else { // Call ResolvePath - check relative to pathResolveRoot and in framework directory. string refPath = DnaLibrary.ResolvePath(rf.Path, pathResolveRoot); if (!string.IsNullOrEmpty(refPath)) { refPaths.Add(refPath); isResolved = true; } } } if (!isResolved && rf.Name != null) { // Try to resolve by Name #pragma warning disable 0618 Assembly refAssembly = Assembly.LoadWithPartialName(rf.Name); #pragma warning restore 0618 if (refAssembly != null) { if (!string.IsNullOrEmpty(refAssembly.Location)) { refPaths.Add(refAssembly.Location); isResolved = true; } } } if (!isResolved) { // Must have been loaded by us from the packing....? Logger.DnaCompilation.Error("Assembly resolve failure - Reference Name: {0}, Path: {1}", rf.Name, rf.Path); } } } if (DefaultReferences) { // CONSIDER: Should these be considered more carefully? I'm just putting in what the default templates in Visual Studio 2010 put in. refPaths.Add("System.dll"); refPaths.Add("System.Data.dll"); refPaths.Add("System.Xml.dll"); if (Environment.Version.Major >= 4) { refPaths.Add("System.Core.dll"); refPaths.Add("System.Data.DataSetExtensions.dll"); refPaths.Add("System.Xml.Linq.dll"); if (provider is Microsoft.CSharp.CSharpCodeProvider) { refPaths.Add("Microsoft.CSharp.dll"); } } } // DOCUMENT: Reference to the xll is always added // Sort out "ExcelDna.Integration.dll" copy which causes problems // TODO: URGENT: Revisit this... (don't know what to do yet - maybe full AssemblyName). string location = Assembly.GetExecutingAssembly().Location; if (location != "") { refPaths.Add(location); } else { string assPath = Path.GetTempFileName(); tempAssemblyPaths.Add(assPath); File.WriteAllBytes(assPath, ExcelIntegration.GetAssemblyBytes("EXCELDNA.INTEGRATION")); refPaths.Add(assPath); } Logger.DnaCompilation.Verbose("Compiler References: "); foreach (string rfPath in refPaths) { Logger.DnaCompilation.Verbose(" " + rfPath); } return(refPaths); }