static void Main()
{
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var assemblyPath = Path.Combine(baseDirectory, "ShellAssembly.exe");
var module = ModuleHelper.LoadModule(assemblyPath);
var codeImporter = new CodeImporter(module)
{
HideImportedTypes = false,
ModuleResolver = new AssemblyModuleResolver(
typeof(Microsoft.WindowsAPICodePack.Dialogs.CommonFileDialog).Assembly,
typeof(Microsoft.WindowsAPICodePack.Dialogs.TaskDialog).Assembly,
typeof(Newtonsoft.Json.JsonConvert).Assembly)
};
codeImporter.ILMerge();
var tempPath = TestHelper.TempPath;
var importedModules = codeImporter.ListImportedModules();
foreach (var m in importedModules)
{
foreach (var resource in m.Resources.OfType <EmbeddedResource>())
{
module.Resources.Add(resource);
}
}
var targetAssemblyPath = Path.Combine(tempPath, "ShellAssembly2.exe");
module.Assembly.Name.Name = "ShellAssembly2";
var now = DateTime.Now;
module.Assembly.Name.Version = new Version(now.Year, now.Month, now.Day, (int)now.TimeOfDay.TotalMilliseconds);
module.Write(targetAssemblyPath);
var peVerify = TestHelper.PEVerify.Verify(targetAssemblyPath, line => Console.WriteLine(line));
Assert.True(peVerify);
var importedTypes = codeImporter.ListImportedTypes();
TestHelper.VerifyTypes(importedTypes, importedModules, targetAssemblyPath, AssertIl);
var il = TestHelper.ILDasm.Decompile(targetAssemblyPath);
File.WriteAllText(Path.ChangeExtension(targetAssemblyPath, ".il"), il);
Console.WriteLine("Done - press any key...");
Console.ReadKey();
}
public void ComplexTypesTest(int numberOfTypes, params Type[] types)
{
var module = ModuleHelper.LoadModule <EmptyClass>();
var governingType = types.First();
var target = new CodeImporter(module)
{
// else IL comparison will fail:
HideImportedTypes = false,
CompactMode = false
};
foreach (var type in types)
{
target.Import(type);
}
var tempPath = TestHelper.TempPath;
var targetAssemblyPath = Path.Combine(tempPath, "TargetAssembly2.dll");
module.Write(targetAssemblyPath);
var sourceAssemblyPath = Path.Combine(tempPath, "SourceAssembly2.dll");
var sourceModule = ModuleHelper.LoadModule(new Uri(governingType.Assembly.CodeBase).LocalPath);
sourceModule.Assembly.Name.Name = "SourceAssembly";
sourceModule.Write(sourceAssemblyPath);
var importedTypes = target.ListImportedTypes();
if (importedTypes.Keys.Select(t => t.FullName).Contains("TomsToolbox.Core.NetStandardExtensions"))
{
numberOfTypes += 1;
}
foreach (var type in importedTypes)
{
_testOutputHelper.WriteLine(type.Key.FullName);
}
Assert.Equal(numberOfTypes, importedTypes.Count);
TestHelper.VerifyTypes(importedTypes, target.ListImportedModules(), targetAssemblyPath);
Assert.True(TestHelper.PEVerify.Verify(targetAssemblyPath, _testOutputHelper));
}
public override void Execute()
{
#if DEBUG && LAUNCH_DEBUGGER
System.Diagnostics.Debugger.Launch();
#endif
var includeAssemblies = BuildRegex(ReadConfigValue("IncludeAssemblies", string.Empty));
var excludeAssemblies = BuildRegex(ReadConfigValue("ExcludeAssemblies", string.Empty));
var includeResources = BuildRegex(ReadConfigValue("IncludeResources", string.Empty));
var excludeResources = BuildRegex(ReadConfigValue("ExcludeResources", string.Empty));
var hideImportedTypes = ReadConfigValue("HideImportedTypes", true);
var namespacePrefix = ReadConfigValue("NamespacePrefix", string.Empty);
var compactMode = ReadConfigValue("CompactMode", false);
var fullImport = ReadConfigValue("FullImport", false);
var isDotNetCore = ModuleDefinition.IsTargetFrameworkDotNetCore();
var references = isDotNetCore ? (IList <string>)References.Split(';') : ReferenceCopyLocalPaths;
var codeImporter = new CodeImporter(ModuleDefinition)
{
ModuleResolver = new LocalReferenceModuleResolver(this, references, includeAssemblies, excludeAssemblies),
HideImportedTypes = hideImportedTypes,
NamespaceDecorator = name => namespacePrefix + name,
CompactMode = compactMode && !fullImport,
};
codeImporter.ILMerge();
var importedModules = codeImporter.ListImportedModules();
if (fullImport)
{
importedModules = ImportRemainingTypes(importedModules, codeImporter);
}
ValidateBamlReferences(ModuleDefinition, importedModules);
ImportResources(ModuleDefinition, importedModules, includeResources, excludeResources, this);
var importedReferences = new HashSet <string>(importedModules.Select(moduleDefinition => Path.GetFileNameWithoutExtension(moduleDefinition.FileName)), StringComparer.OrdinalIgnoreCase);
bool IsImportedReference(string path)
{
return(importedReferences.Contains(Path.GetFileNameWithoutExtension(path)));
}
ReferenceCopyLocalPaths.RemoveAll(IsImportedReference);
RuntimeCopyLocalPaths.RemoveAll(IsImportedReference);
}
public void SimpleTypesTest(int numberOfTypes, ModuleResolver moduleResolver, params Type[] types)
{
var module = ModuleHelper.LoadModule <EmptyClass>();
var moduleResolverInstance = moduleResolver == ModuleResolver.AssemblyModuleResolver
? (IModuleResolver) new AssemblyModuleResolver(typeof(TomsToolbox.Core.AssemblyExtensions).Assembly, typeof(TomsToolbox.Core.DefaultValue).Assembly)
: new LocalReferenceModuleResolver();
var targetAssemblyPath = Path.Combine(TestHelper.TempPath, "TargetAssembly1.dll");
var target = new CodeImporter(module)
{
ModuleResolver = moduleResolverInstance,
HideImportedTypes = false,
CompactMode = false
};
foreach (var type in types)
{
target.Import(type);
}
module.Write(targetAssemblyPath);
var importedTypes = target.ListImportedTypes();
foreach (var type in importedTypes)
{
_testOutputHelper.WriteLine(type.Key.FullName);
}
var importedModules = target.ListImportedModules();
Assert.True(TestHelper.PEVerify.Verify(targetAssemblyPath, _testOutputHelper));
Assert.Equal(numberOfTypes, importedTypes.Count);
TestHelper.VerifyTypes(importedTypes, importedModules, targetAssemblyPath);
}
private static ICollection <ModuleDefinition> ImportRemainingTypes(ICollection <ModuleDefinition> importedModules, CodeImporter codeImporter)
{
var updatedModules = new HashSet <ModuleDefinition>();
while (true)
{
var modulesToUpdate = importedModules.Except(updatedModules).ToList();
if (!modulesToUpdate.Any())
{
break;
}
foreach (var type in modulesToUpdate.SelectMany(module => module.GetTypes().Where(t => t.Name != "<Module>")))
{
codeImporter.ImportType(type, null);
}
updatedModules = new HashSet <ModuleDefinition>(updatedModules.Concat(modulesToUpdate));
importedModules = codeImporter.ListImportedModules();
}
return(importedModules);
}