Python：如何检查当前函数Do的调用方法并执行条件控制？

Python 实现 #

通过inspect模块获取调用栈信息，提取调用方函数名后判断是否在排除列表中：

import inspect

def Do():
    # 获取调用栈，索引1对应直接调用方（索引0是Do自身）
    caller_frame = inspect.stack()[1]
    caller_name = caller_frame.function

    # 定义需要跳过逻辑的调用方列表
    excluded_callers = ["FuncA", "FuncB"]

    if caller_name not in excluded_callers:
        # 这里编写需要执行的核心逻辑
        print("执行核心逻辑")
    else:
        print(f"调用方{caller_name}在排除列表中，跳过核心逻辑")

def FuncA():
    Do()

def FuncB():
    Do()

def FuncC():
    Do()

# 测试调用
FuncA()
FuncB()
FuncC()

C# 实现 #

借助System.Diagnostics命名空间下的StackTrace类获取调用方信息：

using System;
using System.Diagnostics;

class CallerCheckDemo
{
    static void Do()
    {
        // 跳过当前Do函数的栈帧，获取直接调用方的栈帧
        StackTrace stackTrace = new StackTrace(1);
        StackFrame callerFrame = stackTrace.GetFrame(0);
        string callerName = callerFrame.GetMethod().Name;

        // 定义排除的调用方法列表
        string[] excludedCallers = { "FuncA", "FuncB" };

        if (!Array.Exists(excludedCallers, name => name == callerName))
        {
            Console.WriteLine("执行核心逻辑");
        }
        else
        {
            Console.WriteLine($"调用方{callerName}在排除列表中，跳过核心逻辑");
        }
    }

    static void FuncA()
    {
        Do();
    }

    static void FuncB()
    {
        Do();
    }

    static void FuncC()
    {
        Do();
    }

    static void Main()
    {
        FuncA();
        FuncB();
        FuncC();
    }
}

Java 实现 #

通过Thread.currentThread().getStackTrace()获取栈轨迹，定位调用方方法：

public class CallerCheckDemo {
    public static void Do() {
        // 获取当前线程的栈轨迹
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        // 索引2对应直接调用Do的方法（索引0是getStackTrace，索引1是Do自身）
        String callerName = stackTrace[2].getMethodName();

        // 定义需要跳过逻辑的调用方列表
        String[] excludedCallers = {"FuncA", "FuncB"};

        boolean isExcluded = false;
        for (String name : excludedCallers) {
            if (name.equals(callerName)) {
                isExcluded = true;
                break;
            }
        }

        if (!isExcluded) {
            System.out.println("执行核心逻辑");
        } else {
            System.out.printf("调用方%s在排除列表中，跳过核心逻辑%n", callerName);
        }
    }

    public static void FuncA() {
        Do();
    }

    public static void FuncB() {
        Do();
    }

    public static void FuncC() {
        Do();
    }

    public static void main(String[] args) {
        FuncA();
        FuncB();
        FuncC();
    }
}

注意事项 #

• 编译优化影响：代码混淆、JIT内联优化等操作可能会修改栈结构，导致无法正确识别调用方，这种场景下建议改用调用方显式传递标识参数的方案。
• 重载方法区分：如果存在同名重载方法，仅靠方法名无法精确匹配，需要获取方法的完整签名（如参数类型）来判断。
• 性能开销：获取调用栈会产生一定性能损耗，若Do函数被高频调用，需权衡使用。

内容的提问来源于stack exchange，提问作者Berkos