Tiger 的 IL 教程

C# 代码

using System;
public class C {
    public event Action? OnUpdate;
}

IL 代码 (省略了部分内容)

.class public C extends System.Object {
    .field private class System.Action OnUpdate

    .method public instance void add_OnUpdate (class System.Action 'value') {
        // 这里 IL 代码太长就用 C# 代码了
        Action action = this.OnUpdate;
        while (true) {
            Action action2 = action;
            Action value2 = (Action)Delegate.Combine(action2, value);
            action = Interlocked.CompareExchange(ref this.OnUpdate, value2, action2);
            if ((object)action == action2)
                break;
        }
    }

    .method public instance void remove_OnUpdate (class System.Action 'value') {
        // 这里 IL 代码太长就用 C# 代码了
        Action action = this.OnUpdate;
        while (true) {
            Action action2 = action;
            Action value2 = (Action)Delegate.Remove(action2, value);
            action = Interlocked.CompareExchange(ref this.OnUpdate, value2, action2);
            if ((object)action == action2)
                break;
        }
    }

    .event System.Action OnUpdate
    {
        .addon instance void C::add_OnUpdate(class System.Action)
        .removeon instance void C::remove_OnUpdate(class System.Action)
    }


} // end of class C

上面的 C# 代码等效于下面的 C# 代码 (IL 代码太过繁琐就不放了)

using System;
public class C {
    private string field = "\n";
    public void Func(string s) {
        string tail = "!!!";
        Action action = () => Console.WriteLine(s + tail + field);
        s = s.Trim();
        action();
    }
}

using System;
public class C {
    private sealed class <>c__DisplayClass0_0 {
        // 捕获到的参数与局部变量
        public string s;
        public string tail;
        public C <>4__this;
        // lambda 表达式对应的方法
        internal void <Func>b__0() {
            Console.WriteLine(string.Concat(s, tail, <>4__this.field));
        }
    }
    private string field = "\n";
    public void Func(string s) {
        <>c__DisplayClass0_0 <>c__DisplayClass0_ = new();
        // 参数和实例被存在字段中
        <>c__DisplayClass0_.s = s;
        <>c__DisplayClass1_.<>4__this = this;
        // 局部变量直接被替换成了对应字段
        <>c__DisplayClass0_.tail = "!!!";
        Action action = new(<>c__DisplayClass0_.<Func>b__0);
        // 后续对参数或者局部变量的调用也都会被替换为对应的字段
        <>c__DisplayClass0_.s = <>c__DisplayClass0_.s.Trim();
        action();
    }
}

using System;
public class C {
    private string field = "\n";
    public void Func(string s) {
        while (Condition()) {
            string tail = "!!!";
            Invoke(() => Console.Write(s + tail + field));
            Invoke(() => Console.Write(s + field));
        }
        Invoke(() => Console.WriteLine("Hello World!"));
        Invoke(() => Console.WriteLine(s));
        Invoke(() => Console.Write(field));
    }
    public void Func2(string s){
        Invoke(() => Console.Write(field));
        Invoke(() => Console.WriteLine("Hello World 2!"));
    }
    private Random rand = new();
    private bool Condition() => rand.Next(2) == 0;
    private void Invoke(Action? action) => action?.Invoke();
}

// 注: 以下 "对应的类" 都是指的由 lambda 生成的类
public class C {
    // 非闭包 lambda 对应的类
    private sealed class <>c {
        // 单例
        public static readonly <>c <>9 = new <>c();
        public static Action <>9__1_0;
        public static Action <>9__2_1;
        internal void <Func>b__1_0() => Console.WriteLine("Hello World!");
        internal void <Func2>b__2_1() => Console.WriteLine("Hello World 2!");
    }
    private sealed class <>c__DisplayClass1_0 {
        public string s;
        public C <>4__this;
        public Action <>9__4;
        internal void <Func>b__1() => Console.WriteLine(s);
        internal void <Func>b__2() => Console.Write(<>4__this.field);
    }
    private sealed class <>c__DisplayClass1_1 {
        public string tail;
        public <>c__DisplayClass1_0 CS$<>8__locals1;
        internal void <Func>b__3() => Console.Write(string.Concat(CS$<>8__locals1.s, tail, CS$<>8__locals1.<>4__this.field));
    }
    private string field = "\n";
    public void Func(string s) {
        // 此块对应类为 <>c__DisplayClass1_0, 捕获的变量为 s 与 this
        <>c__DisplayClass1_0 <>c__DisplayClass1_ = new();
        <>c__DisplayClass1_.s = s;
        <>c__DisplayClass1_.<>4__this = this;
        while (Condition()) {
            // 此块对应类为 <>c__DisplayClass1_1, 捕获的变量为 tail
            <>c__DisplayClass1_1 <>c__DisplayClass1_2 = new();
            // 由于此 lambda 还捕获了外部块中的 s, 所以这里实际会捕获外部块所对应的类的实例
            <>c__DisplayClass1_2.CS$<>8__locals1 = <>c__DisplayClass1_;
            // 捕获到的局部变量直接变成了字段
            <>c__DisplayClass1_2.tail = "!!!";
            // 实际上此 lambda 还捕获了 this, 不过由于外部块已经捕获到了, 所以就不再捕获了
            Invoke(new Action(<>c__DisplayClass1_2.<Func>b__3));
            // 由于没有捕获此块内声明的变量, 所以使用了缓存 (如果上面的 while 变为 if 的话这里是不会缓存的)
            // 另外由于外部块所对应的类的实例 (<>c__DisplayClass1_) 被捕获了, 所以这里也会被替换为对应字段 (<>c__DisplayClass1_2.CS$<>8__locals1)
            Invoke(<>c__DisplayClass1_2.CS$<>8__locals1.<>9__4 ??= new Action(<>c__DisplayClass1_2.CS$<>8__locals1.<Func>b__4)));
            // 即相当于 Invoke(<>c__DisplayClass1_.<>9__4 ??= new Action(<>c__DisplayClass1_.<Func>b__4)));
        }
        // 非闭包 lambda, 缓存 lambda 表达式对应的值
        Invoke(<>c.<>9__1_0 ??= new Action(<>c.<>9.<Func>b__1_0));
        // 同一块下不同的闭包 lambda 也是使用的相同的类
        Invoke(new Action(<>c__DisplayClass1_.<Func>b__1));
        // 虽然仅仅捕获了 this, 但是此块已经有对应的类, 所以使用此类
        Invoke(new Action(<>c__DisplayClass1_.<Func>b__2));
    }
    public void Func2(string s) {
        // 仅仅捕获了 this, 且此块没有对应的类, 直接在 this 的类中生成方法
        Invoke(new Action(<Func2>b__2_0));
        // 此类中的所有的非闭包 lambda 都对应的同一个类
        Invoke(<>c.<>9__2_1 ??= new Action(<>c.<>9.<Func2>b__2_1));
    }
    private Random rand = new();
    private bool Condition() => rand.Next(2) == 0;
    private void Invoke(Action action) => action?.Invoke();
    private void <Func2>b__2_0() => Console.Write(field);
}

using System.Collections.Generic;
public class C {
    private int i = 2;
    public IEnumerable<int> Func(int k) {
        i += 2;
        yield return i;
        for (int j = 0; j < 10; j++) {
            k += 2;
            i += k;
            yield return i;
        }
    }
}

// 以下省略了所有的特性 (Attribute)
using System;
using System.Collections.Generic;
public class C {
    // 由迭代器生成的类, 既实现了 IEnumerable 也实现了 IEnuemrator
    private sealed class <Func>d__1 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable {
        // 状态机的状态， -2 表示新生成, -1 代表结束
        private int <>1__state;
        // yield return 对应的返回值
        private int <>2__current;
        private int <>l__initialThreadId;
        // 参数 k 在迭代时的值
        private int k;
        // 参数 k 的初始值
        public int <>3__k;
        // 捕获的 this
        public C <>4__this;
        // 原局部变量 j
        private int <j>5__1;
        int IEnumerator<int>.Current => <>2__current;
        object IEnumerator.Current => <>2__current;
        public <Func>d__1(int <>1__state) {
            this.<>1__state = <>1__state;
            <>l__initialThreadId = Environment.CurrentManagedThreadId;
        }
        void IDisposable.Dispose() { }
        // 具体实现
        private bool MoveNext() {
            switch (<>1__state) {
                default:
                    return false;
                case 0:
                    <>1__state = -1;
                    <>4__this.i += 2;
                    <>2__current = <>4__this.i;
                    <>1__state = 1;
                    return true;
                case 1:
                    <>1__state = -1;
                    <j>5__1 = 0;
                    break;
                case 2:
                    <>1__state = -1;
                    <j>5__1++;
                    break;
            }
            if (<j>5__1 < 10) {
                k += 2;
                <>4__this.i += k;
                <>2__current = <>4__this.i;
                <>1__state = 2;
                return true;
            }
            return false;
        }
        bool IEnumerator.MoveNext() => return this.MoveNext();
        void IEnumerator.Reset() => throw new NotSupportedException();
        // 由 Enumerable 生成 IEnumerator (但这里实际是同一个类型)
        IEnumerator<int> IEnumerable<int>.GetEnumerator() {
            <Func>d__1 <Func>d__;
            // 若此为新生成的且处于生成时的线程中时直接将自己作为 IEnumerator 否则新建一个
            if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId) {
                <>1__state = 0;
                <Func>d__ = this;
            }
            else {
                <Func>d__ = new <Func>d__1(0);
                <Func>d__.<>4__this = <>4__this;
            }
            // 将参数的初始值赋值给实际会使用的值
            <Func>d__.k = <>3__k;
            return <Func>d__;
        }
        IEnumerator IEnumerable.GetEnumerator() => return ((IEnumerable<int>)this).GetEnumerator();
    }
    private int i = 2;
    // 原方法
    public IEnumerable<int> Func(int k) {
        // 生成一个实例, 将状态设置为 -2
        <Func>d__1 <Func>d__ = new <Func>d__1(-2);
        // 捕获 this 和所有的参数
        <Func>d__.<>4__this = this;
        <Func>d__.<>3__k = k;
        // 直接返回这个实例
        return <Func>d__;
    }
}

using System;
using System.Threading.Tasks;
public class C {
    private int i;
    public async Task<int> FuncAsync(Action longTimeWork) {
        int k = 13;
        await Task.Delay(100);
        i += k;
        await Task.Run(longTimeWork);
        i *= k;
        await Task.Run(longTimeWork);
        return i;
    }
}

using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
public class C {
    // 由异步方法生成的类, 实现 IAsyncStateMachine 接口
    private sealed class <FuncAsync>d__1 : IAsyncStateMachine {
        // 状态机的状态, -2 代表出错, -1 代表准备开始
        public int <>1__state;
        public AsyncTaskMethodBuilder<int> <>t__builder;
        // 捕获到的参数和 this
        public Action longTimeWork;
        public C <>4__this;
        // 原局部变量
        private int <k>5__1;
        private TaskAwaiter <>u__1;
        // 具体实现
        private void MoveNext() {
            int num = <>1__state;
            int i;
            try {
                TaskAwaiter awaiter3;
                TaskAwaiter awaiter2;
                TaskAwaiter awaiter;
                switch (num) {
                    default:
                        <k>5__1 = 13;
                        awaiter3 = Task.Delay(100).GetAwaiter();
                        if (!awaiter3.IsCompleted) {
                            num = (<>1__state = 0);
                            <>u__1 = awaiter3;
                            <FuncAsync>d__1 stateMachine = this;
                            <>t__builder.AwaitUnsafeOnCompleted(ref awaiter3, ref stateMachine);
                            return;
                        }
                        goto IL_0089;
                    case 0:
                        awaiter3 = <>u__1;
                        <>u__1 = default(TaskAwaiter);
                        num = (<>1__state = -1);
                        goto IL_0089;
                    case 1:
                        awaiter2 = <>u__1;
                        <>u__1 = default(TaskAwaiter);
                        num = (<>1__state = -1);
                        goto IL_010e;
                    case 2:
                        {
                            awaiter = <>u__1;
                            <>u__1 = default(TaskAwaiter);
                            num = (<>1__state = -1);
                            break;
                        }
                        IL_010e:
                        awaiter2.GetResult();
                        <>4__this.i *= <k>5__1;
                        awaiter = Task.Run(longTimeWork).GetAwaiter();
                        if (!awaiter.IsCompleted) {
                            num = (<>1__state = 2);
                            <>u__1 = awaiter;
                            <FuncAsync>d__1 stateMachine = this;
                            <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
                            return;
                        }
                        break;
                        IL_0089:
                        awaiter3.GetResult();
                        <>4__this.i += <k>5__1;
                        awaiter2 = Task.Run(longTimeWork).GetAwaiter();
                        if (!awaiter2.IsCompleted) {
                            num = (<>1__state = 1);
                            <>u__1 = awaiter2;
                            <FuncAsync>d__1 stateMachine = this;
                            <>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
                            return;
                        }
                        goto IL_010e;
                }
                awaiter.GetResult();
                i = <>4__this.i;
            }
            catch (Exception exception) {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult(i);
        }
        void IAsyncStateMachine.MoveNext() => this.MoveNext();
        private void SetStateMachine(IAsyncStateMachine stateMachine) { }
        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine) => this.SetStateMachine(stateMachine);
    }
    private int i;
    // 原方法
    public Task<int> FuncAsync(Action longTimeWork) {
        <FuncAsync>d__1 stateMachine = new <FuncAsync>d__1();
        stateMachine.<>t__builder = AsyncTaskMethodBuilder<int>.Create();
        stateMachine.<>4__this = this;
        stateMachine.longTimeWork = longTimeWork;
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }
}

// if (num >= 1.0)
ldloc.1 // num
ldc.r8 1
blt.un label

// hitInfo.SourceDamage = Math.Max((int)SourceDamage.ApplyTo(baseDamage), 1);
ldloca.s 1 // hitInfo
ldarg.0 // this
ldflda NPC.HitModifiers.SourceDamage
ldarg.1 // baseDamage
call StatModifier.ApplyTo(float)
conv.i4
ldc.i4.1
call Math.Max(int, int)
call NPC.HitInfo.set_SourceDamage(int)

// return Math.Clamp((int)dmg, 1, Math.Min(_damageLimit, 4));
ldloc.s 5 // dmg
conv.i4
ldc.i4.1
ldarg.0  // this
ldfld NPC.HitModifiers._damageLimit
ldc.i4.4
call Math.Min(int, int)
call Math.Clamp(int, int, int)
ret

// damage = Math.Max(damage - damageReduction, 1);
ldloc.0 // damage
ldloc.3 // damageReduction
sub
ldc.r4 1
call Math.Max(float, float)
stloc.0

// return Math.Clamp((int)statModifier.ApplyTo(damage), 1, _damageLimit);
ldloca.s 6 // statModifier (this.FinalDamage)
ldloc.0    // damage
call StatModifier.ApplyTo(float)
conv.i4
ldc.i4.1
ldarg.0    // this
ldfld NPC.HitModifiers._damageLimit
call Math.Clamp(int,int,int)
ret

// set_Damage: this._damage = Math.Max(value, 1);
ldarg.0 // this
ldarg.1 // value
ldc.i4.1
call Math.Max(int, int)
stfld NPC.HitInfo._damage
ret

// set_SourceDamage: this._sourceDamage = Math.Max(value, 1);
ldarg.0 // this
ldarg.1 // value
ldc.i4.1
call Math.Max(int, int)
stfld NPC.HitInfo._sourceDamage
ret

// if (flag3)
ldloc.s 10  // flag3 (this.damage > 0)
brfalse label

ILCursor cursor = new(il);
ILLabel bleLabel = null;
cursor.GotoNext(MoveType.AfterLabel,
    i => i.MatchLdloc1(),
    i => i.MatchLdcR8(1.0),
    i => i.MatchBltUn(out bleLabel));
cursor.EmitLdloc1();
cursor.EmitLdcR8(0.0);
// 使用 Target 而不是直接使用标签作为参数是为了创建一个新的标签出来, 防止耦合
cursor.EmitBltUn(bleLabel.Target);
cursor.EmitBr(il.Instrs[cursor.Index + 3]);

// 通过反射获得各种需要的 FieldInfo 和 MethodInfo
FieldInfo npcHitModifiersSourceDamage = typeof(NPC.HitModifiers).GetField(nameof(NPC.HitModifiers.SourceDamage));
MethodInfo statModifierApplyTo = typeof(StatModifier).GetMethod(nameof(StatModifier.ApplyTo));
MethodInfo mathMaxInt = typeof(Math).GetMethod(nameof(Math.Max), BindingFlags.Public | BindingFlags.Static, [typeof(int), typeof(int)]);
MethodInfo npcHitInfoSetSourceDamage = typeof(NPC.HitInfo).GetProperty(nameof(NPC.HitInfo.SourceDamage)).GetSetMethod();

ILCursor cursor = new(il);
cursor.GotoNext(MoveType.AfterLabel,
    i => i.MatchLdloca(1),
    i => i.MatchLdarg0(),
    i => i.MatchLdflda(npcHitModifiersSourceDamage),
    i => i.MatchLdarg1(),
    i => i.MatchCall(statModifierApplyTo),
    i => i.MatchConvI4(),
    i => i.MatchLdcI4(1),
    i => i.MatchCall(mathMaxInt),
    i => i.MatchCall(nPCHitInfoSetSourceDamage));
for (Instruction i = cursor.Next; !i.MatchLdcI4(1); i = i.Next) {
    cursor.Emit(i.OpCode, i.Operand);
}
cursor.EmitLdcI4(0);
cursor.EmitCall(mathMaxInt);
cursor.EmitCall(npcHitInfoSetSourceDamage);
cursor.EmitBr(il.Instrs[cursor.Index + 9]);

// 通过反射获得各种需要的 FieldInfo 和 MethodInfo
npcHitModifiers_damageLimit= typeof(NPC.HitModifiers).GetField("_damageLimit", BindingFlags.NonPublic | BindingFlags.Instance);
MethodInfo mathMinInt = typeof(Math).GetMethod(nameof(Math.Min), bfps, [typeof(int), typeof(int)]);
MethodInfo mathClampInt = typeof(Math).GetMethod(nameof(Math.Clamp), bfps, [typeof(int), typeof(int), typeof(int)]);

ILCursor cursor = new(il);
cursor.GotoNext(MoveType.AfterLabel,
    i => i.MatchLdloc(5),
    i => i.MatchConvI4(),
    i => i.MatchLdcI4(1),
    i => i.MatchLdarg0(),
    i => i.MatchLdfld(npcHitModifiers_damageLimit),
    i => i.MatchLdcI4(4),
    i => i.MatchCall(mathMinInt),
    i => i.MatchCall(mathClampInt),
    i => i.MatchRet());
for(Instruction i = cursor.Next!; !i.MatchRet(); i = i.Next) {
    if(i.MatchLdcI4(1)) {
        cursor.EmitLdcI4(0);
        continue;
    }
    cursor.Emit(i.OpCode, i.Operand);
}
cursor.EmitBr(il.Instrs[cursor.Index + 8]);

MethodInfo mathMaxFloat = typeof(Math).GetMethod(nameof(Math.Max), bfps, [typeof(float), typeof(float)]);

// 使用上一部分的 cursor 接着搜索
cursor.GotoNext(MoveType.AfterLabel,
    i => i.MatchLdloc0(),
    i => i.MatchLdloc3(),
    i => i.MatchSub(),
    i => i.MatchLdcR4(1),
    i => i.MatchCall(mathMaxFloat),
    i => i.MatchStloc0());
cursor.EmitLdloc0();
cursor.EmitLdloc3();
cursor.EmitSub();
cursor.EmitLdcR4(0);
cursor.EmitCall(mathMaxFloat);
cursor.EmitStloc0();
cursor.EmitBr(il.Instrs[cursor.Index + 6]);

MethodInfo statModifierApplyTo = typeof(StatModifier).GetMethod(nameof(StatModifier.ApplyTo));

cursor.GotoNext(MoveType.AfterLabel,
    i => i.MatchLdloca(6),
    i => i.MatchLdloc0(),
    i => i.MatchCall(statModifierApplyTo),
    i => i.MatchConvI4(),
    i => i.MatchLdcI4(1),
    i => i.MatchLdarg0(),
    i => i.MatchLdfld(npcHitModifiers_damageLimit),
    i => i.MatchCall(mathClampInt),
    i => i.MatchRet());
for(Instruction i = cursor.Next!; !i.MatchRet(); i = i.Next) {
    if(i.MatchLdcI4(1)) {
        cursor.EmitLdcI4(0);
        continue;
    }
    cursor.Emit(i.OpCode, i.Operand);
}
cursor.EmitBr(il.Instrs[cursor.Index + 8]);

ILCursor cursor = new(il);
cursor.GotoNext(MoveType.After, i => i.MatchLdcI4(1));
cursor.EmitPop();
cursor.EmitLdcI4(0);

ILCursor cursor = new(il);
cursor.GotoNext(MoveType.AfterLabel, i => i.MatchLdloc(10), il => il.MatchBrfalse(out _));
cursor.EmitLdarg0();
cursor.EmitLdloc(10);
cursor.EmitDelegate((Projectile p, bool flag) => CanDamage ? p.damage >= 0 : flag);
cursor.EmitBr(il.Instrs[cursor.Index + 1]);