VS2010代码分析期间的IDisposable和CA2000警告

Question

我在这里需要一些建议，希望有人可以帮助我。我有以下类结构（简化）：

public class Bar: IDisposable {...}

public abstract class FooBase: IDisposable
{
    Bar bar;
    bool disposed;

    internal FooBase(Bar bar)
    {
        this.bar=bar;
    }

    public void Dispose()
    {
         Dispose(true);
         GC.SupressFinalize(this);

    }

    protected void Dispose(bool disposing)
    {
         if (!this.disposed)
         {
             if (disposing)
             {
                 this.bar.Dispose();
             }

             this.disposed = true;
         }
    }
}

public FooA: Foo {...}
public FooB: Foo {...}

public static class FooProvider
{
    public static FooA GetFooA()
    {
       Bar bar = new Bar();
       ...
       return new FooA(bar);
    }

    public static FooB GetFooB()
    {
        Bar bar = new Bar();
        ...
        return new FooB(bar);
    }

    ...
}

当我对此运行代码分析时，我在 FooProvider 类的所有“CreateFooX()”方法上收到警告 CA2000。此警告提供以下消息：

“Microsoft. 可靠性：在方法 'FooProvider.GetFooX()' 中，在对象 'bar' 的所有引用超出范围之前调用 System.IDisposable.Dispose。”

Microsoft 建议不要禁止显示此警告，但我不确定它是否会警告代码中的实际问题。确实，在我们考虑的任何 'CreateFooX()' 方法中，在超出范围之前不会释放 'bar'，但对它的引用仍然存在于 'FooX' 对象中，该对象最终将被释放，并反过来处理释放 '吧”。

我是否对 Dispose 模式的工作方式理解有误，并且我的代码存在一些根本缺陷，还是应该直接取消此警告？

编辑

由于某些 cmets，我尝试将工厂方法修改为以下内容：

public static class FooProvider
{
    public static FooA GetFooA()
    {
       Bar bar = null;

       try
       {
           bar =  new Bar();
           ...
           return new FooA(bar);
       }
       catch
       {
           if (bar != null) bar.Dispose();
           throw;
       }
    }

    ...
}

但我仍然收到同样的警告。我想这只是一个误报，我可以放心使用它。

感谢您的建议。

Answer 1

这是代码分析部分的典型误报。它真的无法理解你的代码的内在情况，所以它给出了一个普遍的答案。请谨慎行事，但只要您确认您有误报，您就可以放心地忽略它。

Answer 2

这不是误报。如果在创建Bar 之后但在将其传递给Foo 构造函数之前抛出异常怎么办？我看到了几个代码路径，其中一个或多个对象可能不会被释放。

Answer 3

我觉得你的一次性模式有点不对劲。我认为您不应该在 FooBase 类中调用 bar.Dispose 。为了您正在处理的对象的安全，并且能够多次安全地调用 Dispose，我会推荐这种方法。

  private bool _disposed;
  public void Dispose()
  {
     Dispose( true );
     GC.SuppressFinalize( this );
  }

  protected virtual void Dispose( bool disposing )
  {
     if ( disposing )
     {
        if ( !_disposed )
        {
           if ( Bar != null )
           {
              Bar.Dispose();
           }

           _disposed = true;
        }
     }
  }

至于错误，我认为这应该处理静态分析警告。我在一个测试项目中按如下方式实现了您的代码，启用了所有静态分析警告而没有出现警告问题。

public class Bar : IDisposable
{
  private bool _disposed;
  public void Dispose()
  {
     Dispose( true );
     GC.SuppressFinalize( this );
  }

  protected virtual void Dispose( bool disposing )
  {
     if ( disposing )
     {
        if ( !_disposed )
        {
           _disposed = true;
        }
     }
  }
}

public abstract class FooBase : IDisposable
{
  public Bar Bar
  {
     get;
     set;
  }

  internal FooBase( Bar bar )
  {
     Bar = bar;
  }

  private bool _disposed;
  public void Dispose()
  {
     Dispose( true );
     GC.SuppressFinalize( this );
  }

  protected virtual void Dispose( bool disposing )
  {
     if ( disposing )
     {
        if ( !_disposed )
        {
           if ( Bar != null )
           {
              Bar.Dispose();
           }

           _disposed = true;
        }
     }
  }
}

public class FooA : FooBase
{
  public FooA( Bar bar )
     : base( bar )
  {
  }
}

public static class FooProvider
{
  public static FooA GetFooA()
  {
     Bar bar;
     using ( bar = new Bar() )
     {
        return new FooA( bar );
     }
  }
}

[TestClass]
public class UnitTest1
{
  [TestMethod]
  public void StaticAnalysisTest()
  {
     Assert.IsNotNull( FooProvider.GetFooA().Bar );
  }
}

我希望这会有所帮助。

Answer 4

这个问题至少有一部分不是真正的误报，即使它不一定是一个非常有用的问题检测。要解决您编辑版本的剩余问题，您需要在 bar 分配之后立即打开 try 块，而不是在它之前。 例如：

Bar bar = new Bar();
try
{
    ///...            
    return new FooA(bar);
}
catch
{
    bar.Dispose();
    throw;
}

很遗憾，在您进行此更改后，您仍会收到 CA2000 违规，这可能是误报。这是因为该规则不会检查您是否将bar 置于新创建的FooA 的状态中。如果它进入FooA 中的状态，您可以安全地为违规创建抑制。但是，如果它没有进入FooA 中的状态，您应该将它放在finally 子句中而不是catch 子句中。