如何用Moq测试System.Threading.Timer构造函数中TimerCallback方法是否被调用

针对你遇到的问题，这里提供几个实用的改进思路，既能避免等待15分钟定时器触发，又能覆盖私有回调方法MethodC的测试：

方案一：重构回调逻辑为独立可测试组件（推荐） #

核心思路是把MethodC的业务逻辑从MyClass中抽离，封装成一个独立的服务类，通过依赖注入传入MyClass。这样既解耦了Timer回调逻辑，又能轻松用Moq验证方法调用。

步骤： #

1. 定义回调逻辑的接口和实现类：

public interface ITimerTaskService
{
    void ExecuteTask();
}

public class TimerTaskService : ITimerTaskService
{
    public void ExecuteTask()
    {
        // 原MethodC的业务逻辑
    }
}

2. 重构MyClass，依赖ITimerTaskService和抽象的ITimer：

public interface ITimer
{
    void Dispose();
}

// 封装System.Threading.Timer实现ITimer
public class SystemTimerWrapper : ITimer
{
    private readonly Timer _timer;

    public SystemTimerWrapper(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
    {
        _timer = new Timer(callback, state, dueTime, period);
    }

    public void Dispose() => _timer.Dispose();
}

public class MyClass : IDisposable
{
    private readonly ITimer _timer;
    private readonly ITimerTaskService _taskService;

    // 生产环境构造函数
    public MyClass(ITimerTaskService taskService, TimeSpan dueTime, TimeSpan period)
    {
        _taskService = taskService;
        _timer = new SystemTimerWrapper(OnTimerElapsed, null, dueTime, period);
    }

    // 测试用构造函数，直接注入ITimer
    public MyClass(ITimerTaskService taskService, ITimer timer)
    {
        _taskService = taskService;
        _timer = timer;
    }

    private void OnTimerElapsed(object? state)
    {
        _taskService.ExecuteTask();
    }

    public void Dispose() => _timer.Dispose();
}

3. 编写测试用例（以xUnit+Moq为例）：

public class MyClassTests
{
    [Fact]
    public void TimerElapsed_ShouldExecuteTaskService()
    {
        // Arrange
        var mockTaskService = new Mock<ITimerTaskService>();
        var mockTimer = new Mock<ITimer>();

        // 手动触发回调逻辑（不用等定时器）
        var myClass = new MyClass(mockTaskService.Object, mockTimer.Object);
        var onTimerElapsed = typeof(MyClass).GetMethod("OnTimerElapsed", BindingFlags.NonPublic | BindingFlags.Instance);
        onTimerElapsed?.Invoke(myClass, new object[] { null });

        // Assert
        mockTaskService.Verify(s => s.ExecuteTask(), Times.Once);
    }
}

优点：解耦业务逻辑和Timer依赖，测试扩展性强；缺点：需要一定的代码重构。

方案二：通过构造参数控制Timer触发时间+反射验证私有方法 #

如果不想大规模重构，可以修改MyClass的构造函数，允许传入dueTime和period参数，测试时设为TimeSpan.Zero让Timer立即触发，再用反射验证MethodC是否被调用。

步骤： #

1. 修改MyClass构造：

public class MyClass : IDisposable
{
    private readonly Timer _timer;
    private bool _methodCWasCalled;

    public MyClass(TimeSpan dueTime, TimeSpan period)
    {
        _timer = new Timer(MethodC, null, dueTime, period);
    }

    private void MethodC(object? state)
    {
        _methodCWasCalled = true;
        // 原业务逻辑
    }

    // 测试用：暴露私有方法的调用状态（或者用反射直接获取）
    public bool WasMethodCCalled() => _methodCWasCalled;

    public void Dispose() => _timer.Dispose();
}

2. 编写测试用例：

public class MyClassTests
{
    [Fact]
    public void TimerShouldTriggerMethodCImmediately()
    {
        // Arrange
        using var myClass = new MyClass(TimeSpan.Zero, Timeout.InfiniteTimeSpan);

        // 用反射手动触发MethodC
        var methodC = typeof(MyClass).GetMethod("MethodC", BindingFlags.NonPublic | BindingFlags.Instance);
        methodC?.Invoke(myClass, new object[] { null });

        // Assert
        Assert.True(myClass.WasMethodCCalled());
    }
}

优点：改动小，快速实现测试；缺点：依赖反射，测试耦合度较高。

方案三：使用测试框架的私有方法访问工具 #

部分测试框架提供了直接访问私有成员的工具，比如NUnit的PrivateType，可以直接验证私有方法的调用次数：

public class MyClassTests
{
    [Test]
    public void TimerElapsed_CallsMethodC()
    {
        // Arrange
        var myClass = new MyClass(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
        var privateType = new PrivateType(typeof(MyClass));

        // 手动触发私有方法
        privateType.InvokeStatic("MethodC", myClass, new object[] { null });

        // Assert
        var wasCalled = (bool)privateType.GetField("_methodCWasCalled", myClass);
        Assert.IsTrue(wasCalled);
    }
}

优点：无需修改生产代码；缺点：测试与实现细节强耦合，代码重构后测试容易失效。

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