How to replace method parameter with a variable with Mono.Cecil

Question

I am making a code generation utility for my application, and I have a problem - I don't know how can I replace a method's parameter with a variable created inside it.

Example:

a) Code before code-generation:

public void SomeMethod(Foo foo)
{
    DoSomethingWithFoo(foo);
    int someInfo = foo.ExamleValue * 12;
    // etc
}

b) Expected code after code-generation:

// BitwiseReader class is deserializing byte array received from UDP stream into types
public void SomeMethod(BitwiseReader reader)
{
    Foo foo = reader.ReadFoo();

    DoSomethingWithFoo(foo);
    int someInfo = foo.ExamleValue * 12;
    // etc
}

I have tried making a second method, that converts BitwiseReader into Foo and passes it to the actual SomeMethod(Foo) method. But I am making a high-performance application and that second method visibly increased processing time.

The biggest problem is that Mono.Cecil handles Parameters & Variables very differently & I don't know how to replace a param into a generated variable.

FAQ to "Micro optimization is bad (TM)" guys:

I am making a very high-performance application that handles tens of thousands of operations per second. And as I said - my workaround with a second method decreased performance in a visible way.

Answer 1

If you look in the original IL code you'll see something like this:

.method public hidebysig 
    instance void SomeMethod (
        class Foo foo
    ) cil managed 
{
    // Method begins at RVA 0x2360
    // Code size 20 (0x14)
    .maxstack 2
    .locals init (
        [0] int32
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: ldarg.1
    IL_0003: call instance void Driver::DoSomethingWithFoo(class Foo)
    IL_0008: nop
    IL_0009: ldarg.1
    IL_000a: ldfld int32 Foo::ExamleValue
    IL_000f: ldc.i4.s 12
    IL_0011: mul
    IL_0012: stloc.0
    IL_0013: ret
} // end of method Driver::SomeMethod

Basically what you will need to is:

1. Replace the parameter type Foo with BitwiseReader

2. Find the instruction that is loading the 1st parameter (IL_0002 in the above), ie, previously foo , now reader

3. Add a call to ReadFoo() just after the instruction found in the previous step.

After these steps your IL will looks like:

.method public hidebysig 
    instance void SomeMethod (
        class BitwiseReader reader
    ) cil managed 
{
    // Method begins at RVA 0x2360
    // Code size 25 (0x19)
    .maxstack 2
    .locals init (
        [0] int32
    )
    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: ldarg.1
    IL_0003: call instance class Foo BitwiseReader::ReadFoo()
    IL_0008: call instance void Driver::DoSomethingWithFoo(class Foo)
    IL_000d: nop
    IL_000e: ldarg.1
    IL_000f: ldfld int32 Foo::ExamleValue
    IL_0014: ldc.i4.s 12
    IL_0016: mul
    IL_0017: stloc.0
    IL_0018: ret
} // end of method Driver::SomeMethod

**** Warning ****

The code bellow is highly dependent on the fact that SomeMethod() takes a single Foo parameter and that it does something that expects this reference to be in the top of the stack (in this case, calling DoSomethingWithFoo() )

If you change SomeMethod() implementation, most likely you'll need to adapt the Cecil code that changes its signature/implementation also.

Notice also that for simplicity sake I've defined BitwiseReader in the same assembly; if it is declared in a different assembly you may need to change the code that finds that method (an alternative is to construct a MethodReference instance manually)

using Mono.Cecil;
using Mono.Cecil.Cil;
using System.Linq;

class Driver
{
    public static void Main(string[] args)
    {
        if (args.Length == 1 && args[0] == "run")
        {
            ProofThatItWorks();
            return;
        }

        using var assembly = AssemblyDefinition.ReadAssembly(typeof(Foo).Assembly.Location);

        var driver = assembly.MainModule.Types.Single(t => t.Name == "Driver");
        var someMethod = driver.Methods.Single(m => m.Name == "SomeMethod");

        var bitwiseReaderType = assembly.MainModule.Types.Single(t => t.Name == "BitwiseReader");
        var paramType = someMethod.Parameters[0].ParameterType;        
        
        // 1.
        someMethod.Parameters.RemoveAt(0); // Remove Foo parameter
        someMethod.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None,  bitwiseReaderType)); // Add reader parameter

        var ilProcessor = someMethod.Body.GetILProcessor();
        
        // 2.
        var loadOldFooParam = ilProcessor.Body.Instructions.FirstOrDefault(inst => inst.OpCode == OpCodes.Ldarg_1);
        
        // 3.
        var readFooMethod = bitwiseReaderType.Methods.Single(m => m.Name == "ReadFoo");
        var callReadFooMethod = ilProcessor.Create(OpCodes.Call, readFooMethod);
        ilProcessor.InsertAfter(loadOldFooParam, callReadFooMethod);

        // Save the modified assembly alongside a .runtimeconfig.json file to be able to run it through 'dotnet'
        var originalAssemblyPath = typeof(Driver).Assembly.Location;
        var outputPath = Path.Combine(Path.GetDirectoryName(originalAssemblyPath), "driver_new.dll");

        var originalRuntimeDependencies = Path.ChangeExtension(originalAssemblyPath, "runtimeconfig.json");
        var newRuntimeDependencies = Path.ChangeExtension(outputPath, "runtimeconfig.json");
        File.Copy(originalRuntimeDependencies, newRuntimeDependencies, true);

        System.Console.WriteLine($"\nWritting modified assembly to {outputPath}");
        Console.ForegroundColor = ConsoleColor.Magenta;
        System.Console.WriteLine($"execute: 'dotnet {outputPath} run'  to test.");
        assembly.Name.Name = "driver_new";
        assembly.Write(outputPath);
    }

    static void ProofThatItWorks()
    {
        // call through reflection because the method parameter does not mach 
        // during compilation...
        var p = new Driver();
        var m = p.GetType().GetMethod("SomeMethod");

        System.Console.WriteLine($"Calling {m}");
        m.Invoke(p, new [] { new BitwiseReader() });
    }

    public void SomeMethod(Foo foo)
    {
        DoSomethingWithFoo(foo);
        int someInfo = foo.ExamleValue * 12;
        // etc
    }

    void DoSomethingWithFoo(Foo foo) {}
}

public class Foo 
{
    public int ExamleValue;
}

public class BitwiseReader
{
    public Foo ReadFoo() 
    {
        System.Console.WriteLine("ReadFoo called...");
        return new Foo();
    }
}

Finally some good tools you can use may find useful when experimenting with Mono.Cecil / IL / C#:

1. https://sharplab.io
2. https://cecilifier.me (disclaimer, I am the author of this one)