代码编译时方法中函数执行的计数

Question

我想计算'ExecuteAction'函数在类方法中出现的次数。

public class A : B
{
  public void X()
  {
    ExecuteAction(....);
    ExecuteAction(....);
  }
}

分数是2，因为ExecuteAction出现了2次。我需要它，因为我建立测试框架，并希望允许外部测试操作员知道当前的步骤执行在哪里，它将在哪里结束。有可能这样做吗?或者我应该改变我的方法吗?

谢谢。

Answer 1

下面是演示如何通过反射读取方法体并计算特定方法的所有调用的方法:

class Foo {
    public void SomeMethod() {
        ExecuteAction();
        ExecuteAction();
    }
    public void ExecuteAction() {
        //
    }
}
// --- Read the IL ---
var mInfo = typeof(Foo).GetMethod("SomeMethod");
var token = typeof(Foo).GetMethod("ExecuteAction").MetadataToken;
var methodBody = mInfo.GetMethodBody();
var rawIL = methodBody.GetILAsByteArray();
int counter = 0;
var reader = new ILReader(rawIL);
while(reader.Read(mInfo)) {
    if(reader.OpCode == OpCodes.Call && object.Equals(reader.MetadataToken, token)) {
        System.Console.WriteLine("Method "{0}" call detected", reader.Operand);
        counter++;
    }
}
System.Console.WriteLine("Total: {0}", counter);

ILReader类的实现如下(这个特定任务的最小实现):

class ILReader {
    readonly byte[] msil;
    int ptr;
    public ILReader(byte[] msil) {
        this.msil = msil;
    }
    public OpCode OpCode { get; private set; }
    public int MetadataToken { get; private set; }
    public object Operand { get; private set; }
    public bool Read(MethodInfo methodInfo) {
        if(ptr < msil.Length) {
            OpCode = ReadOpCode();
            Operand = ReadOperand(OpCode, methodInfo);
            return true;
        }
        return false;
    }
    OpCode ReadOpCode() {
        byte instruction = ReadByte();
        if(instruction != 254)
            return singleByteOpCode[instruction];
        else
            return doubleByteOpCode[ReadByte()];
    }
    object ReadOperand(OpCode code, MethodInfo methodInfo) {
        MetadataToken = 0;
        switch(code.OperandType) {
            case OperandType.InlineMethod:
                MetadataToken = ReadInt();
                System.Type[] methodArgs = null;
                if(methodInfo.GetType() != typeof(ConstructorInfo))
                    methodArgs = methodInfo.GetGenericArguments();
                System.Type[] typeArgs = null;
                if(methodInfo.DeclaringType != null)
                    typeArgs = methodInfo.DeclaringType.GetGenericArguments();
                return methodInfo.Module.ResolveMember(MetadataToken, typeArgs, methodArgs);
        }
        return null;
    }
    byte ReadByte() {
        return msil[ptr++];
    }
    int ReadInt() {
        byte b1 = ReadByte();
        byte b2 = ReadByte();
        byte b3 = ReadByte();
        byte b4 = ReadByte();
        return (int)b1 | (((int)b2) << 8) | (((int)b3) << 16) | (((int)b4) << 24);
    }
    #region static
    static ILReader() {
            CreateOpCodes();
        }
    static OpCode[] singleByteOpCode;
    static OpCode[] doubleByteOpCode;
    static void CreateOpCodes() {
        singleByteOpCode = new OpCode[225];
        doubleByteOpCode = new OpCode[31];
        FieldInfo[] fields = GetOpCodeFields();
        for(int i = 0; i < fields.Length; i++) {
            OpCode code = (OpCode)fields[i].GetValue(null);
            if(code.OpCodeType == OpCodeType.Nternal)
                continue;
            if(code.Size == 1)
                singleByteOpCode[code.Value] = code;
            else
                doubleByteOpCode[code.Value & 0xff] = code;
        }
    }
    static FieldInfo[] GetOpCodeFields() {
        return typeof(OpCodes).GetFields(BindingFlags.Public | BindingFlags.Static);
    }
    #endregion static
}

Answer 2

为什么不编写一个脚本来计算函数在源代码中出现的次数呢?类似以下语句:

static void Main(string[] args)
    {
        int count = 0;
        using (StreamReader sr = new StreamReader(System.IO.File.OpenRead(@"<filepath>/Program.cs")))
        {
            while (sr.Peek()>0)
            {
                string line = sr.ReadLine();
                if (line.Contains("Function(") 
                    && !(line.Contains("class") || line.Contains("static") || line.Contains("public")))
                {
                    count++;
                }
            }
        }
        Console.WriteLine(count);
        Console.Read();
    }