Get the :base parameters from a constructor

[woltek]

Hello,

I'm looking for a way to get the 'base' parameters of constructor class using a dll without reference.
seem's like this information can't be found with reflection. (see my inital post here : https://stackoverflow.com/questions/68578435/c-sharp-constructor-get-base-part-with-reflection)

do cecil allow to get method content ?
and is there a way to get the information about the base constructor call with its parameters value ?

Exemple showing what i call 'base' constructor (not shure how to call it)

public class MyClass: MySuperClass
{
   public MyClass(Color color1, Color color2)
          : base(0.0f, 0.0f, 0.0f, 0.0f, color1, color2) //what i call 'base' constructor
    {
           //...
     }
 }

Exemple of what i try to watch in debug with cecil, but i don't really get how to retrieve the method content...

 var lModule = Mono.Cecil.ModuleDefinition.ReadModule(gDllPath);
 var lRef = new Mono.Cecil.TypeReference(lClass.NameSpace, lClass.Name, lModule, null);
 var lMethods = new Mono.Cecil.MethodReference(lClass.Name, lRef);

[jbevain]

Hi,

I'm not sure I fully understand what it is you're after.

For the above code, you can write something like:

using var module = ModuleDefinition.ReadModule(dllPath);
var type = module.GetType("MyClass");
var ctor = type.Methods.FirstOrDefault(m => m.IsConstructor && m.Parameters.Count == 2);

var instructions = ctor.Body.Instructions;

In instructions, you'll find a method call to MySuperClass::.ctor(float, float, float, Color, Color) which will be your C# base constructor call. I suggest using ILSpy to learn about IL instructions and how C# maps to IL.

[Zastai]

A method invocation in IL will be preceded by instructions that set up the arguments on the stack. As Jb says, you will be able to find the call to the superclass constructor fairly easily, and that will tell you how many arguments it expects (the first of which will be the this pointer, so you can ignore that one.

In your simple case, where every argument is either a literal or one of the arguments of the subclass constructor, that's pretty easy - you get one instruction per parameter (ldc to load a constant, ldarg to load an argument):

  .method /* 06000008 */ public hidebysig specialname rtspecialname 
    instance void .ctor (
      valuetype [System.Drawing.Primitives]System.Drawing.Color color1,
      valuetype [System.Drawing.Primitives]System.Drawing.Color color2
    ) cil managed 
  {
    // Method begins at RVA 0x20e9
    // Header size: 1
    // Code size: 29 (0x1d)
    .maxstack 8

    IL_0000: ldarg.0 // this
    IL_0001: ldc.r4 0.0
    IL_0006: ldc.r4 0.0
    IL_000b: ldc.r4 0.0
    IL_0010: ldc.r4 0.0
    IL_0015: ldarg.1 // color1
    IL_0016: ldarg.2 // color2
    IL_0017: call instance void CodeSamples.MySuperClass::.ctor(float32, float32, float32, float32, valuetype [System.Drawing.Primitives]System.Drawing.Color, valuetype [System.Drawing.Primitives]System.Drawing.Color) /* 0600000A */

    IL_001c: ret
  } // end of method MyClass::.ctor

(bit surprising that GitHub doesn't do IL for highlighting)

However, things can get more complicated; consider

  public static readonly int X = 5;

  public MyClass()
    : base(MathF.PI, MathF.E, MathF.Tau, MathF.Atan2(13.0f, 42.0f), Color.Bisque, Color.FromArgb((3 * MyClass.X) + 7, 2, 3, 4)) {
  }

  private int evil = 666;

will get you

  .method /* 06000007 */ public hidebysig specialname rtspecialname 
    instance void .ctor () cil managed 
  {
    // Method begins at RVA 0x20a4
    // Header size: 12
    // Code size: 70 (0x46)
    .maxstack 10

    IL_0000: ldarg.0 // this
    IL_0001: ldc.i4 666
    IL_0006: stfld int32 CodeSamples.MyClass::evil /* 04000004 */

    IL_000b: ldarg.0 // this
    IL_000c: ldc.r4 3.14159274
    IL_0011: ldc.r4 2.71828175
    IL_0016: ldc.r4 6.28318548
    IL_001b: ldc.r4 13
    IL_0020: ldc.r4 42
    IL_0025: call float32 [System.Runtime]System.MathF::Atan2(float32, float32) /* 0A000013 */
    IL_002a: call valuetype [System.Drawing.Primitives]System.Drawing.Color [System.Drawing.Primitives]System.Drawing.Color::get_Bisque() /* 0A000014 */
    IL_002f: ldc.i4.3
    IL_0030: ldsfld int32 CodeSamples.MyClass::X /* 04000003 */
    IL_0035: mul
    IL_0036: ldc.i4.7
    IL_0037: add
    IL_0038: ldc.i4.2
    IL_0039: ldc.i4.3
    IL_003a: ldc.i4.4
    IL_003b: call valuetype [System.Drawing.Primitives]System.Drawing.Color [System.Drawing.Primitives]System.Drawing.Color::FromArgb(int32, int32, int32, int32) /* 0A000015 */
    IL_0040: call instance void CodeSamples.MySuperClass::.ctor(float32, float32, float32, float32, valuetype [System.Drawing.Primitives]System.Drawing.Color, valuetype [System.Drawing.Primitives]System.Drawing.Color) /* 06000009 */

    IL_0045: ret
  } // end of method MyClass::.ctor

so not only will there be code preceding the base constructor call (i.e. any and all initializers for instance fields), but the instructions before it are much more complex, including method calls of their own.

In short, trying to make sense of the exact expressions passed to a method's arguments, while certainly possible, is not a trivial undertaking.