|
public Resolve ( Mono.Cecil.AssemblyNameReference name ) : |
||
| name | Mono.Cecil.AssemblyNameReference | |
| return | ||
/// <summary>
/// Check the given dot42.dll wrt forward assemblies.
/// </summary>
internal static void Check(string assemblyPath)
{
// Load dot42.dll
var resolver = new AssemblyResolver(new[] { Path.GetDirectoryName(assemblyPath) })
{
ShowLoading = false
};
var dot42 = resolver.Resolve(Path.GetFileNameWithoutExtension(assemblyPath), new ReaderParameters(ReadingMode.Immediate)
{
ReadSymbols = false
});
// Load forward assemblies
var fwAssemblies = new List <AssemblyDefinition>();
var folder = Path.GetDirectoryName(assemblyPath);
foreach (var path in Directory.GetFiles(folder, "*.dll"))
{
var name = Path.GetFileNameWithoutExtension(path);
if (string.Equals(name, dot42.Name.Name, StringComparison.OrdinalIgnoreCase))
{
continue;
}
var fwAssembly = resolver.Resolve(name, new ReaderParameters(ReadingMode.Immediate)
{
ReadSymbols = false
});
fwAssemblies.Add(fwAssembly);
}
var existingCount = 0;
var missingCount = 0;
// Go over all types
foreach (var type in dot42.MainModule.Types)
{
if (!type.IsPublic)
{
continue;
}
if (!type.Namespace.StartsWith("System"))
{
continue;
}
if (HasForwarder(type, fwAssemblies))
{
existingCount++;
continue;
}
Console.WriteLine("Missing forwarder for {0}", type.FullName);
missingCount++;
}
Console.WriteLine("{0} forwarders missing, {1} found.", missingCount, existingCount);
}
TypeDefinition GetTypeDefinition(string assemblyName, string typeName)
{
ModuleDefinition moduleDefinition;
if (assemblyName == ModuleDefinition.Assembly.Name.Name)
{
moduleDefinition = ModuleDefinition;
}
else
{
var assemblyDefinition = AssemblyResolver.Resolve(assemblyName);
if (assemblyDefinition == null)
{
throw new WeavingException($"Could not find assembly named '{assemblyName}'.");
}
moduleDefinition = assemblyDefinition.MainModule;
}
var typeDefinition = moduleDefinition.GetTypes().FirstOrDefault(x => x.FullName == typeName);
if (typeDefinition == null)
{
throw new WeavingException($"Could not find type named '{typeName}'.");
}
return(typeDefinition);
}
/// <summary>
/// Resolve assembly locations
/// </summary>
/// <returns>List</returns>
public ICollection <string> ResolveAssemblyLocations()
{
IList <string> ret = new List <string>();
// Go through each assembly name
foreach (string assemblyName in _unresolvedAssemblies)
{
try
{
AssemblyDefinition ad = AssemblyResolver.Resolve(assemblyName);
if (ad == null)
{
throw new ILAnalyzerException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.UnableToResolveAssembly, assemblyName), assemblyName);
}
ret.Add(ad.MainModule.Image.FileInformation.FullName);
}
catch (Exception ex)
{
throw new ILAnalyzerException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.UnableToResolveAssembly, assemblyName), assemblyName, ex);
}
}
return(ret);
}
private static void asmRefAdder()
{
var asmResolver = new AssemblyResolver {
EnableTypeDefCache = true
};
var modCtx = new ModuleContext(asmResolver);
asmResolver.DefaultModuleContext = modCtx;
var asmRefs = module.GetAssemblyRefs().ToList();
module.Context = modCtx;
foreach (var asmRef in asmRefs)
{
try
{
if (asmRef == null)
{
continue;
}
var asm = asmResolver.Resolve(asmRef.FullName, module);
if (asm == null)
{
continue;
}
((AssemblyResolver)module.Context.AssemblyResolver).AddToCache(asm);
}
catch
{
}
}
}
// Token: 0x06000164 RID: 356 RVA: 0x00019900 File Offset: 0x00017B00
public static void Fix(ModuleDef moduleDef)
{
AssemblyResolver assemblyResolver = new AssemblyResolver();
ModuleContext moduleContext = new ModuleContext(assemblyResolver);
assemblyResolver.DefaultModuleContext = moduleContext;
assemblyResolver.EnableTypeDefCache = true;
List <AssemblyRef> list = moduleDef.GetAssemblyRefs().ToList <AssemblyRef>();
moduleDef.Context = moduleContext;
foreach (AssemblyRef assemblyRef in list)
{
bool flag = assemblyRef == null;
bool flag2 = !flag;
if (flag2)
{
AssemblyDef assemblyDef = assemblyResolver.Resolve(assemblyRef.FullName, moduleDef);
bool flag3 = assemblyDef == null;
bool flag4 = !flag3;
if (flag4)
{
moduleDef.Context.AssemblyResolver.AddToCache(assemblyDef);
}
}
}
}
private IEnumerable <ModuleDefinition> GetAllModules()
{
var seen = new HashSet <string>();
var queue = new Queue <ModuleDefinition>();
queue.Enqueue(ModuleDefinition);
while (queue.Count > 0)
{
ModuleDefinition module = queue.Dequeue();
yield return(module);
foreach (AssemblyNameReference assemblyReference in module.AssemblyReferences)
{
if (seen.Contains(assemblyReference.FullName))
{
continue;
}
AssemblyDefinition assembly = AssemblyResolver.Resolve(assemblyReference);
if (assembly?.MainModule == null)
{
continue;
}
seen.Add(assembly.FullName);
queue.Enqueue(assembly.MainModule);
}
}
}
void FindMsCoreReferences()
{
var msCoreLibDefinition = AssemblyResolver.Resolve("mscorlib");
msCoreTypes = msCoreLibDefinition.MainModule.Types.ToList();
var objectDefinition = msCoreTypes.FirstOrDefault(x => x.Name == "Object");
if (objectDefinition == null)
{
throw new WeavingException("Only compat with desktop .net");
}
var voidDefinition = msCoreTypes.First(x => x.Name == "Void");
voidTypeReference = ModuleDefinition.ImportReference(voidDefinition);
var dictionary = msCoreTypes.First(x => x.Name == "Dictionary`2");
var dictionaryOfStringOfString = ModuleDefinition.ImportReference(dictionary);
dictionaryOfStringOfStringAdd = ModuleDefinition.ImportReference(dictionaryOfStringOfString.Resolve().Methods.First(m => m.Name == "Add"))
.MakeHostInstanceGeneric(ModuleDefinition.TypeSystem.String, ModuleDefinition.TypeSystem.String);
var list = msCoreTypes.First(x => x.Name == "List`1");
var listOfString = ModuleDefinition.ImportReference(list);
listOfStringAdd = ModuleDefinition.ImportReference(listOfString.Resolve().Methods.First(m => m.Name == "Add"))
.MakeHostInstanceGeneric(ModuleDefinition.TypeSystem.String);
var compilerGeneratedAttribute = msCoreTypes.First(x => x.Name == "CompilerGeneratedAttribute");
compilerGeneratedAttributeCtor = ModuleDefinition.ImportReference(compilerGeneratedAttribute.Methods.First(x => x.IsConstructor));
}
static void Main()
{
AssemblyResolver.Resolve();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ReindexForm());
}
public void LoadSystemTypes()
{
var mscorlib = AssemblyResolver.Resolve("mscorlib");
var typeType = mscorlib.MainModule.Types.FirstOrDefault(x => x.Name == "Type");
if (typeType == null)
{
var runtime = AssemblyResolver.Resolve("System.Runtime");
typeType = runtime.MainModule.Types.First(x => x.Name == "Type");
}
GetTypeFromHandle = typeType.Methods
.First(x => x.Name == "GetTypeFromHandle" &&
x.Parameters.Count == 1 &&
x.Parameters[0].ParameterType.Name == "RuntimeTypeHandle");
GetTypeFromHandle = ModuleDefinition.Import(GetTypeFromHandle);
var stringType = ModuleDefinition.TypeSystem.String.Resolve();
ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
var exceptionType = mscorlib.MainModule.Types.FirstOrDefault(x => x.Name == "Exception");
if (exceptionType == null)
{
var runtime = AssemblyResolver.Resolve("System.Runtime");
exceptionType = runtime.MainModule.Types.First(x => x.Name == "Exception");
}
ExceptionType = ModuleDefinition.Import(exceptionType);
}
public void FindSystemTypes()
{
if (!HideObsoleteMembers)
{
return;
}
try
{
var assemblyDefinition = ModuleDefinition.AssemblyResolver.Resolve("System");
var typeDefinitions = assemblyDefinition.MainModule.Types;
if (typeDefinitions.Any(x => x.Name == "EditorBrowsableAttribute"))
{
FindFromTypes(typeDefinitions);
}
else
{
var systemRuntime = AssemblyResolver.Resolve("System.Runtime");
FindFromTypes(systemRuntime.MainModule.Types);
}
}
catch (Exception)
{
throw new WeavingException("Could not enable HideObsoleteMembers due to problem finding EditorBrowsableAttribute. Disable HideObsoleteMembers and raise an issue detailing what runtime you are compiling against.");
}
}
AssemblyDefinition GetReference(params string[] referenceNames)
{
foreach (var referenceName in referenceNames)
{
var existingReference = ModuleDefinition.AssemblyReferences.FirstOrDefault(x => x.Name == referenceName);
if (existingReference != null)
{
return(AssemblyResolver.Resolve(existingReference));
}
}
foreach (var referenceName in referenceNames)
{
var assemblyDefinition = AssemblyResolver.Resolve(referenceName);
if (assemblyDefinition != null)
{
ModuleDefinition.AssemblyReferences.Add(assemblyDefinition.Name);
return(assemblyDefinition);
}
}
var message = string.Format("Expected to find a reference to one of {0}.", string.Join(",", referenceNames));
throw new Exception(message);
}
private void LoadReferences()
{
var asmResolver = new AssemblyResolver {
EnableTypeDefCache = true
};
var modCtx = new ModuleContext(asmResolver);
asmResolver.DefaultModuleContext = modCtx;
var asmRefs = Module.GetAssemblyRefs().ToList();
Module.Context = modCtx;
foreach (var asmRef in asmRefs)
{
try
{
if (asmRef == null)
{
continue;
}
var asm = asmResolver.Resolve(asmRef.FullName, Module);
if (asm == null)
{
continue;
}
Logger.PrintInfo("Reference : " + asm.FullName);
(Module.Context.AssemblyResolver as AssemblyResolver).AddToCache(asm);
}
catch
{
}
}
}
public void Execute()
{
this.LogInfo = s => { };
this.LogWarning = s => { };
var decorator = new MethodDecorator.Fody.MethodDecorator(this.ModuleDefinition, Config);
foreach (var x in this.ModuleDefinition.AssemblyReferences)
{
AssemblyResolver.Resolve(x);
}
this.DecorateDirectlyAttributed(decorator);
this.DecorateAttributedByImplication(decorator);
if (this.ModuleDefinition.AssemblyReferences.Count(r => r.Name == "mscorlib") > 1)
{
throw new Exception(
String.Format(
"Error occured during IL weaving. The new assembly is now referencing more than one version of mscorlib: {0}",
String.Join(", ", this.ModuleDefinition.AssemblyReferences.Where(r => r.Name == "mscorlib").Select(r => r.FullName))
)
);
}
}
void AddAssemblyIfExists(string name, List <TypeDefinition> types)
{
try
{
var assembly = AssemblyResolver.Resolve(new AssemblyNameReference(name, null));
if (assembly == null)
{
return;
}
var module = assembly.MainModule;
types.AddRange(module.Types.Where(x => x.IsPublic));
var exported = module.ExportedTypes
.Select(x => x.Resolve())
.Where(x => x != null &&
x.IsPublic &&
x.Scope.Name != "System.Private.CoreLib.dll");
types.AddRange(exported);
}
catch (AssemblyResolutionException)
{
LogInfo($"Failed to resolve '{name}'. So skipping its types.");
}
}
public void Execute()
{
var assemblyContainsAttribute = ModuleDefinition.Assembly.CustomAttributes.ContainsAttribute("LogMinimalMessageAttribute");
var moduleContainsAttribute = ModuleDefinition.CustomAttributes.ContainsAttribute("LogMinimalMessageAttribute");
if (assemblyContainsAttribute || moduleContainsAttribute)
{
LogMinimalMessage = true;
}
FindReference();
Init();
var stringType = ModuleDefinition.TypeSystem.String.Resolve();
ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
var msCoreLibDefinition = AssemblyResolver.Resolve("mscorlib");
ExceptionType = ModuleDefinition.Import(msCoreLibDefinition.MainModule.Types.First(x => x.Name == "Exception"));
foreach (var type in ModuleDefinition
.GetTypes()
.Where(x => (x.BaseType != null) && !x.IsEnum && !x.IsInterface))
{
ProcessType(type);
}
//TODO: ensure attributes dont exist on interfaces
RemoveReference();
}
public static void LoadAsmRef()
{
var asmResolver = new AssemblyResolver();
var modCtx = new ModuleContext(asmResolver);
asmResolver.DefaultModuleContext = modCtx;
asmResolver.EnableTypeDefCache = true;
Protections.Base.ModuleDefMD.Location = Path;
var asmRefs = Protections.Base.ModuleDefMD.GetAssemblyRefs();
Protections.Base.ModuleDefMD.Context = modCtx;
foreach (var asmRef in asmRefs)
{
if (asmRef == null)
{
continue;
}
var asma = asmResolver.Resolve(asmRef.FullName, Protections.Base.ModuleDefMD);
// Protections.Protections.ModuleDef.Context.AssemblyResolver.AddToCache(asma);
((AssemblyResolver)Protections.Base.ModuleDefMD.Context.AssemblyResolver).AddToCache(asma);
}
}
private void assemblyReferencesAdder(ModuleDef moduleDefMD)
{
var asmResolver = new AssemblyResolver {
EnableTypeDefCache = true
};
var modCtx = new ModuleContext(asmResolver);
asmResolver.DefaultModuleContext = modCtx;
var asmRefs = moduleDefMD.GetAssemblyRefs();
moduleDefMD.Context = modCtx;
foreach (var asmRef in asmRefs)
{
try
{
if (asmRef == null)
{
continue;
}
var asm = asmResolver.Resolve(asmRef.FullName, moduleDefMD);
if (asm == null)
{
continue;
}
moduleDefMD.Context.AssemblyResolver.AddToCache(asm);
}
catch {}
}
}
void AppendTypes(string name, List <TypeDefinition> coreTypes)
{
var definition = AssemblyResolver.Resolve(new AssemblyNameReference(name, null));
if (definition != null)
{
coreTypes.AddRange(definition.MainModule.Types);
}
}
private void AppendTypes(string name, List <TypeDefinition> coreTypes)
{
AssemblyDefinition definition = AssemblyResolver.Resolve(name);
if (definition != null)
{
coreTypes.AddRange(definition.MainModule.Types);
}
}
public void LoadSystemTypes()
{
var mscorlib = AssemblyResolver.Resolve(new AssemblyNameReference("mscorlib", null));
var typeType = mscorlib?.MainModule.Types.FirstOrDefault(x => x.Name == "Type");
if (typeType == null)
{
var runtime = AssemblyResolver.Resolve(new AssemblyNameReference("System.Runtime", null));
typeType = runtime.MainModule.Types.First(x => x.Name == "Type");
}
var funcDefinition = typeType.Module.Types.FirstOrDefault(x => x.Name == "Func`1");
if (funcDefinition == null)
{
var core = AssemblyResolver.Resolve(new AssemblyNameReference("System.Core", null));
funcDefinition = core.MainModule.Types.First(x => x.Name == "Func`1");
}
var genericInstanceType = new GenericInstanceType(funcDefinition);
genericInstanceType.GenericArguments.Add(ModuleDefinition.TypeSystem.String);
GenericFunc = ModuleDefinition.ImportReference(genericInstanceType);
var methodReference = new MethodReference("Invoke", funcDefinition.FindMethod("Invoke").ReturnType, genericInstanceType)
{
HasThis = true
};
FuncInvokeMethod = ModuleDefinition.ImportReference(methodReference);
GetTypeFromHandle = typeType.Methods
.First(x => x.Name == "GetTypeFromHandle" &&
x.Parameters.Count == 1 &&
x.Parameters[0].ParameterType.Name == "RuntimeTypeHandle");
GetTypeFromHandle = ModuleDefinition.ImportReference(GetTypeFromHandle);
var stringType = mscorlib?.MainModule.Types.FirstOrDefault(x => x.Name == "String");
if (stringType == null)
{
var runtime = AssemblyResolver.Resolve(new AssemblyNameReference("System.Runtime", null));
stringType = runtime.MainModule.Types.First(x => x.Name == "String");
}
ConcatMethod = ModuleDefinition.ImportReference(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.ImportReference(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
var exceptionType = mscorlib?.MainModule.Types.FirstOrDefault(x => x.Name == "Exception");
if (exceptionType == null)
{
var runtime = AssemblyResolver.Resolve(new AssemblyNameReference("System.Runtime", null));
exceptionType = runtime.MainModule.Types.First(x => x.Name == "Exception");
}
ExceptionType = ModuleDefinition.ImportReference(exceptionType);
}
private static void SetupAssemblyResolver(string path)
{
AssemblyResolver resolver = new AssemblyResolver(path);
AppDomain.CurrentDomain.AssemblyResolve +=
delegate(object senderJunk, ResolveEventArgs args) {
Assembly assemblyObj = resolver.Resolve(args.Name);
return(assemblyObj);
};
}
void FindReference()
{
var reference = AssemblyResolver.Resolve(new AssemblyNameReference("log4net", null));
if (reference == null)
{
throw new Exception("Could not resolve a reference to log4net.dll.");
}
Log4NetReference = reference;
}
public void Execute()
{
AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly;
try
{
var assemblyRef = ModuleDefinition.AssemblyReferences.FirstOrDefault(x => x.Name == "Corvalius.ArraySlice");
if (assemblyRef == null)
{
return;
}
var assemblyDefinition = AssemblyResolver.Resolve(assemblyRef);
if (assemblyDefinition == null)
{
LogError("Cannot resolve the Corvalius.ArraySlice assembly.");
return;
}
var typeToFind = assemblyDefinition.MainModule.Types.FirstOrDefault(x => x.Name == "ArraySlice`1");
if (typeToFind == null)
{
LogError("Cannot find an instance of ArraySlice<T> in the referenced assembly '" + assemblyDefinition.Name + "'.");
return;
}
var methodsToProcess = FindMethodsUsingArraySlices(typeToFind);
foreach (var method in methodsToProcess)
{
method.Body.SimplifyMacros();
var occurrences = LocateIntermediateInjectionPoints(method, typeToFind).ToList();
occurrences = PruneUnusedInjectionPoints(method, typeToFind, occurrences).ToList();
occurrences.Reverse();
IntroduceIntermediateVariables(method, occurrences);
method.Body.OptimizeMacros();
method.Body.SimplifyMacros();
ReplaceIndexersCalls(method, occurrences);
method.Body.OptimizeMacros();
}
RemoveAttributes();
}
catch (Exception ex)
{
LogError(ex.Message + Environment.NewLine + "StackTrace: " + ex.StackTrace);
#if DEBUG
Debugger.Launch();
#endif
}
}
private static void Main(string[] args)
{
var pathToAssembly = args[0];
using (var resolver = new AssemblyResolver())
{
var enumerable = resolver.Resolve(pathToAssembly);
var assemblyTuple = BfCache.GetTupleDictionary(enumerable);
using (var bfCache = new BfCache(assemblyTuple))
{
Func <BfMethod, bool> predicate = m => m.FullName.StartsWith(@"System") == false;
var simpleMethods = bfCache.Methods
.Where(predicate)
.Select(m => new SimpleMethod
{
BusinessId = m.MethodId,
Name = m.Name,
FullName = m.FullName,
Type = new SimpleType
{
BusinessId = m.Type.TypeId,
Name = m.Type.Name,
FullName = m.Type.FullName,
Namespace = new SimpleNamespace
{
BusinessId = m.Type.Namespace.NamespaceId,
FullName = m.Type.Namespace.Name
}
},
Calls = m.Calls.Where(predicate).Select(c => new SimpleMethod
{
BusinessId = c.MethodId,
Name = c.Name,
FullName = c.FullName,
Type = new SimpleType
{
BusinessId = c.Type.TypeId,
Name = c.Type.Name,
FullName = c.Type.FullName,
Namespace = new SimpleNamespace
{
BusinessId = c.Type.Namespace.NamespaceId,
FullName = c.Type.Namespace.Name
}
},
Calls = new List <SimpleMethod>()
})
});
new ObjectDumper().DumpAsNeo4J(simpleMethods.ToList());
}
}
}
/// <summary>
/// Find all API enhancements
/// </summary>
internal static void Find(string assemblyPath)
{
var resolver = new AssemblyResolver(new[] { Path.GetDirectoryName(assemblyPath) });
var assembly = resolver.Resolve(Path.GetFileNameWithoutExtension(assemblyPath), new ReaderParameters(ReadingMode.Immediate)
{
ReadSymbols = false
});
FindListenerInterfaces.Find(assembly);
FindRunnableArguments.Find(assembly);
}
public void DefaultResolve()
{
var resolver = new AssemblyResolver();
resolver.Should().NotBeNull();
var assemblies = resolver.Resolve().ToList();
assemblies.Should().NotBeEmpty();
assemblies.Should().Contain(a => a.FullName.StartsWith("System"));
}
protected override void OnStartup(StartupEventArgs e)
{
AssemblyResolver.Resolve();
// First assign the MainWindow to the main form
TMCleanerViewModel viewModel = new TMCleanerViewModel();
MainWindow window = new MainWindow();
window.DataContext = viewModel;
Application.Current.MainWindow = window; // main win
window.Show();
}
/// <summary>
/// Fix the given mscorlib.dll assembly.
/// </summary>
internal static void Fix(string assemblyPath)
{
var resolver = new AssemblyResolver(new[] { Path.GetDirectoryName(assemblyPath) });
var assembly = resolver.Resolve(Path.GetFileNameWithoutExtension(assemblyPath), new ReaderParameters(ReadingMode.Immediate)
{
ReadSymbols = false
});
assembly.Name.Name = "mscorlib";
assembly.Write(assemblyPath);
}
public void DefaultResolve()
{
var resolver = new AssemblyResolver();
resolver.Should().NotBeNull();
var assemblies = resolver.Resolve().ToList();
assemblies.Should().NotBeEmpty();
assemblies.Should().Contain(a => a.FullName.StartsWith("System"));
}
IEnumerable <ModuleDefinition> GetAllModules()
{
yield return(ModuleDefinition);
foreach (var assembly in ModuleDefinition
.AssemblyReferences
.Select(_ => AssemblyResolver.Resolve(_)))
{
yield return(assembly.MainModule);
}
}
void FindExceptionType()
{
var msCoreLibDefinition = AssemblyResolver.Resolve("mscorlib");
var exceptionType = msCoreLibDefinition.MainModule.Types.FirstOrDefault(x => x.Name == "Exception");
if (exceptionType == null)
{
var systemRuntimeDefinition = AssemblyResolver.Resolve("System.Runtime");
exceptionType = systemRuntimeDefinition.MainModule.Types.First(x => x.Name == "Exception");
}
ExceptionType = ModuleDefinition.Import(exceptionType);
}
public void IncludeAssemblyForTestCore()
{
var resolver = new AssemblyResolver();
resolver.Should().NotBeNull();
resolver.IncludeAssemblyFor<SampleWorker>();
var assemblies = resolver.Resolve().ToList();
assemblies.Should().NotBeEmpty();
assemblies.Count.Should().Be(1);
assemblies.Should().Contain(a => a == typeof(SampleWorker).Assembly);
}
public void ExcludeSystem()
{
var domainAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var resolver = new AssemblyResolver();
resolver.Should().NotBeNull();
resolver.ExcludeName("System");
var assemblies = resolver.Resolve().ToList();
assemblies.Should().NotBeEmpty();
assemblies.Should().NotContain(a => a.FullName.StartsWith("System"));
}
IEnumerable<IUnresolvedAssembly> LoadAssemblies()
{
var resolver = new AssemblyResolver();
List<AssemblyDefinition> assemblies = new List<AssemblyDefinition>();
foreach (var file in fileNames.Distinct(StringComparer.OrdinalIgnoreCase))
assemblies.Add(resolver.LoadAssemblyFile(file));
foreach (var asm in assemblies.ToArray())
assemblies.AddRange(asm.Modules.SelectMany(m => m.AssemblyReferences).Select(r => resolver.Resolve(r)));
return assemblies.Distinct().Select(asm => loader.LoadAssembly(asm));
}
