Cecil Metadata Reference for Roslyn

[DarioDaF]

Hi, I'm new to the forum, I did some DLL patching for .NET in the past using dnSpy and wanted to automate the patch for the future, so I looked into Mono.Cecil and Microsoft.CodeAnalysis.CSharp.
I'm interested in compiling some code into an existing dll in code and then save the new assembly.

For obvious reasons I made minimal changes in the current assembly methods (add a call, skip a check and so on) and those must be done in IL, but, I used to add methods to existing classes using dnSpy interface.
Apparently this requires building C# code to generate IL to then copy into the assembly with Cecil and I faced a problem, Roslyn requires MetadataReference of the assemblies used in the code (reasonable assumption), but I found only load from file as an option, although those assembly references are present in the target assembly too assembly.MainModule.AssemblyReferences.

I wanted to use those pre-existing references in the compiled code (since method name/version etc. is all present in the original assembly).
This is important because I'm using Cecil in .NET core (for cross platform reasons) to patch a .NET4 dll so assemblies are not the same (e.g. using typeof(Console).Assembly and so on does not result in the correct bindings).

Thanks in advance for the help, here is some reference code:

            var assembly = AssemblyDefinition.ReadAssembly(TARGET_ASSEMBLY);
            var module = assembly.MainModule;

            var bp = module.GetType("Test.TargetClass");

            var parseOpts = new CSharpParseOptions(languageVersion: LanguageVersion.LatestMajor, kind: SourceCodeKind.Regular);
            var stx = CSharpSyntaxTree.ParseText(@"
using System;

namespace Test {
    public class TargetClass {
        static void MyMethod() {
            Console.WriteLine(""Hello World"");
        }
    }
};
", parseOpts);
            var refs = new[] {
                MetadataReference.CreateFromFile(Path.Combine(REFS_ASSEMBLY, "mscorlib.dll")), // Hand taken copies of .NET4 dlls taken from dnSpy references
                MetadataReference.CreateFromFile(Path.Combine(REFS_ASSEMBLY, "System.dll")),
                MetadataReference.CreateFromFile(Path.Combine(REFS_ASSEMBLY, "System.Core.dll")),
                MetadataReference.CreateFromFile(Path.Combine(REFS_ASSEMBLY, "System.Runtime.dll")),
                //MetadataReference.CreateFromFile(typeof(ValueTuple<>).Assembly.Location), // Required for C# 7+
                //MetadataReference.CreateFromFile(typeof(Console).Assembly.Location), // Not referencing the correct assembly!
                MetadataReference.CreateFromFile(TARGET_ASSEMBLY)
            };
            var compOpts = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);
            var comp = CSharpCompilation.Create("MyCompilation", options: compOpts, references: refs).AddReferences(refs).AddSyntaxTrees(new[] { stx });
            var stream = new MemoryStream();
            var emitRes = comp.Emit(stream); // ??? Saving stream with PE and reparsing? Isn't there a way to get IL directly?
            if (emitRes.Success)
            {
                stream.Seek(0, SeekOrigin.Begin);
                var myAssembly = AssemblyDefinition.ReadAssembly(stream);
                var myMethod = myAssembly.MainModule.GetType("Test.TargetClass").Methods.Where((md) => { return md.Name == "MyMethod"; }).First();
                foreach (var inst in myMethod.Body.Instructions) // Dump IL
                {
                    Console.WriteLine($"{inst.OpCode} \"{inst.Operand}\"");
                }
                // [...] GO ON AND COPY IL
            }

[jbevain]

Hi,

I'm not exactly sure I understand what the issue or what the question is :)

Cecil and Roslyn being two different APIs there is no mapping between a Cecil assembly and a Roslyn assembly.

Cecil also only reads and writes binaries, so it doesn't necessarily know where system assemblies are.

Again, I'm not quite sure how to help :)

[DarioDaF]

Thanks, I've probably thrown too much stuff there, to compile or even reference a method/class you need [https://docs.microsoft.com/en-us/dotnet/standard/assembly/reference-assemblies] as stated here a reference assembly, those reference can be seen inside Cecil loading an assembly, I need to extract those metadata/references to use to compile a part of C# to include back into the DLL (copying the compiled IL back in the Cecil opened assembly).

To use the functions the definitions/references of for example System.Web.dll are included into the Cecil opened DLL, I would like to use the same references to build another piece of code (to avoid manually finding which version of dotnet and libraries it's using and manually gather those refs to compile).

I hope this is clearer and thanks for the answer

[jbevain]

So when Cecil reads an assembly and looks at its references (like System.Web), it doesn't know where System.Web.dll is.

Cecil has the concept of an AssemblyResolver that takes an AssemblyNameReference and tries to load that into an AssemblyDefinition, but that is tricky in the scenario you're mentioning (looking at .NET assemblies on .NET Core).

So basically, it's going to be on you to find which and where System.Web.dll is from a System.Web reference before passing that to Roslyn.

[DarioDaF]

Ok it seems to be hard to do.
Since Cecil knows the metadata of System.Web I supposed it could export the partial definition (metadata only) that is present in the assembly referencing it.