IAssemblyResolver GetAssemblyResolver() { if (test_case.AssemblyResolver != null) { return(test_case.AssemblyResolver); } test_resolver = new DefaultAssemblyResolver(); var directory = Path.GetDirectoryName(test_case.ModuleLocation); test_resolver.AddSearchDirectory(directory); return(test_resolver); }
/// <summary> /// Returns a new assembly resolver. /// </summary> private IAssemblyResolver GetAssemblyResolver() { // TODO: can we reuse it, or do we need a new one for each assembly? var assemblyResolver = new DefaultAssemblyResolver(); // Add known search directories for resolving assemblies. assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(typeof(ControlledTask).Assembly.Location)); assemblyResolver.AddSearchDirectory(this.Configuration.AssembliesDirectory); // Add the assembly resolution error handler. assemblyResolver.ResolveFailure += OnResolveAssemblyFailure; return(assemblyResolver); }
private void LoadModules() { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(_file.DirectoryName); var parameters = new ReaderParameters { AssemblyResolver = resolver, }; _module = ModuleDefinition.ReadModule(_file.FullName, parameters); }
public CecilSymbolHelperTests() { var location = GetType().Assembly.Location; var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(location)); var parameters = new ReaderParameters { ReadSymbols = true, AssemblyResolver = resolver }; _module = ModuleDefinition.ReadModule(location, parameters); _cecilSymbolHelper = new CecilSymbolHelper(); }
private static AssemblyDefinition[] LoadAssemblies(string packageDirectory) { var assemblyDirectory = PathConstruction.Combine(packageDirectory, "tools"); var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(assemblyDirectory); return(PathConstruction.GlobFiles(assemblyDirectory, "docfx.exe") .Select(x => AssemblyDefinition.ReadAssembly(x, new ReaderParameters { AssemblyResolver = assemblyResolver })) .ToArray()); }
public DllMerger(MergeOptions options) { var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(options.Executable)); var assembly = AssemblyDefinition.ReadAssembly(options.Executable, new ReaderParameters() { AssemblyResolver = assemblyResolver }); _assembly = assembly; _options = options; }
private static AssemblyDefinition GetAssembly(string location) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(typeof(IPropertyContainer).Assembly.Location)); return(AssemblyDefinition.ReadAssembly( location, new ReaderParameters() { AssemblyResolver = resolver })); }
private static ReaderParameters GetReaderParameters(string folder) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(folder); var parameters = new ReaderParameters { AssemblyResolver = resolver, }; return(parameters); }
public void InitializeTest() { if (!initialized) { var weaver = new NotificationWeaver(TestNotifierPath); weaver.InsertNotifications(true); initialized = true; } this.assemblyResolver = new DefaultAssemblyResolver(); this.assemblyResolver.AddSearchDirectory(ApplicationPath); this.metadataResolver = new MetadataResolver(assemblyResolver); }
public ModuleDefinition ReadModuleDefinition(string path) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(ManagedFolder); ModuleDefinition module = ModuleDefinition.ReadModule(path, new ReaderParameters() { AssemblyResolver = resolver, }); return(module); }
protected ModuleDefinition read_module(string path, bool readOnly) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(path)); var rp = new ReaderParameters { ReadWrite = !readOnly, AssemblyResolver = resolver }; return(ModuleDefinition.ReadModule(path, rp)); }
void patch_dll() { try { var temp_path = temp_base + "patch.dll"; File.Copy(dll_path, temp_path, true); var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(dlls_path); var reader = new ReaderParameters() { AssemblyResolver = resolver }; var game_dll = AssemblyDefinition.ReadAssembly(temp_path, reader).MainModule; var welcome = game_dll.Types.Single(t => t.Name == "WelcomeScript"); var labels = welcome.Resolve().Fields.Single(f => f.Name == "FlashingLabels"); labels.IsPrivate = false; labels.IsPublic = true; labels.Attributes = Mono.Cecil.FieldAttributes.Public; var csharp_dll = AssemblyDefinition.ReadAssembly(dlls_path + "Assembly-CSharp-firstpass.dll", reader); var ui_label = csharp_dll.MainModule.Types.Single(t => t.Name == "UILabel"); var set_text = ui_label.Methods.Single(m => m.Name == "set_text"); var setref = game_dll.ImportReference(set_text); var start = welcome.Methods.Single(m => m.Name == "Start"); var il2 = start.Body.GetILProcessor(); il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Callvirt, setref)); il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldstr, "Warning ! Do not submit bug reports, Yandere Loader is loaded !")); il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldelem_Ref)); il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldc_I4_2)); il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldfld, labels)); il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldarg_0)); game_dll.Write(dll_path); } catch (Exception e) { write_line("[CRITICAL]: Failed to patch dll: " + e.ToString()); Application.Exit(); } }
public IEnumerable <SdkFunctionMetadata> GenerateFunctionMetadata(string assemblyPath, IEnumerable <string> referencePaths) { string sourcePath = Path.GetDirectoryName(assemblyPath); string[] targetAssemblies = Directory.GetFiles(sourcePath, "*.dll"); var functions = new List <SdkFunctionMetadata>(); _logger.LogMessage($"Found { targetAssemblies.Length} assemblies to evaluate in '{sourcePath}':"); foreach (var path in targetAssemblies) { using (_logger.Indent()) { _logger.LogMessage($"{Path.GetFileName(path)}"); using (_logger.Indent()) { try { BaseAssemblyResolver resolver = new DefaultAssemblyResolver(); foreach (string referencePath in referencePaths.Select(p => Path.GetDirectoryName(p)).Distinct()) { resolver.AddSearchDirectory(referencePath); } resolver.AddSearchDirectory(Path.GetDirectoryName(path)); ReaderParameters readerParams = new ReaderParameters { AssemblyResolver = resolver }; var moduleDefintion = ModuleDefinition.ReadModule(path, readerParams); functions.AddRange(GenerateFunctionMetadata(moduleDefintion)); } catch (BadImageFormatException) { _logger.LogMessage($"Skipping file '{Path.GetFileName(path)}' because of a {nameof(BadImageFormatException)}."); } catch (Exception ex) { _logger.LogWarning($"Could not evaluate '{Path.GetFileName(path)}' for functions metadata. Exception message: {ex.ToString()}"); } } } } return(functions); }
public static RuntimeInitializeOnLoadMethodsData ExtractPlayerRuntimeInitializeOnLoadMethods(BuildTarget targetPlatform, string[] assemblyPaths, string[] searchDirs) { var classInfoList = new List <RuntimeInitializeClassInfo>(); int methodCount = 0; foreach (var assemblyPath in assemblyPaths) { try { var assemblyResolverData = new GetAssemblyResolverData { SearchDirs = searchDirs, }; var resolver = new DefaultAssemblyResolver(); foreach (var searchDir in searchDirs) { resolver.AddSearchDirectory(searchDir); } assemblyResolverData.Resolver = resolver; var assembly = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters { AssemblyResolver = assemblyResolverData.Resolver }); var assemblyName = assembly.Name.Name; foreach (var module in assembly.Modules) { foreach (var type in module.Types) { FindRuntimeInitializeOnLoadMethodAttributes(type, assemblyName, ref classInfoList, ref methodCount); } } } catch (Exception ex) { throw new Exception("ExtractPlayerRuntimeInitializeOnLoadMethods: Failed to process " + assemblyPath + ", " + ex); } } var data = new RuntimeInitializeOnLoadMethodsData(); data.classInfos = classInfoList.ToArray(); data.methodsCount = methodCount; return(data); }
public static void addProfiler(string assemblyPath, string fileName, string typeName, string methodName) { if (Application.isPlaying || EditorApplication.isCompiling) { Debug.Log("You need stop play mode or wait compiling finished"); return; } if (!System.IO.File.Exists(assemblyPath + fileName)) { Debug.Log("This Project didn't contains this dll"); return; } var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(assemblyPath); var readerParameters = new ReaderParameters { ReadSymbols = false, AssemblyResolver = resolver }; var assembly = AssemblyDefinition.ReadAssembly(assemblyPath + fileName, readerParameters); if (assembly == null) { Debug.LogError("InjectTool Inject Load assembly failed: " + assemblyPath); return; } try { ProcessAssembly(assembly, typeName, methodName); assembly.Write(assemblyPath + fileName, new WriterParameters { WriteSymbols = false }); Debug.Log("Listening function " + methodName + " successfully!"); } catch (Exception ex) { Debug.LogError("InjectTool addProfiler failed: " + ex); throw; } finally { if (assembly.MainModule.SymbolReader != null) { Debug.Log("InjectTool addProfiler Succeed"); assembly.MainModule.SymbolReader.Dispose(); } } // Debug.Log("InjectTool Inject" + fileName + " End"); }
static void Main() { string managedPath = PathDiscovery.FindManagedDirectory(); var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(managedPath); Version version = GetUnityVersion(); // as of Unity 2017.2, the UnityEngine assembly has been split into multiple assemblies // the assembly containing the GameObject class is UnityEngine.CoreModule string coreName = version.Major < 2017 || (version.Major == 2017 && version.Minor == 1) ? "UnityEngine" : "UnityEngine.CoreModule"; string corePath = PathDiscovery.GetAssemblyPath(resolver, coreName); byte[] coreData = File.ReadAllBytes(corePath); Console.WriteLine("Unity {0} detected.", version); ModuleDefinition unityCore = ModuleDefinition.ReadModule( new MemoryStream(coreData), new ReaderParameters { AssemblyResolver = resolver }); TypeDefinition gameObject = unityCore.GetType("UnityEngine", "GameObject"); // UPM works by adding a static constructor to the GameObject class, // which calls an initialization function in PluginManager.Core SetStaticCtor(gameObject, GenStaticCtor(unityCore, il => { ModuleDefinition upm = ModuleDefinition.ReadModule(CoreLibrary); TypeDefinition upmMain = upm.GetType("PluginManager.Core", "PluginManager"); MethodDefinition upmInit = upmMain.Methods.Single(m => m.Name == "Initialize"); il.Emit(OpCodes.Call, unityCore.ImportReference(upmInit)); il.Emit(OpCodes.Ret); upm.Dispose(); })); unityCore.Write(corePath); // We need to copy PluginManager.Core.dll into the Managed directory File.Copy(CoreLibrary, Path.Combine(managedPath, CoreLibrary), true); Console.WriteLine("UPM installed."); }
public void Execute() { if (!string.IsNullOrEmpty(AddinDirectoryPath)) //it is not empty when triggered from MS Build (Fody) { List <string> localRefDirs = new List <string>(); foreach (var refCopyLocalPath in ReferenceCopyLocalPaths) { localRefDirs.Add(Directory.GetParent(refCopyLocalPath).FullName); } var defAssemblyResolver = new DefaultAssemblyResolver(); defAssemblyResolver.AddSearchDirectory(AddinDirectoryPath); localRefDirs.ForEach(refDir => defAssemblyResolver.AddSearchDirectory(refDir)); AssemblyResolver = defAssemblyResolver; } else //for testing { AssemblyResolver = ModuleDefinition.AssemblyResolver; } ReferencedModules = new List <ModuleDefinition>(); foreach (var assemblyRef in ModuleDefinition.AssemblyReferences) { var refModuleDefinition = AssemblyResolver.Resolve(assemblyRef).MainModule; ReferencedModules.Add(refModuleDefinition); } TestFlaskAspectsModule = ResolveTestFlaskAspectsModuleDefinition(); typeSystem = ModuleDefinition.TypeSystem; var playableMethods = ModuleDefinition.GetAllTypes().SelectMany( t => t.Methods.Where( md => md.CustomAttributes.Any(ca => ca.AttributeType.Name.Equals("PlaybackAttribute"))) ).ToList(); foreach (var playableMethod in playableMethods) { var playbackAttr = playableMethod.CustomAttributes.Single(ca => ca.AttributeType.Name.Equals("PlaybackAttribute")); TypeDefinition requestIdentifierTypeDef = playbackAttr.ConstructorArguments[0].Value as TypeDefinition; TypeDefinition responseIdentifierTypeDef = playbackAttr.ConstructorArguments[1].Value as TypeDefinition; var clonePlayableMethod = CloneOriginalMethod(playableMethod); DecorateMethod(playableMethod, clonePlayableMethod, requestIdentifierTypeDef, responseIdentifierTypeDef); } }
//[PostProcessScene]//打包的时候会自动调用下面方法注入代码 static void AssemblyPostProcessorRun() { try { Debug.Log("AssemblyPostProcessor running"); EditorApplication.LockReloadAssemblies(); DefaultAssemblyResolver assemblyResolver = new DefaultAssemblyResolver(); foreach (System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assembly.Location)); } assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(EditorApplication.applicationPath) + "/Data/Managed"); ReaderParameters readerParameters = new ReaderParameters(); readerParameters.AssemblyResolver = assemblyResolver; WriterParameters writerParameters = new WriterParameters(); foreach (String assemblyPath in assemblyPathss) { readerParameters.ReadSymbols = true; readerParameters.SymbolReaderProvider = new Mono.Cecil.Mdb.MdbReaderProvider(); writerParameters.WriteSymbols = true; writerParameters.SymbolWriterProvider = new Mono.Cecil.Mdb.MdbWriterProvider(); AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters); Debug.Log("Processing " + Path.GetFileName(assemblyPath)); if (HookEditor.ProcessAssembly(assemblyDefinition)) { Debug.Log("Writing to " + assemblyPath); assemblyDefinition.Write(assemblyPath, writerParameters); Debug.Log("Done writing"); } else { Debug.Log(Path.GetFileName(assemblyPath) + " didn't need to be processed"); } } } catch (Exception e) { Debug.LogWarning(e); } EditorApplication.UnlockReloadAssemblies(); }
// It's important that this logic remains in a separate function, // otherwise the Mono.Cecil and GamePluginKit.API assemblies // will be resolved before the custom resolver is registered. static void LoadPluginAssemblies(Transform root, string directory, SearchOption searchOption) { using (var resolver = new DefaultAssemblyResolver()) { foreach (string searchPath in SearchPaths) { resolver.AddSearchDirectory(searchPath); } var readParams = new ReaderParameters { AssemblyResolver = resolver }; foreach (string filePath in Directory.GetFiles(directory, "*.dll", searchOption)) { // Mono.Cecil is used to inspect the attributes for a very important reason. // If a plugin assembly contains attributes that are not present in the game's // assemblies (for example, TargetFrameworkAttribute when using the old Mono runtime) // the game will throw an exception when calling Assembly.GetCustomAttributes. using (var asmDef = AssemblyDefinition.ReadAssembly(filePath, readParams)) { var assembly = Assembly.LoadFrom(filePath); foreach (var attribute in asmDef.CustomAttributes) { try { if (attribute.AttributeType.FullName != "GamePluginKit.StartupBehaviourAttribute") { continue; } // Retrieve the behaviour type var typeRef = attribute.ConstructorArguments[0].Value as TypeReference; var typeName = Assembly.CreateQualifiedName(typeRef.Module.Assembly.FullName, typeRef.FullName); var behaviour = Type.GetType(typeName); new GameObject(behaviour.Name, behaviour).transform.SetParent(root); } catch (Exception ex) { Debug.LogException(ex); } } } } } }
internal void Compile(string assembly) { resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(assembly)); var basm = AssemblyDefinition.ReadAssembly(assembly, new ReaderParameters { AssemblyResolver = resolver }); var allasm = FindRefs(basm); foreach (var asm in allasm) { WriteLine(asm.FullName); } }
public static AssemblyDef LoadFrom(string path) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(path)); var assemblyDef = AssemblyDefinition.ReadAssembly( path, new ReaderParameters { AssemblyResolver = resolver }); return(new AssemblyDef(assemblyDef.MainModule)); }
public void ApplyToAssembly(Stream assemblyStream) { var assemblyResolver = new DefaultAssemblyResolver(); var assemblyDefinitions = new Dictionary <string, AssemblyDefinition>(StringComparer.OrdinalIgnoreCase); foreach (var assemblyName in Instance.GetAssembliesForScanning()) { var assembly = assemblyResolver.Resolve(new AssemblyNameReference(assemblyName, null)); if (assembly == null) { continue; } if (assemblyDefinitions.ContainsKey(assemblyName)) { continue; } assemblyDefinitions.Add(assemblyName, assembly); } TypeResolver.Initialise(assemblyDefinitions.Values); var module = ModuleDefinition.ReadModule(assemblyStream); Instance.ModuleDefinition = module; Instance.FindType = TypeResolver.FindType; Instance.TryFindType = TypeResolver.TryFindType; Instance.ResolveAssembly = assemblyName => assemblyResolver.Resolve(new AssemblyNameReference(assemblyName, null)); var errors = new List <string>(); Instance.LogError = s => { Debug.WriteLine($" Error: {s}"); errors.Add(s); }; Instance.LogWarning = s => Debug.WriteLine($" Warning: {s}"); Instance.LogInfo = s => Debug.WriteLine($" Info: {s}"); Instance.LogDebug = s => Debug.WriteLine($" Debug: {s}"); Instance.Execute(); if (errors.Any()) { throw new WeaverErrorException(errors); } Instance.AfterWeaving(); assemblyStream.Position = 0; module.Write(assemblyStream); }
static void Main(string[] args) { var resolver = new DefaultAssemblyResolver(); var module = resolver.Resolve(Assembly.GetExecutingAssembly().FullName).MainModule; Console.WriteLine("For HelperClass<>"); var helperClass = module.Import(typeof(HelperClass <>)).Resolve(); var someMethod = helperClass.Methods[0]; var someMethodBody = someMethod.Body; foreach (var instruction in someMethodBody.Instructions) { Console.WriteLine( "{0}\t{1}\t{2}", instruction.Offset, instruction.OpCode.Code, instruction.Operand == null ? "<null>" : string.Format("{0} / {1}", instruction.Operand.GetType().FullName, instruction.Operand.ToString())); var fieldReference = instruction.Operand as FieldReference; if (fieldReference != null) { var fieldDefinition = fieldReference.Resolve(); Console.WriteLine( "\t\tResolved field reference operand: {0} / {1}", fieldDefinition.GetType().FullName, fieldDefinition.ToString()); } } Console.WriteLine(""); Console.WriteLine("For HelperClass<int>"); helperClass = module.Import(typeof(HelperClass <int>)).Resolve(); someMethod = helperClass.Methods[0]; someMethodBody = someMethod.Body; foreach (var instruction in someMethodBody.Instructions) { Console.WriteLine( "{0}\t{1}\t{2}", instruction.Offset, instruction.OpCode.Code, instruction.Operand == null ? "<null>" : string.Format("{0} / {1}", instruction.Operand.GetType().FullName, instruction.Operand.ToString())); var fieldReference = instruction.Operand as FieldReference; if (fieldReference != null) { var fieldDefinition = fieldReference.Resolve(); Console.WriteLine( "\t\tResolved field reference operand: {0} / {1}", fieldDefinition.GetType().FullName, fieldDefinition.ToString()); } } }
public void Variant() { var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "ScriptBuilder.Tests.dll"); var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(TestContext.CurrentContext.TestDirectory); var readerParameters = new ReaderParameters(ReadingMode.Deferred) { AssemblyResolver = assemblyResolver }; var module = ModuleDefinition.ReadModule(path, readerParameters); ObjectApprover.VerifyWithJson(SqlVariantReader.Read(module).ToList()); }
/// <summary> /// Writes the module <paramref name="module"/> to the file specified by the path <paramref name="moduleFilePath"/> /// </summary> /// <param name="module"></param> /// <param name="moduleFilePath"></param> public static void WriteModule(ModuleDefinition module, String moduleFilePath) { // Quick fix for AssemblyResolutionException // occurring in RequestReduce and Newtonsoft.Json projects // detailed info documented in challenges.txt // TODO: Check if there is more elegant solution if (module.AssemblyResolver is DefaultAssemblyResolver) { DefaultAssemblyResolver resolver = module.AssemblyResolver as DefaultAssemblyResolver; resolver.AddSearchDirectory(System.IO.Path.GetDirectoryName(module.FullyQualifiedName)); } module.Write(moduleFilePath); UpdateModuleDictionary(module, moduleFilePath); }
public static IEnumerable <ExtensionReference> GenerateExtensionReferences(string fileName, ConsoleLogger logger) { BaseAssemblyResolver resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(fileName)); ReaderParameters readerParams = new ReaderParameters { AssemblyResolver = resolver }; AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(fileName, readerParams); var startupAttributes = assembly.Modules.SelectMany(p => p.GetCustomAttributes()) .Where(a => IsWebJobsStartupAttributeType(a.AttributeType, logger)); List <ExtensionReference> extensionReferences = new List <ExtensionReference>(); foreach (var attribute in startupAttributes) { var typeProperty = attribute.ConstructorArguments.ElementAtOrDefault(0); var nameProperty = attribute.ConstructorArguments.ElementAtOrDefault(1); TypeDefinition typeDef = (TypeDefinition)typeProperty.Value; string assemblyQualifiedName = Assembly.CreateQualifiedName(typeDef.Module.Assembly.FullName, GetReflectionFullName(typeDef)); string name; // Because we're now using static analysis we can't rely on the constructor running so have to get the name ourselves. if (string.Equals(attribute.AttributeType.FullName, FunctionsStartupAttributeType, StringComparison.OrdinalIgnoreCase)) { // FunctionsStartup always uses the type name as the name. name = typeDef.Name; } else { // WebJobsStartup does some trimming. name = GetName((string)nameProperty.Value, typeDef); } var extensionReference = new ExtensionReference { Name = name, TypeName = assemblyQualifiedName }; extensionReferences.Add(extensionReference); } return(extensionReferences); }
public void RunInject(string assemblyPath, string assemblyName) { OnProgressChanged(assemblyName, 0f); string fullName = Utility.Path.GetCombinePath(assemblyPath, assemblyName); if (!File.Exists(fullName)) { Debug.LogWarning(string.Format("Assembly '{0}' does not exist.", fullName)); return; } DefaultAssemblyResolver resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(fullName)); ModuleDefinition moduleDefinition = ModuleDefinition.ReadModule(fullName, new ReaderParameters { AssemblyResolver = resolver }); Collection <TypeDefinition> typeDefinitions = moduleDefinition.Types; int typeCount = typeDefinitions.Count; if (typeCount <= 0) { return; } int index = 0; foreach (TypeDefinition typeDefinition in typeDefinitions) { if (NeedInject(typeDefinition)) { Collection <MethodDefinition> methodDefinitions = typeDefinition.Methods; foreach (MethodDefinition methodDefinition in methodDefinitions) { if (NeedInject(methodDefinition)) { InjectMethod(typeDefinition, methodDefinition); } } } OnProgressChanged(assemblyName, ++index / (float)typeCount); } moduleDefinition.Write(fullName, new WriterParameters { WriteSymbols = true }); }
/// <summary> /// 获取程序集反射器 /// </summary> /// <param name="path"></param> /// <returns></returns> public MonoAssemblyReflector LoadAssembly(string path) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(path)); var reader = new ReaderParameters() { AssemblyResolver = resolver }; var assembly = AssemblyDefinition.ReadAssembly(path, reader); return(new MonoAssemblyReflector(assembly)); }
// Well played assembly resolver, you have escaped death this time public static IAssemblyResolver GetAssemblyResolver() { DefaultAssemblyResolver resolver = new DefaultAssemblyResolver(); if (Environment.OSVersion.Platform == PlatformID.Win32NT) { foreach (string xnaDirectory in xnaDirectories) { resolver.AddSearchDirectory(GetDirectoryFromGAC(xnaDirectory)); } } return(resolver); }
void RunTest(string name, string asmPath, string sourcePath) { var resolver = new DefaultAssemblyResolver(); var assembly = AssemblyDefinition.ReadAssembly(asmPath, new ReaderParameters { AssemblyResolver = resolver, InMemory = true }); Resource res = assembly.MainModule.Resources.First(); Stream bamlStream = LoadBaml(res, name + ".baml"); Assert.IsNotNull(bamlStream); XDocument document = BamlResourceEntryNode.LoadIntoDocument(resolver, assembly, bamlStream, CancellationToken.None); XamlIsEqual(File.ReadAllText(sourcePath), document.ToString()); }
protected virtual ICollection<IUnitTestElement> GetUnitTestElements(IProject testProject, string assemblyLocation) { var observer = new TestUnitTestElementObserver(); var resolver = new DefaultAssemblyResolver(); resolver.AddPath(FileSystemPath.Parse(assemblyLocation).Directory); using (var loader = new MetadataLoader(resolver)) { MetadataExplorer.ExploreProjects( new Dictionary<IProject, FileSystemPath> { {testProject, FileSystemPath.Parse(assemblyLocation)} }, loader, observer, CancellationToken.None); } return observer.Elements; }
ModuleDefinition GetModule() { var location = test_case.ModuleLocation; var directory = Path.GetDirectoryName (location); var resolver = new DefaultAssemblyResolver (); resolver.AddSearchDirectory (directory); var parameters = new ReaderParameters { SymbolReaderProvider = GetSymbolReaderProvider (), AssemblyResolver = resolver, }; switch (type) { case TestCaseType.ReadImmediate: parameters.ReadingMode = ReadingMode.Immediate; return ModuleDefinition.ReadModule (location, parameters); case TestCaseType.ReadDeferred: parameters.ReadingMode = ReadingMode.Deferred; return ModuleDefinition.ReadModule (location, parameters); case TestCaseType.WriteFromImmediate: parameters.ReadingMode = ReadingMode.Immediate; return RoundTrip (location, parameters, "cecil-irt"); case TestCaseType.WriteFromDeferred: parameters.ReadingMode = ReadingMode.Deferred; return RoundTrip (location, parameters, "cecil-drt"); default: return null; } }
IAssemblyResolver GetAssemblyResolver () { if (test_case.AssemblyResolver != null) return test_case.AssemblyResolver; var resolver = new DefaultAssemblyResolver (); var directory = Path.GetDirectoryName (test_case.ModuleLocation); resolver.AddSearchDirectory (directory); return resolver; }