CA2000 在 ConcurrentDictionary 中保存引用时处理警告

Question

I have a parent class that has a collection of child classes. Both classes are IDisposable . I am receiving warning CA2000 ("Call Dispose on object ... before all references to it are out of scope."), but I don't want to Dispose() it in the same method call it's created, as the child has a long lifetime. I'm keeping a reference to it in the parent class. If that reference is in a Dictionary or a ConcurrentBag , all is well. If the reference is in a ConcurrentDictionary , CA2000 is listed.

As far as I can tell I'm implementing IDisposable correctly. Perhaps the way I'm iterating a concurrent collection and calling Dispose() could be improved, although I suspect that's not the source of the warning.

Is this a bug in the compiler/warnings, or can I achieve compliance through code? My stab at a theory is that it's being of the function syntax used to add the reference, but I'm not sure.

The following example reproduces the warning, with child1 and child3 being fine, but child2 producing the warning, when the only difference is the container type:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;

public class ParentDisposable : IDisposable
{
    private readonly Dictionary<string, ChildDisposable> dictionary = new Dictionary<string, ChildDisposable>();
    private readonly ConcurrentDictionary<string, ChildDisposable> concurrentDictionary = new ConcurrentDictionary<string, ChildDisposable>();
    private readonly ConcurrentBag<ChildDisposable> concurrentBag = new ConcurrentBag<ChildDisposable>();

    public void CreateChild()
    {
        // I want to create these disposable children, use them beyond the lifetime of this method call, and dispose of them when this parent class is disposed of
        var child1 = new ChildDisposable(); // No warning
        var child2 = new ChildDisposable(); // Warning CA2000  Call System.IDisposable.Dispose on object created by 'new ChildDisposable()' before all references to it are out of scope.
        var child3 = new ChildDisposable(); // No Warning
        this.dictionary.Add("key", child1);
        this.concurrentDictionary.AddOrUpdate("key", child2, (k, v) => child2);
        this.concurrentBag.Add(child3);
    }

    #region IDisposable Pattern
    private bool disposedValue = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposedValue)
        {
            if (disposing)
            {
                foreach (var key in this.dictionary.Keys)
                {
                    this.dictionary[key].Dispose();
                }

                foreach (var key in this.concurrentDictionary.Keys)
                {
                    this.concurrentDictionary[key].Dispose();
                }

                foreach (var child in this.concurrentBag)
                {
                    child.Dispose();
                }
            }

            this.disposedValue = true;
        }
    }

    public void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }
    #endregion IDisposable Pattern
}

public class ChildDisposable : IDisposable
{
    private EventWaitHandle waitObject = new EventWaitHandle(false, EventResetMode.AutoReset);

    #region IDisposable Pattern
    private bool disposedValue = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposedValue)
        {
            this.waitObject.Dispose();
            this.disposedValue = true;
        }
    }

    public void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }
    #endregion IDisposable Pattern
}

Answer 1

This is not a problem in your code, it's an oversight in the version of FxCop you are using.

This has been fixed in the latest version. See https://github.com/dotnet/roslyn-analyzers/issues/3082