实例方法和静态方法有区别吗?

实例方法和静态方法有区别吗？对于很多人来说，这是一个愚蠢的问题。因为我们都知道它们的区别，实例方法作用于某个具体的上下文对象，该上下文对象可以利用this关键字获得；静态方法则是定义在某个类型中，不存在上下文对象的概念。但是如果我们从函数的角度来看的话，不论是静态方法还是实例方法都是一个用于处理输入参数的操作，貌似又没有什么区别。

以如下这个用于封装一个整数的IntValue类型为例，它具有两个AsInt32方法，实例方法返回当前InValue对象的_value字段；静态方法将IntValue对象作为参数，返回该对象的_value字段。我们的问题是：这两个AsInt32方法有分别吗？

var target = new IntValue(123);
target.AsInt32();
IntValue.AsInt32(target);

public class IntValue
{
    private readonly int _value;
    public IntValue(int value) => _value = value;

    public int AsInt32() => _value;
    public static int AsInt32(IntValue value) => value._value;
}

我们从IL的视角来看这两个方法的声明和实现。如下面的代码片段所示，从方法声明来看，实例方法AsInt32和静态方法AsInt32确实不同，但是它们的实现却完全一致。方法涉及三个IL指令：ldarg.0提取第1个参数压入栈中，具体入栈的是指向IntValue对象的地址；目标IntValue对象的_value字段通过ldfld指令被加载，最终通过ret指令作为结果返回。实例方法也好，静态方法也罢，它们都被视为的普通函数。函数只有输入和输出，并不存在所谓的上下文对象（this）。

.method public hidebysig
	instance int32 AsInt32 () cil managed
{
	// Method begins at RVA 0x2178
	// Header size: 1
	// Code size: 7 (0x7)
	.maxstack 8

	// return _value;
	IL_0000: ldarg.0
	IL_0001: ldfld int32 IntValue::_value
	IL_0006: ret
} // end of method IntValue::AsInt32

.method public hidebysig static
	int32 AsInt32 (
		class IntValue 'value'
	) cil managed
{
	.custom instance void System.Runtime.CompilerServices.NullableContextAttribute::.ctor(uint8) = (
		01 00 01 00 00
	)
	// Method begins at RVA 0x2180
	// Header size: 1
	// Code size: 7 (0x7)
	.maxstack 8

	// return value._value;
	IL_0000: ldarg.0
	IL_0001: ldfld int32 IntValue::_value
	IL_0006: ret
} // end of method IntValue::AsInt32

实例方法实际上将目标对象作为它的第一个参数，这与显式将目标对象作为第一个参数的静态方法并没有本质的区别，所以调用它们的IL代码也一样。如下所示的就是上面C#针对这两个方法的调用转换生成的IL代码。

.method private hidebysig static
	void '<Main>$' (
		string[] args
	) cil managed
{
	// Method begins at RVA 0x213c
	// Header size: 12
	// Code size: 23 (0x17)
	.maxstack 1
	.entrypoint
	.locals init (
		[0] class IntValue target
	)

	// IntValue intValue = new IntValue(123);
	IL_0000: ldc.i4.s 123
	IL_0002: newobj instance void IntValue::.ctor(int32)
	IL_0007: stloc.0
	// intValue.AsInt32();
	IL_0008: ldloc.0
	IL_0009: callvirt instance int32 IntValue::AsInt32()
	IL_000e: pop
	// IntValue.AsInt32(intValue);
	IL_000f: ldloc.0
	IL_0010: call int32 IntValue::AsInt32(class IntValue)
	IL_0015: pop
	// }
	IL_0016: ret
} // end of method Program::'<Main>$'

由于实例方法和静态方法的“无差异性”，我们可以使用一些Hijack的方式“篡改”现有某个类型的实例方法。比如我们在IntValue类型（可以定义任意类型中）中定义了一个总是返回int.MaxValue的AlwaysMaxValue方法。在演示程序中，我们通过调用Hijack方法将IntValue的实例方法AsInt32“替换”这个AlwaysMaxValue方法。

var target = new IntValue(123);
Hijack(()=>target.AsInt32(), () => IntValue.AlwaysMaxValue(null!));
Debug.Assert(target.AsInt32() == int.MaxValue);

public class IntValue
{
    private readonly int _value;
    public IntValue(int value) => _value = value;
    public int AsInt32() => _value;
    public static int AsInt32(IntValue value) => value._value;

    public static int AlwaysMaxValue(IntValue _) => int.MaxValue;
}

如下所示的就是这个Hijack方法的定义。它的两个方法表示调用原始方法和篡改方法的表达式，我们利用它们得到对应的MethodInfo对象。我们利用MethodHandle得到方法句柄，并进一步利用GetFunctionPointer方法得到具体的指针地址。有了这两个地址，我们就可以计算出它们之间的偏移量，然后利用Marshal.Copy方法“篡改”了原始方法的指令。具体来说，我们将原始方法的初始指令改为跳转指令JUMP，通过设置的偏移量跳转到新的方法。

static void Hijack(Expression<Action> originalCall, Expression<Action> targetCall)
{
    var originalMethod = ((MethodCallExpression)originalCall.Body).Method;
    var targetMethod = ((MethodCallExpression)targetCall.Body).Method;

    RuntimeHelpers.PrepareMethod(originalMethod.MethodHandle);
    RuntimeHelpers.PrepareMethod(targetMethod.MethodHandle);

    var sourceAddress = originalMethod.MethodHandle.GetFunctionPointer();
    var targetAddress = (long)targetMethod.MethodHandle.GetFunctionPointer();

    int offset = (int)(targetAddress - (long)sourceAddress - 5);

    byte[] instruction = {
        0xE9, // JUMP
        (byte)(offset & 0xFF),
        (byte)((offset >> 8) & 0xFF),
        (byte)((offset >> 16) & 0xFF),
        (byte)((offset >> 24) & 0xFF)
    };

    Marshal.Copy(instruction, 0, sourceAddress, instruction.Length);
}