public static AssemblyDefinition GetAssemblyDef(string assemblyPath) { if (assemblies.ContainsKey(assemblyPath)) return assemblies[assemblyPath]; var assemblyResolver = new DefaultAssemblyResolver(); var assemblyLocation = Path.GetDirectoryName(assemblyPath); assemblyResolver.AddSearchDirectory(assemblyLocation); var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver }; var pdbName = Path.ChangeExtension(assemblyPath, "pdb"); if (File.Exists(pdbName)) { var symbolReaderProvider = new PdbReaderProvider(); readerParameters.SymbolReaderProvider = symbolReaderProvider; readerParameters.ReadSymbols = true; } var assemblyDef = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters); assemblies.Add(assemblyPath,assemblyDef); return assemblyDef; }
public void LoadAsm(string f) { source = f; var ar = new DefaultAssemblyResolver(); ar.AddSearchDirectory(Path.GetDirectoryName(f)); string[] searchDirs = new string[] { @"C:\Program Files\Reference Assemblies", @"C:\Program Files (x86)\Reference Assemblies" }; foreach (string sd in searchDirs) if (Directory.Exists(sd)) ar.AddSearchDirectory(sd); ar.ResolveFailure += new AssemblyResolveEventHandler(ResolveFailure); ReaderParameters rp = new ReaderParameters() { AssemblyResolver = ar }; assembly = AssemblyDefinition.ReadAssembly(source, rp); LoadAssemblyTree(); }
static FodyAssemblyPostProcessor() { try { //Debug.Log( "Fody processor running" ); // Lock assemblies while they may be altered EditorApplication.LockReloadAssemblies(); var assetPath = Path.GetFullPath(Application.dataPath); // This will hold the paths to all the assemblies that will be processed HashSet<string> assemblyPaths = new HashSet<string>(); // This will hold the search directories for the resolver HashSet<string> assemblySearchDirectories = new HashSet<string>(); // Add all assemblies in the project to be processed, and add their directory to // the resolver search directories. foreach( System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies() ) { // Only process assemblies which are in the project if( assembly.Location.Replace( '\\', '/' ).StartsWith( Application.dataPath.Substring( 0, Application.dataPath.Length - 7 ) ) && !Path.GetFullPath(assembly.Location).StartsWith(assetPath)) //but not in the assets folder { assemblyPaths.Add( assembly.Location ); } // But always add the assembly folder to the search directories assemblySearchDirectories.Add( Path.GetDirectoryName( assembly.Location ) ); } // Create resolver var assemblyResolver = new DefaultAssemblyResolver(); // Add all directories found in the project folder foreach( String searchDirectory in assemblySearchDirectories ) { assemblyResolver.AddSearchDirectory( searchDirectory ); } // Add path to the Unity managed dlls assemblyResolver.AddSearchDirectory( Path.GetDirectoryName( EditorApplication.applicationPath ) + "/Data/Managed" ); ProcessAssembliesIn(assemblyPaths, assemblyResolver); // Unlock now that we're done EditorApplication.UnlockReloadAssemblies(); } catch( Exception e ) { Debug.LogError( e ); } //Debug.Log("Fody processor finished"); }
public static AssemblyDefinition Load(string fileName) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(new FileInfo(fileName).DirectoryName); var parameters = new ReaderParameters { SymbolReaderProvider = new PdbReaderProvider(), ReadingMode = ReadingMode.Immediate, AssemblyResolver = resolver }; AssemblyDefinition assemblyDef; try { assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters); } catch (FileNotFoundException) { // Perhaps we have an MDB file (Mono), or there is no symbol file to load. // Try MDB first! parameters.SymbolReaderProvider = new MdbReaderProvider(); try { assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters); } catch (FileNotFoundException) { parameters.SymbolReaderProvider = null; assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters); } } return assemblyDef; }
public static string GenerateBlackList(string librariesFolder, RuntimeClassRegistry usedClasses, string[] allAssemblies) { string text = "tmplink.xml"; usedClasses.SynchronizeClasses(); using (TextWriter textWriter = new StreamWriter(Path.Combine(librariesFolder, text))) { textWriter.WriteLine("<linker>"); textWriter.WriteLine("<assembly fullname=\"UnityEngine\">"); foreach (string current in usedClasses.GetAllManagedClassesAsString()) { textWriter.WriteLine(string.Format("<type fullname=\"UnityEngine.{0}\" preserve=\"{1}\"/>", current, usedClasses.GetRetentionLevel(current))); } textWriter.WriteLine("</assembly>"); DefaultAssemblyResolver defaultAssemblyResolver = new DefaultAssemblyResolver(); defaultAssemblyResolver.AddSearchDirectory(librariesFolder); for (int i = 0; i < allAssemblies.Length; i++) { string path = allAssemblies[i]; AssemblyDefinition assemblyDefinition = defaultAssemblyResolver.Resolve(Path.GetFileNameWithoutExtension(path), new ReaderParameters { AssemblyResolver = defaultAssemblyResolver }); textWriter.WriteLine("<assembly fullname=\"{0}\">", assemblyDefinition.Name.Name); MonoAssemblyStripping.GenerateBlackListTypeXML(textWriter, assemblyDefinition.MainModule.Types, usedClasses.GetAllManagedBaseClassesAsString()); textWriter.WriteLine("</assembly>"); } textWriter.WriteLine("</linker>"); } return text; }
private static ModuleDefinition ResolveInterceptorModuleDefinition() { const string InterceptorAssemblyName = "StaticProxy.Interceptor"; AssemblyDefinition definition = ModuleWeaver.Instance.AssemblyResolver.Resolve(InterceptorAssemblyName); if (definition == null) { // todo use an integration test to test this! DirectoryInfo nugetPackagesDirectory = Directory.GetParent(ModuleWeaver.Instance.AddinDirectoryPath); var assemblyResolver = new DefaultAssemblyResolver(); DirectoryInfo[] packageDirectores = nugetPackagesDirectory.GetDirectories(); foreach (DirectoryInfo packageDirectory in packageDirectores) { assemblyResolver.AddSearchDirectory(packageDirectory.FullName); } definition = assemblyResolver.Resolve(InterceptorAssemblyName); if (definition == null) { throw new WeavingException("Can't find StaticProxy.Interceptor assembly. Make sure you've downloaded and installed the nuget package!"); } } return definition.MainModule; }
//Adapted from: https://stackoverflow.com/questions/9262464/tool-to-show-assembly-dependencies public static void PoC(IEnumerable<AssemblyDefinition> assemblies, TextWriter writer, IEnumerable<string> searchfolders) { var resolver = new DefaultAssemblyResolver(); searchfolders.ToList().ForEach(x => resolver.AddSearchDirectory(x)); //writer.WriteLine("digraph Dependencies {"); var loaded = assemblies .SelectMany(a => a.Modules.Cast<ModuleDefinition>()) .SelectMany(m => m.AssemblyReferences.Cast<AssemblyNameReference>()) .Distinct() .Select(asm => { var dllname = asm.Name + ".dll"; //Console.WriteLine("Probing for {0}", dllname); try { return AssemblyDefinition.ReadAssembly(dllname); } catch { } try { return resolver.Resolve(asm.FullName); } catch { } return null; }) .Where(assembly => assembly != null) .ToList(); //loaded.ForEach(a => a.MainModule.ReadSymbols()); loaded.Select(x => x.FullName).Distinct().OrderBy(x => x).ToList().ForEach(x => writer.WriteLine("{0}", x)); /*loaded.ForEach(a => { foreach (var r in a.MainModule.AssemblyReferences.Cast<AssemblyNameReference>()) writer.WriteLine(@"""{0}"" -> ""{1}"";", r.Name, a.Name.Name); } );*/ //writer.WriteLine("}"); }
private Program() { defaultResolver = new DefaultAssemblyResolver(); defaultResolver.AddSearchDirectory(@"..\..\..\..\..\Bin\Desktop\"); writer = new StringWriter(); indexWriter = new StreamWriter("index.md"); }
private static IAssemblyResolver AssemblyResolverFor(IEnumerable<string> assemblies) { var resolver = new DefaultAssemblyResolver(); foreach (var directory in assemblies.Select(a => Path.GetFullPath(Path.GetDirectoryName(a))).ToHashSet()) resolver.AddSearchDirectory(directory); return resolver; }
private AssemblyDefinition ReadAssembly(string assemblyPath, string searchDir) { var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(searchDir); return AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters { AssemblyResolver = assemblyResolver, ReadingMode = ReadingMode.Deferred }); }
public static AssemblyDefinition LoadCecilAssembly(string fileName, bool immediateLoad = false, bool? readSymbols = null) { using (var t = new Tracer(Level.L5, myType, "LoadCecilAssembly")) { var pdbPath = Path.ChangeExtension(fileName, "pdb"); var tryReadSymbols = readSymbols ?? File.Exists(pdbPath); var fileInfo = new FileInfo(fileName); if (fileInfo.Length == 0) { t.Info("File {0} has zero byte length", fileName); return null; } try { var readingMode = immediateLoad ? ReadingMode.Immediate : ReadingMode.Deferred; var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(fileInfo.Directory.FullName); var readerParameters = new ReaderParameters { ReadSymbols = tryReadSymbols, ReadingMode = readingMode, AssemblyResolver = assemblyResolver }; var assemblyDef = AssemblyDefinition.ReadAssembly(fileName, readerParameters); // Managed C++ assemblies are not supported by Mono Cecil if (IsManagedCppAssembly(assemblyDef)) { t.Info("File {0} is a managed C++ assembly", fileName); return null; } return assemblyDef; } catch (BadImageFormatException) // Ignore invalid images { } catch (IndexOutOfRangeException) { t.Info("File {0} is a managed C++ assembly", fileName); } catch (NullReferenceException) // ignore managed c++ targets { t.Info("File {0} is a managed C++ assembly", fileName); } catch (ArgumentOutOfRangeException) { t.Info("File {0} is a managed C++ assembly", fileName); } catch (Exception ex) { t.Error(Level.L1, "Could not read assembly {0}: {1}", fileName, ex); } return null; } }
public void Simple() { 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(SqlVarientReader.Read(module).ToList()); }
private static ReaderParameters CreateReaderParameters( IEnumerable<string> dirs ) { var resolver = new DefaultAssemblyResolver(); foreach( var dir in dirs ) { resolver.AddSearchDirectory( dir ); } return new ReaderParameters { AssemblyResolver = resolver, }; }
public static string GeneratePublicApi(Assembly assemby, Type[] includeTypes = null, bool shouldIncludeAssemblyAttributes = true) { var assemblyResolver = new DefaultAssemblyResolver(); var assemblyPath = assemby.Location; assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath)); var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb")); var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred) { ReadSymbols = readSymbols, AssemblyResolver = assemblyResolver, }); return CreatePublicApiForAssembly(asm, tr => includeTypes == null || includeTypes.Any(t => t.FullName == tr.FullName && t.Assembly.FullName == tr.Module.Assembly.FullName), shouldIncludeAssemblyAttributes); }
public static void ApprovePublicApi(string assemblyPath) { var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath)); var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb")); var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred) { ReadSymbols = readSymbols, AssemblyResolver = assemblyResolver, }); var publicApi = PublicApiGenerator.CreatePublicApiForAssembly(asm); var writer = new ApprovalTextWriter(publicApi, "cs"); ApprovalTests.Approvals.Verify(writer, new UnitTestFrameworkNamer(), ApprovalTests.Approvals.GetReporter()); }
public ModuleWeaverTestHelper(string inputAssembly) { BeforeAssemblyPath = Path.GetFullPath(inputAssembly); #if (!DEBUG) BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release"); #endif AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll"); var oldPdb = BeforeAssemblyPath.Replace(".dll", ".pdb"); var newPdb = BeforeAssemblyPath.Replace(".dll", "2.pdb"); File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true); File.Copy(oldPdb, newPdb, true); Errors = new List<string>(); var assemblyResolver = new MockAssemblyResolver { Directory = Path.GetDirectoryName(BeforeAssemblyPath) }; using (var symbolStream = File.OpenRead(newPdb)) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Directory.GetParent(BeforeAssemblyPath).FullName); var readerParameters = new ReaderParameters { ReadSymbols = true, SymbolStream = symbolStream, SymbolReaderProvider = new PdbReaderProvider(), AssemblyResolver = resolver }; var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogError = s => Errors.Add(s) }; weavingTask.Execute(); moduleDefinition.Write(AfterAssemblyPath); } Assembly = Assembly.LoadFile(AfterAssemblyPath); }
public void approve_public_api() { var assemblyPath = typeof(StringHumanizeExtensions).Assembly.Location; var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath)); var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb")); var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred) { ReadSymbols = readSymbols, AssemblyResolver = assemblyResolver }); var publicApi = PublicApiGenerator.CreatePublicApiForAssembly(asm); Approvals.Verify(publicApi); }
public static void ApprovePublicApi(string assemblyPath) { var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath)); var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb")); var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred) { ReadSymbols = readSymbols, AssemblyResolver = assemblyResolver, }); var publicApi = PublicApiGenerator.CreatePublicApiForAssembly(asm); publicApi.ShouldMatchApproved(c => c .WithFileExtension(".cs") .UseCallerLocation()); }
/// <summary> /// Returns the code for a specific algorithm. /// </summary> /// <returns>The algorithm code.</returns> /// <param name="algorithmType">Algorithm type.</param> public static MethodDeclaration GetMethodCode(Type algorithmType, out AstBuilder astBuilder, string methodName) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName); var parameters = new ReaderParameters { AssemblyResolver = resolver, }; // Load Tychaia.ProceduralGeneration into Mono.Cecil. var module = AssemblyDefinition.ReadAssembly( Assembly.GetExecutingAssembly().Location, parameters).MainModule; // Now we have a reference to the method we want to decompile. TypeDefinition cecilType; MethodDefinition processCell; FindMethodName(module, algorithmType, methodName, out processCell, out cecilType); var decompilerSettings = new DecompilerSettings(); astBuilder = new AstBuilder(new DecompilerContext(module) { CurrentType = cecilType, Settings = decompilerSettings }); astBuilder.AddMethod(processCell); try { astBuilder.RunTransformations(); } catch (AssemblyResolutionException ex) { throw new Exception( "Unable to decompile algorithm source code for " + algorithmType.FullName + ".", ex); } astBuilder.CompilationUnit.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = true }); // Return. return astBuilder.CompilationUnit.Members.Where(v => v is MethodDeclaration).Cast<MethodDeclaration>().First(); }
private static ReflectionModel BuildReflectionModel(IEnumerable<string> paths) { var assemblyPaths = FilterFilesOnExtension(paths, ".dll").ToArray(); var definitions = new List<AssemblyDefinition>(); var resolver = new DefaultAssemblyResolver(); foreach (var assemblyPath in assemblyPaths) { resolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath)); } var parameters = new ReaderParameters { AssemblyResolver = resolver, }; foreach (var assemblyPath in assemblyPaths) { definitions.Add(AssemblyDefinition.ReadAssembly(assemblyPath, parameters)); } return ReflectionModelBuilder.Build(definitions); }
public static string GenerateBlackList(string librariesFolder, RuntimeClassRegistry usedClasses, string[] allAssemblies) { string str = "tmplink.xml"; usedClasses.SynchronizeClasses(); using (TextWriter writer = new StreamWriter(Path.Combine(librariesFolder, str))) { writer.WriteLine("<linker>"); writer.WriteLine("<assembly fullname=\"UnityEngine\">"); foreach (string str2 in usedClasses.GetAllManagedClassesAsString()) { writer.WriteLine(string.Format("<type fullname=\"UnityEngine.{0}\" preserve=\"{1}\"/>", str2, usedClasses.GetRetentionLevel(str2))); } writer.WriteLine("</assembly>"); DefaultAssemblyResolver resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(librariesFolder); foreach (string str3 in allAssemblies) { ReaderParameters parameters = new ReaderParameters { AssemblyResolver = resolver }; AssemblyDefinition definition = resolver.Resolve(Path.GetFileNameWithoutExtension(str3), parameters); writer.WriteLine("<assembly fullname=\"{0}\">", definition.Name.Name); if (definition.Name.Name.StartsWith("UnityEngine.")) { foreach (string str4 in usedClasses.GetAllManagedClassesAsString()) { writer.WriteLine(string.Format("<type fullname=\"UnityEngine.{0}\" preserve=\"{1}\"/>", str4, usedClasses.GetRetentionLevel(str4))); } } GenerateBlackListTypeXML(writer, definition.MainModule.Types, usedClasses.GetAllManagedBaseClassesAsString()); writer.WriteLine("</assembly>"); } writer.WriteLine("</linker>"); } return str; }
private static ReflectionModel BuildReflectionModel(IDictionary<string, IDocumentationMetadata> paths) { var items = FilterFilesOnExtension(paths, ".dll"); var definitions = new Dictionary<AssemblyDefinition, IDocumentationMetadata>(); var resolver = new DefaultAssemblyResolver(); foreach (var item in items) { resolver.AddSearchDirectory(Path.GetDirectoryName(item.Key)); } var parameters = new ReaderParameters { AssemblyResolver = resolver, }; foreach (var item in items) { var definition = AssemblyDefinition.ReadAssembly(item.Key, parameters); definitions.Add(definition, item.Value); } return ReflectionModelBuilder.Build(definitions); }
static int Main (string [] args) { int input; string output; switch (args.Length) { case 0: Console.WriteLine ("Usage: detect-sc input-dir [input-dir [...]] [output-dir]"); return 1; case 1: output = args [0]; input = 1; break; default: input = args.Length - 1; output = args [input]; break; } foreach (string assembly in PlatformCode.Assemblies) { Console.Write ("{0}.dll:", assembly); string fullpath = null; for (int i = 0; i < input; i++) { fullpath = Path.Combine (args [i], assembly) + ".dll"; if (File.Exists (fullpath)) break; fullpath = null; } if (fullpath == null) { Console.WriteLine (" NOT FOUND!", assembly); continue; } var resolver = new DefaultAssemblyResolver (); resolver.AddSearchDirectory (args [0]); AssemblyDefinition ad = AssemblyDefinition.ReadAssembly (fullpath, new ReaderParameters { AssemblyResolver = resolver }); ProcessAssembly (ad); string outfile = Path.Combine (output, assembly) + ".auto.sc"; using (StreamWriter sw = new StreamWriter (outfile)) { sw.WriteLine ("# [SecurityCritical] needed to execute code inside '{0}'.", ad.Name.FullName); sw.WriteLine ("# {0} methods needs to be decorated.", methods.Count); sw.WriteLine (); Console.Write (" {0} methods", methods.Count); foreach (KeyValuePair<string, string> kvp in methods) { sw.WriteLine ("# {0}", kvp.Value); sw.WriteLine ("+SC-M: {0}", kvp.Key); sw.WriteLine (); } } methods.Clear (); Console.WriteLine ("."); } return 0; }
private ReaderParameters GetReaderParameters() { var assemblyResolver = new DefaultAssemblyResolver(); var assemblyLocation = Path.GetDirectoryName(_assemblyLocation); assemblyResolver.AddSearchDirectory(assemblyLocation); var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver }; if (!File.Exists(PdbName)) return readerParameters; var symbolReaderProvider = new PdbReaderProvider(); readerParameters.SymbolReaderProvider = symbolReaderProvider; readerParameters.ReadSymbols = _mode == PatchMode.Debug; readerParameters.ReadingMode = ReadingMode.Deferred; return readerParameters; }
static void Check (string filename) { var resolver = new DefaultAssemblyResolver (); resolver.AddSearchDirectory (RuntimePath); resolver.AddSearchDirectory (SdkClientPath); AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly (filename, new ReaderParameters { AssemblyResolver = resolver }); foreach (ModuleDefinition module in assembly.Modules) { foreach (TypeDefinition type in module.GetAllTypes ()) { foreach (MethodDefinition md in type.Methods) { Check (assembly, md); } } } Console.WriteLine ("# Assembly: {0} [{1} items]", assembly, internals.Count); internals.Sort (); foreach (string s in internals) Console.WriteLine (s); Console.WriteLine (); internals.Clear (); }
private DefaultAssemblyResolver GetAssemblyResolver() { var assemblyResolver = new DefaultAssemblyResolver(); // Fix for having path to bin directory when running ASP.NET app. var extraSearchDir = Path.GetDirectoryName(new Uri(GetType().Assembly.CodeBase).AbsolutePath); assemblyResolver.AddSearchDirectory(extraSearchDir); return assemblyResolver; }
private void scan_Click(object sender, EventArgs e) { nodeTypeDefs.Clear(); nodeTreeNodes.Clear(); treeView1.Nodes.Clear(); DefaultAssemblyResolver asmResolver = new DefaultAssemblyResolver(); ReaderParameters readPars = new ReaderParameters(ReadingMode.Deferred); readPars.AssemblyResolver = asmResolver; //temp asmResolver.AddSearchDirectory(Path.GetDirectoryName(_browsePath)); AssemblyDefinition assem = AssemblyDefinition.ReadAssembly(_browsePath, readPars); var types = assem.MainModule.Types; var nameSpace = assem.MainModule.Types; TreeNode node = new TreeNode(); foreach (TypeDefinition type in types) { if (nodeTreeNodes.TryGetValue(type.Namespace, out node)) { node.Nodes.Add(type.Name); } else { node = new TreeNode(type.Namespace); node.Nodes.Add(type.Name); } nodeTreeNodes[type.Namespace] = node; nodeTypeDefs.Add(type.FullName, type); } List<string> keys = new List<string>(nodeTreeNodes.Keys); foreach (string key in keys) { if (nodeTreeNodes.TryGetValue(key, out node)) treeView1.Nodes.Add(node); } EnableDecompileWidget(true); lbCountAll.Text = Path.GetFileName(_browsePath) + " have " + nodeTypeDefs.Count + " types"; }
public static AssemblyDefinition[] ToDefinitions(IEnumerable <string> assemblyLocations) { if (assemblyLocations == null || !assemblyLocations.Any()) { return(new AssemblyDefinition[0]); } assemblyLocations = assemblyLocations.Select(x => { if (!File.Exists(x)) { return(x); } var path = Path.GetDirectoryName(x); var asmInfo = Path.Combine(path, "__AssemblyInfo__.ini"); if (!File.Exists(asmInfo)) { return(x); } var content = File.ReadAllText(asmInfo, System.Text.Encoding.Unicode); var idx = content.LastIndexOf("\0file:///"); if (idx < 0) { return(x); } var end = content.IndexOf('\0', idx + 9); if (end < 0) { return(x); } var location = content.Substring(idx + 9, end - idx - 9).Replace('/', '\\'); if (File.Exists(location)) { return(location); } return(x); }).ToList(); #if COREFX var resolver = ICSharpCode.Decompiler.UniversalAssemblyResolver .LoadMainModule(assemblyLocations.First(), inMemory: true).AssemblyResolver as ICSharpCode.Decompiler.UniversalAssemblyResolver; #else var resolver = new Mono.Cecil.DefaultAssemblyResolver(); #endif foreach (var assembly in assemblyLocations) { resolver.AddSearchDirectory(Path.GetDirectoryName(assembly)); } var assemblyDefinitions = new List <AssemblyDefinition>(); foreach (var assembly in assemblyLocations) { assemblyDefinitions.Add(Mono.Cecil.AssemblyDefinition.ReadAssembly( assembly, new Mono.Cecil.ReaderParameters { AssemblyResolver = resolver, InMemory = true })); } return(assemblyDefinitions.ToArray()); }
private static AssemblyDefinition LoadAssembly(string path) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(Path.GetDirectoryName(path)); return AssemblyDefinition.ReadAssembly(path, new ReaderParameters {AssemblyResolver = resolver}); }
internal static Dictionary<string, AssemblyTuple> smethod_1(IEnumerable<AssemblyFileInfo> coreAssemblyFiles) { Dictionary<string, AssemblyTuple> dictionary = new Dictionary<string, AssemblyTuple>(); DefaultAssemblyResolver defaultAssemblyResolver = new DefaultAssemblyResolver(); foreach (string current in BfCache.list_0) { if (Directory.Exists(current)) { defaultAssemblyResolver.AddSearchDirectory(current); } } foreach (AssemblyFileInfo current2 in coreAssemblyFiles) { if (current2.Name == "Search Directory") { defaultAssemblyResolver.AddSearchDirectory(current2.Path); } else { string directoryName = Path.GetDirectoryName(current2.Path); defaultAssemblyResolver.AddSearchDirectory(directoryName); } } foreach (AssemblyFileInfo current2 in coreAssemblyFiles) { if (!(current2.Name == "Search Directory")) { AssemblyDefinition assembly; try { assembly = AssemblyFactory.GetAssembly(current2.Path); } catch (ImageFormatException) { throw new NitriqException("NotManagedAssembly", "The assembly \"" + current2.Name + "\" is not a managed assembly"); } if (!dictionary.ContainsKey(assembly.Name.FullName)) { AssemblyTuple assemblyTuple = new AssemblyTuple(assembly); assemblyTuple.IsCoreAssembly = true; assemblyTuple.Directory = Path.GetDirectoryName(current2.Path); dictionary.Add(assembly.Name.FullName, assemblyTuple); } } } List<AssemblyTuple> list = new List<AssemblyTuple>(dictionary.Values); foreach (AssemblyTuple current3 in list) { foreach (ModuleDefinition moduleDefinition in current3.Assembly.Modules) { foreach (AssemblyNameReference assemblyNameReference in moduleDefinition.AssemblyReferences) { AssemblyDefinition assemblyDefinition; try { assemblyDefinition = defaultAssemblyResolver.Resolve(assemblyNameReference); } catch (FileNotFoundException) { throw new NitriqException("CantResolve", "Nitriq couldn't resolve the below assembly, consider adding a search directory where this assembly can be found \r\n\r\n" + assemblyNameReference.FullName); } string fullName = assemblyNameReference.FullName; string fullName2 = assemblyDefinition.Name.FullName; if (fullName2 == fullName) { if (!dictionary.ContainsKey(fullName)) { dictionary.Add(fullName, new AssemblyTuple(assemblyDefinition) { Directory = "", IsCoreAssembly = false }); } } else if (dictionary.ContainsKey(fullName) || dictionary.ContainsKey(fullName2)) { if (!dictionary.ContainsKey(fullName)) { dictionary.Add(fullName, dictionary[fullName2]); } if (!dictionary.ContainsKey(fullName2)) { dictionary.Add(fullName2, dictionary[fullName]); } } else { AssemblyTuple assemblyTuple2 = new AssemblyTuple(assemblyDefinition); assemblyTuple2.Directory = ""; assemblyTuple2.IsCoreAssembly = false; dictionary.Add(fullName, assemblyTuple2); dictionary.Add(fullName2, assemblyTuple2); } } } } return dictionary; }
/// <summary> /// Patches the file. /// </summary> /// <param name="file">The file.</param> public bool PatchFile(string file) { file = Path.Combine(Environment.CurrentDirectory, file); var fileTime = new FileTime(file); //var fileTimeInteropBuilder = new FileTime(Assembly.GetExecutingAssembly().Location); string checkFile = Path.GetFullPath(file) + ".check"; //string checkInteropBuilderFile = "InteropBuild.check"; // If checkFile and checkInteropBuilderFile up-to-date, then nothing to do if (fileTime.CheckFileUpToDate(checkFile)) { Log("Nothing to do. SharpDX patch was already applied for assembly [{0}]", file); return false; } // Copy PDB from input assembly to output assembly if any var readerParameters = new ReaderParameters(); var resolver = new DefaultAssemblyResolver(); readerParameters.AssemblyResolver = resolver; var writerParameters = new WriterParameters(); var pdbName = Path.ChangeExtension(file, "pdb"); if (File.Exists(pdbName)) { var symbolReaderProvider = new PdbReaderProvider(); readerParameters.SymbolReaderProvider = symbolReaderProvider; readerParameters.ReadSymbols = true; writerParameters.WriteSymbols = true; } // Read Assembly assembly = AssemblyDefinition.ReadAssembly(file, readerParameters); resolver.AddSearchDirectory(Path.GetDirectoryName(file)); // Query the target framework in order to resolve correct assemblies and type forwarding var targetFrameworkAttr = assembly.CustomAttributes.FirstOrDefault( attribute => attribute.Constructor.FullName.Contains("System.Runtime.Versioning.TargetFrameworkAttribute")); if(targetFrameworkAttr != null && targetFrameworkAttr.ConstructorArguments.Count > 0 && targetFrameworkAttr.ConstructorArguments[0].Value != null) { var targetFramework = new FrameworkName(targetFrameworkAttr.ConstructorArguments[0].Value.ToString()); var netcoreAssemblyPath = string.Format(@"Reference Assemblies\Microsoft\Framework\{0}\v{1}", targetFramework.Identifier, targetFramework.Version); netcoreAssemblyPath = Path.Combine(ProgramFilesx86(), netcoreAssemblyPath); if(Directory.Exists(netcoreAssemblyPath)) { resolver.AddSearchDirectory(netcoreAssemblyPath); } } // Import void* and int32 voidType = assembly.MainModule.TypeSystem.Void.Resolve(); voidPointerType = new PointerType(assembly.MainModule.Import(voidType)); intType = assembly.MainModule.Import( assembly.MainModule.TypeSystem.Int32.Resolve()); // Remove CompilationRelaxationsAttribute for (int i = 0; i < assembly.CustomAttributes.Count; i++) { var customAttribute = assembly.CustomAttributes[i]; if (customAttribute.AttributeType.FullName == typeof(CompilationRelaxationsAttribute).FullName) { assembly.CustomAttributes.RemoveAt(i); i--; } } Log("SharpDX interop patch for assembly [{0}]", file); foreach (var type in assembly.MainModule.Types) PatchType(type); // Remove All Interop classes foreach (var type in classToRemoveList) assembly.MainModule.Types.Remove(type); var outputFilePath = file; assembly.Write(outputFilePath, writerParameters); fileTime = new FileTime(file); // Update Check file fileTime.UpdateCheckFile(checkFile); //fileTimeInteropBuilder.UpdateCheckFile(checkInteropBuilderFile); Log("SharpDX patch done for assembly [{0}]", file); return true; }