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.Reliability：在方法“FooProvider.GetFooX()”中，在对象“bar”的所有引用超出范围之前调用 System.IDisposable.Dispose。”

微软建议永远不要抑制这个警告，但我不太确定它的警告是关于代码中的真正问题。确实，在我们考虑的任何“CreateFooX()”方法中，“bar”在超出范围之前都不会被释放，但对它的引用存在于“FooX”对象中，该对象最终将被释放，并依次负责释放“酒吧'。

我对 Dispose 模式应该如何工作的理解是否有误，并且我的代码中存在一些根本缺陷，或者我应该抑制此警告？

编辑

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

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 子句中。