编程开源技术交流，分享技术与知识

网站首页 > 开源技术 正文

实例方法和静态方法有区别吗?（简答3. 实例方法、类方法、静态方法的区别?）

wxchong 2024-10-24 18:00:38 开源技术 22 ℃ 0 评论

实例方法和静态方法有区别吗？对于很多人来说，这是一个愚蠢的问题。因为我们都知道它们的区别，实例方法作用于某个具体的上下文对象，该上下文对象可以利用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.ableContextAttribute::.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(!));
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);
}

Tags：

猜你喜欢

本文暂时没有评论，来添加一个吧(●'◡'●)

欢迎 你 发表评论:

最近发表
标签列表
赣ICP备2023011894号-2