C# 为什么我的一些单元测试要运行多次？

当我使用Visual Studio的内置测试引擎运行解决方案中的所有单元测试时，我将看到一些测试运行多次，而其他测试只运行一次：

如果在同一个文件中有多个

TestClass

e，事情就会变得混乱。在此文件中，例如：

[TestClass]
public class AerationEngineTests
{
    protected IAerationEngine aerationEngine;
    protected AerationPackage aerationPackage;
    protected BinPackage bin;

    [TestInitialize]
    public void TestInitialize()
    {
        aerationEngine = new AerationEngine();
        aerationPackage = new AerationPackage();
        bin = new BinPackage();
        bin.Children.Add(new Shell {ShellDiameter = 75, RingCount = 15, RingHeight = RingHeights.RingHeight32});
    }

    [TestMethod]
    public void ShouldCalculateFloorArea()
    {
        // Arrange


        // Act
        var floorArea = aerationEngine.CalculateFloorArea(aerationPackage, bin);

        // Assert
        floorArea.ShouldBeInRange(4417.86, 4417.87);
    }

    [TestMethod]
    public void ShouldCalculateBinCapacity()
    {
        // Arrange
        aerationPackage.FillType = FillTypes.Peaked;
        var grainDepth = aerationEngine.CalculateGrainDepth(aerationPackage, bin);
        var floorArea = aerationEngine.CalculateFloorArea(aerationPackage, bin);
        var calculations = new FanCalculations {GrainDepth = grainDepth, FloorArea = floorArea};

        // Act
        var binCapacity = aerationEngine.CalculateMaxBinCapacity(calculations);

        // Assert
        binCapacity.ShouldBeInRange(175525.88, 175525.9);
    }

    [TestMethod]
    public void ShouldCalculateTargetAirFlow()
    {
        // Arrange
        aerationPackage.FillType = FillTypes.Peaked;
        aerationPackage.DesiredAirFlow = AirFlowRates.AirFlowOne4th;
        var grainDepth = aerationEngine.CalculateGrainDepth(aerationPackage, bin);
        var floorArea = aerationEngine.CalculateFloorArea(aerationPackage, bin);
        var calculations = new FanCalculations {GrainDepth = grainDepth, FloorArea = floorArea};
        var binCapacity = aerationEngine.CalculateMaxBinCapacity(calculations);
        calculations.MaxBinCapacity = binCapacity;

        // Act
        var airflow = aerationEngine.CalculateTargetAirflow(aerationPackage, calculations);

        // Assert
        airflow.ShouldBeInRange(43881.46, 43881.48);
    }

    [TestMethod]
    public void ShouldCalculateTargetAirFlowPerFan()
    {
        // Arrange
        aerationPackage.FillType = FillTypes.Peaked;
        aerationPackage.DesiredAirFlow = AirFlowRates.AirFlowOne4th;
        aerationPackage.FanCount = 4;
        var grainDepth = aerationEngine.CalculateGrainDepth(aerationPackage, bin);
        var floorArea = aerationEngine.CalculateFloorArea(aerationPackage, bin);
        var calculations = new FanCalculations {GrainDepth = grainDepth, FloorArea = floorArea};
        var binCapacity = aerationEngine.CalculateMaxBinCapacity(calculations);
        calculations.MaxBinCapacity = binCapacity;
        var airflow = aerationEngine.CalculateTargetAirflow(aerationPackage, calculations);
        calculations.TargetAirFlow = airflow;
        // Act
        var flowPerFan = aerationEngine.CalculateTargetAirflowPerFan(aerationPackage, calculations);

        // Assert
        flowPerFan.ShouldBeInRange(10970.3, 10970.4);
    }

    [TestMethod]
    public void ShouldCalculateFloorPressure()
    {
        // Arrange

        // Act
        var floorPressure = aerationEngine.CalculateFloorPressure(aerationPackage, bin);

        // Assert
        floorPressure.ShouldBeInRange(1943.0, 1945.0);
    }

    [TestMethod]
    public void ShouldCalculateTrenchWidth()
    {
        // Arrange
        aerationPackage.FillType = FillTypes.Peaked;
        aerationPackage.DesiredAirFlow = AirFlowRates.AirFlowOne4th;
        aerationPackage.FanCount = 4;
        var grainDepth = aerationEngine.CalculateGrainDepth(aerationPackage, bin);
        var floorArea = aerationEngine.CalculateFloorArea(aerationPackage, bin);
        var calculations = new FanCalculations {GrainDepth = grainDepth, FloorArea = floorArea};
        var binCapacity = aerationEngine.CalculateMaxBinCapacity(calculations);
        calculations.MaxBinCapacity = binCapacity;
        var airflow = aerationEngine.CalculateTargetAirflow(aerationPackage, calculations);
        calculations.TargetAirFlow = airflow;
        var flowPerFan = aerationEngine.CalculateTargetAirflowPerFan(aerationPackage, calculations);
        calculations.TargetAirFlowPerFan = flowPerFan;

        // Act
        var trenchWidth = aerationEngine.CalculateTrenchWidth(calculations);

        // Assert
        trenchWidth.ShouldBe(72);
    }
}

[TestClass]
public class CalculateGrainDepthMethod : AerationEngineTests
{
    [TestInitialize]
    public new void TestInitialize()
    {
        base.TestInitialize();
    }

    [TestMethod]
    public void ShouldCalculateLevelFillHeight()
    {
        // Arrange
        aerationPackage.FillType = FillTypes.Level;

        // Act
        var grainDepth = aerationEngine.CalculateGrainDepth(aerationPackage, bin);

        // Assert
        grainDepth.ShouldBe(40.0);
    }

    [TestMethod]
    public void ShouldCalculatePeakedFillHeight()
    {
        // Arrange
        aerationPackage.FillType = FillTypes.Peaked;

        // Act
        var grainDepth = aerationEngine.CalculateGrainDepth(aerationPackage, bin);

        // Assert
        grainDepth.ShouldBeInRange(46.64, 46.66);
    }
}

CalculateGrainDepthMethod

中的测试运行一次，但其余的测试方法运行两次，它们被分组在

CalculateGrainDepthMethod

下。请参阅此图片（使用ReSharper的工具）：

---

似乎没有两个测试引擎同时运行，但可能有？或者我只是错误地组织了测试本身？有人知道为什么这些测试会运行不止一次，以及为什么它们会被分组到它们不属于的类下吗？

您正在继承class

CalculateGrainDepthMethod

继承自

曝气网络测试。因此，类中的测试将执行两次曝气引擎测试

[TestClass]
public class CalculateGrainDepthMethod : AerationEngineTests
{

要么在class
CalculateGrainDepthMethod
中包含依赖项，要么创建一个初始化这些值的测试助手，并在两个测试类中使用它。
第二个建议“创建一个初始化这些值的测试助手”，是最适合我的情况的建议。然后，我给派生类中的
TestInitialize
方法指定
new
关键字，并调用
base.TestInitialize（）
。如果我有足够的代表，我会投票支持你的答案。请，任何看到这个的人，给他投票支持！