C# 使用NUnit'；时处理IDisposable实例的正确方法；s测试用例源

我有两个稍微不同的NUnit参数化单元测试变体（TestsA和TestsB），它们使用TestCaseSource将参数传递给测试。在每种情况下，我都会传递一个实现IDisposable接口的类的实例（我在示例中使用

System.Windows.Forms.Control

类）：

[TestFixture]
[类别（“测试A”）]
公共静态类TestsA
{
专用静态控制(u控制),；
[撕裂]
公共静态void拆卸（）
{
_CONTROL.Dispose（）；
}
私有静态类测试用例
{
公共静态IEnumerable TestCase1（）
{
_控件=新控件{Tag=1}；
返回新的TestCaseData（_CONTROL）；
}
公共静态IEnumerable TestCase2（）
{
_控件=新控件{Tag=2}；
返回新的TestCaseData（_CONTROL）；
}
}
[TestCaseSource（typeof（TestCases）、nameof（TestCases.TestCase1））]
公共静态无效测试1（控制）
{
if（control==null）
抛出新ArgumentNullException（nameof（control））；
AreEqual（1，（int）control.Tag）；
}
[TestCaseSource（typeof（TestCases）、nameof（TestCases.TestCase2））]
公共静态无效测试2（控制）
{
if（control==null）
抛出新ArgumentNullException（nameof（control））；
AreEqual（2，（int）control.Tag）；
}
}
[测试夹具]
[类别（“测试B”）]
公共静态类TestsB
{
私有静态类测试用例
{
公共静态IEnumerable TestCase1（）
{
返回新的TestCaseData（新控件{Tag=1}）；
}
公共静态IEnumerable TestCase2（）
{
返回新的TestCaseData（新控件{Tag=2}）；
}
}
[TestCaseSource（typeof（TestCases）、nameof（TestCases.TestCase1））]
公共静态无效测试1（控制）
{
if（control==null）
抛出新ArgumentNullException（nameof（control））；
AreEqual（1，（int）control.Tag）；
control.Dispose（）；
}
[TestCaseSource（typeof（TestCases）、nameof（TestCases.TestCase2））]
公共静态无效测试2（控制）
{
if（control==null）
抛出新ArgumentNullException（nameof（control））；
AreEqual（2，（int）control.Tag）；
control.Dispose（）；
}
}

我正试图找到处理IDisposable实例的正确方法。TestsA类中的测试使用一个TearDown方法进行处理。在TestsB中，我将在断言之后立即处理实例。但不管我怎么做，我最终都会得到一个CA2000警告。TestsA和TestsB的警告描述略有不同：

TestsA:
警告CA2000在方法“TestsA.TestCases.TestCase1（）”中，对象“new Control（）”未沿所有异常路径释放。在对象“new Control（）”的所有引用都超出范围之前，对其调用System.IDisposable.Dispose

TestsB:
警告CA2000在方法“TestsB.TestCases.TestCase1（）”中，在对象“new Control（）”上调用System.IDisposable.Dispose，然后对其进行所有引用，直到其超出范围

我的问题是：有没有更好的方法来处理通过TestCaseSource传递给NUnit测试的对象，或者我可以忽略警告

[TestFixture]
[Category("Tests A")]
public static class TestsA
{
    private static Control _CONTROL;

    [TearDown]
    public static void Teardown()
    {
        _CONTROL.Dispose();
    }

    private static class TestCases
    {
        public static IEnumerable<TestCaseData> TestCase1()
        {
            _CONTROL = new Control { Tag = 1 };
            yield return new TestCaseData(_CONTROL);
        }

        public static IEnumerable<TestCaseData> TestCase2()
        {
            _CONTROL = new Control { Tag = 2 };
            yield return new TestCaseData(_CONTROL);
        }
    }

    [TestCaseSource(typeof(TestCases), nameof(TestCases.TestCase1))]
    public static void Test1(Control control)
    {
        if (control == null)
            throw new ArgumentNullException(nameof(control));
        Assert.AreEqual(1, (int)control.Tag);
    }

    [TestCaseSource(typeof(TestCases), nameof(TestCases.TestCase2))]
    public static void Test2(Control control)
    {
        if (control == null)
            throw new ArgumentNullException(nameof(control));
        Assert.AreEqual(2, (int)control.Tag);
    }
}

[TestFixture]
[Category("Tests B")]
public static class TestsB
{
    private static class TestCases
    {
        public static IEnumerable<TestCaseData> TestCase1()
        {
            yield return new TestCaseData(new Control { Tag = 1 });
        }

        public static IEnumerable<TestCaseData> TestCase2()
        {
            yield return new TestCaseData(new Control { Tag = 2 });
        }
    }

    [TestCaseSource(typeof(TestCases), nameof(TestCases.TestCase1))]
    public static void Test1(Control control)
    {
        if (control == null)
            throw new ArgumentNullException(nameof(control));
        Assert.AreEqual(1, (int)control.Tag);
        control.Dispose();
    }

    [TestCaseSource(typeof(TestCases), nameof(TestCases.TestCase2))]
    public static void Test2(Control control)
    {
        if (control == null)
            throw new ArgumentNullException(nameof(control));
        Assert.AreEqual(2, (int)control.Tag);
        control.Dispose();
    }
}