如何统计C#方法中初始化的字段？

using System;
using System.Reflection;
using System.Reflection.Emit;

public class MyClass
{
    private int myField = 10;

    public void MyMethod()
    {
        int localVar = 20;
        int anotherVar = 30;
        int result = localVar + anotherVar + myField;
        Console.WriteLine(result);
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(MyClass);
        MethodInfo methodInfo = type.GetMethod("MyMethod");
        MethodBody methodBody = methodInfo.GetMethodBody();

        byte[] ilBytes = methodBody.GetILAsByteArray();
        ILReader ilReader = new ILReader(ilBytes);

        Console.WriteLine("Initialized fields in MyMethod:");
        foreach (ILInstruction instruction in ilReader)
        {
            if (instruction.OpCode == OpCodes.Ldfld || instruction.OpCode == OpCodes.Stfld)
            {
                FieldInfo fieldInfo = (FieldInfo)instruction.Operand;
                Console.WriteLine(fieldInfo.Name);
            }
        }
    }
}

public class ILReader : IEnumerable<ILInstruction>
{
    private readonly byte[] ilBytes;

    public ILReader(byte[] ilBytes)
    {
        this.ilBytes = ilBytes;
    }

    public IEnumerator<ILInstruction> GetEnumerator()
    {
        int offset = 0;
        while (offset < ilBytes.Length)
        {
            OpCode opCode = OpCodes.Nop;
            object operand = null;

            byte code = ilBytes[offset++];
            if (code != 0xFE)
            {
                opCode = OpCodes.OneByteOpCodes[code];
            }
            else
            {
                code = ilBytes[offset++];
                opCode = OpCodes.TwoByteOpCodes[code];
            }

            if (opCode.OperandType != OperandType.InlineNone)
            {
                int operandSize = opCode.OperandType == OperandType.ShortInlineBrTarget ? 1 : 4;
                byte[] operandBytes = new byte[operandSize];
                Array.Copy(ilBytes, offset, operandBytes, 0, operandSize);
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(operandBytes);
                }

                if (opCode.OperandType == OperandType.ShortInlineBrTarget)
                {
                    operand = (sbyte)operandBytes[0];
                }
                else
                {
                    operand = BitConverter.ToInt32(operandBytes, 0);
                }

                offset += operandSize;
            }

            yield return new ILInstruction(opCode, operand);
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class ILInstruction
{
    public OpCode OpCode { get; }
    public object Operand { get; }

    public ILInstruction(OpCode opCode, object operand)
    {
        OpCode = opCode;
        Operand = operand;
    }
}