Ejemplo n.º 1
0
 public override bool Execute()
 {
     using (var resolver = new DirectoryAssemblyResolver(Log.LogWarning, loadDebugSymbols: false)) {
         return(Execute(resolver));
     }
 }
Ejemplo n.º 2
0
        bool Execute(DirectoryAssemblyResolver resolver)
        {
            Log.LogDebugMessage("ResolveAssemblies Task");
            Log.LogDebugMessage("  ReferenceAssembliesDirectory: {0}", ReferenceAssembliesDirectory);
            Log.LogDebugMessage("  I18nAssemblies: {0}", I18nAssemblies);
            Log.LogDebugTaskItems("  Assemblies:", Assemblies);

            foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
            {
                resolver.SearchDirectories.Add(dir);
            }

            var assemblies = new HashSet <string>();

            var topAssemblyReferences = new List <AssemblyDefinition>();

            try {
                foreach (var assembly in Assemblies)
                {
                    var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);

                    if (!resolver.SearchDirectories.Contains(assembly_path))
                    {
                        resolver.SearchDirectories.Add(assembly_path);
                    }

                    // Add each user assembly and all referenced assemblies (recursive)
                    var assemblyDef = resolver.Load(assembly.ItemSpec);
                    if (assemblyDef == null)
                    {
                        throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
                    }
                    topAssemblyReferences.Add(assemblyDef);
                    assemblies.Add(Path.GetFullPath(assemblyDef.MainModule.FullyQualifiedName));
                }
            } catch (Exception ex) {
                Log.LogError("Exception while loading assemblies: {0}", ex);
                return(false);
            }
            try {
                foreach (var assembly in topAssemblyReferences)
                {
                    AddAssemblyReferences(resolver, assemblies, assembly, true);
                }
            } catch (Exception ex) {
                Log.LogError("Exception while loading assemblies: {0}", ex);
                return(false);
            }

            // Add I18N assemblies if needed
            AddI18nAssemblies(resolver, assemblies);

            ResolvedAssemblies = assemblies.Select(a => new TaskItem(a)).ToArray();
            // mdb files retain the .dll/.exe, e.g. mscorlib.dll.mdb
            ResolvedMdbFiles = assemblies.Select(a => $"{a}.mdb").Where(File.Exists).Select(a => new TaskItem(a)).ToArray();
            // pdb files have the .dll/.exe removed, e.g. mscorlib.pdb
            ResolvedPdbFiles = assemblies.Select(a => a.Substring(0, a.LastIndexOf('.'))).Select(a => $"{a}.pdb")
                               .Where(File.Exists).Select(a => new TaskItem(a)).ToArray();
            ResolvedConfigFiles         = assemblies.Select(a => $"{a}.config").Where(File.Exists).Select(a => new TaskItem(a)).ToArray();
            ResolvedFrameworkAssemblies = ResolvedAssemblies.Where(p => IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
            ResolvedUserAssemblies      = ResolvedAssemblies.Where(p => !IsFrameworkAssembly(p.ItemSpec, true)).ToArray();

            Log.LogDebugTaskItems("  [Output] ResolvedAssemblies:", ResolvedAssemblies);
            Log.LogDebugTaskItems("  [Output] ResolvedUserAssemblies:", ResolvedUserAssemblies);
            Log.LogDebugTaskItems("  [Output] ResolvedFrameworkAssemblies:", ResolvedFrameworkAssemblies);
            Log.LogDebugTaskItems("  [Output] ResolvedMdbFiles:", ResolvedMdbFiles);
            Log.LogDebugTaskItems("  [Output] ResolvedPdbFiles:", ResolvedPdbFiles);
            Log.LogDebugTaskItems("  [Output] ResolvedConfigFiles:", ResolvedConfigFiles);

            return(!Log.HasLoggedErrors);
        }
Ejemplo n.º 3
0
        string ResolveI18nAssembly(DirectoryAssemblyResolver resolver, string name)
        {
            var assembly = resolver.Resolve(AssemblyNameReference.Parse(name));

            return(Path.GetFullPath(assembly.MainModule.FullyQualifiedName));
        }