C# 这段代码被认为是递归吗？

我有一个处理下一个逻辑的无休止的过程（注意

ServiceUtilities\u OnReSubscribing

到

timer\u Expressed

）之间的圆圈-当ServiceUtilities\u OnReSubscribing中出现异常时，它将创建一个新的计时器

t

，并在finish中完成“如果发生't'，则计划调用ServiceUtilities\u重新订阅

我想知道C#stack在这种情况下是如何工作的，它被认为是递归吗

    System.Timers.Timer timer;
    readonly object timerLocker = new object();

    void ServiceUtilities_OnReSubscribing()
    {
        lock (timerLocker)
        {
            try
            {
                 //do something
            }
            catch (Exception ex)
            {
                //do somehing...
                timer = SetTimer();
                timer.Start();
            }
        }
    }

    void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        CleanTimer(timer);
        ServiceUtilities_OnReSubscribing();
    }


    private System.Timers.Timer SetTimer()
    {
        int miliSeconds = 0;
        if (int.TryParse(ConfigurationManager.AppSettings["ReSubscribingTimer"], out miliSeconds) == false)
            miliSeconds = 3000;

        if (miliSeconds <= 1000)
            miliSeconds = 3000;

        System.Timers.Timer timer = new System.Timers.Timer(miliSeconds);
        timer.Enabled = true;
        timer.Elapsed += timer_Elapsed;
        return timer;
    }

    private void CleanTimer(System.Timers.Timer timer)
    {
        timer.Elapsed -= timer_Elapsed;
        timer.Dispose();
    }

System.Timers.Timer；
只读对象timerLocker=新对象（）；
作废ServiceUtilities\u on重新订阅（）
{
锁（计时器锁）
{
尝试
{
//做点什么
}
捕获（例外情况除外）
{
//做点什么。。。
timer=SetTimer（）；
timer.Start（）；
}
}
}
无效计时器（对象发送器，System.Timers.ElapseDevenTargets e）
{
清洁定时器（定时器）；
ServiceUtilities_on重新订阅（）；
}
private System.Timers.Timer SetTimer（）
{
整数毫秒=0；
如果（int.TryParse（ConfigurationManager.AppSettings[“ReSubscribingTimer”]，out毫秒）=false）
毫秒=3000；
如果（毫秒您的
timer\u expead
方法是从计时器线程调用的，因此它与重新订阅时的
ServiceUtilities\u不在同一调用堆栈上

因此，您不必担心堆栈溢出，因为调用堆栈不会增长。
您从配置中读取的超时值是多少？没有递归，您也不必担心堆栈溢出异常。@HamletHakobyan
ServiceUtilities\u on重新订阅
calls
SetTimer
calls
timer\u passed
calls
ServiceUtilities\u重新订阅时（延迟）。如果我没有遗漏什么，这段代码是递归的。递归有两种类型：直接和。如果间接方法
A
调用
B
…在链中再次调用
A
。我认为这确实是一段递归代码。但这不会破坏堆栈跟踪，因为计时器将使用新的st调用即使此代码在逻辑上是递归的，也没有溢出堆栈的风险。