レジストリキーを連鎖させてキーを検索するとき、RegistryKeyを正しく閉じるにはどうすればいいですか？

Question

私はレジストリ内のキーを検索し、その値を返すために次の方法を使用しています。私はルートキーを使って検索し、ターゲットの相対パスを文字列として渡します。パスを解析する際には、前のキーをベースとして使用して次のレベルを開きます。私は厳密には読み取り専用なので、ベースキーを終了した後でベースキーを閉じる必要がありますか？もしそうなら、それはこれを行う方法ですか？

public static string QueryRegistry (RegistryKey root, string path) 
{ 
    return path.Split(Path.DirectorySeparatorChar) 
    .Aggregate(root, (r, k) => 
    { 
     var key = r?.OpenSubKey(k); 
     r?.Close(); 
     return key; 
    }).GetValue(null).ToString(); 
} 

Answer 1

だからここにあなたの基本的な問題は、あなたがIDisposableオブジェクトの不確定な数を作成している、とあなたはあなたがそれらを閉じて準備ができているよ時にわからないということです。このような状況で私がしているのは、それらを追跡するためのコレクションを作成し、それが済んだらコレクション内のすべてを破棄することです。ここにあなたのオブジェクトを適切に処分しないというリスクがあります。

public static string QueryRegistry (RegistryKey root, string path) 
{ 
    List<IDisposable> resourceTracker = new List<IDisposable>() { root }; 
    string ret = null; 
    try 
    { 
     ret = path.Split(Path.DirectorySeparatorChar) 
     .Aggregate(root, (r, k) => 
     { 
      var key = r?.OpenSubKey(k); 
      if (key != null) 
      { 
       resourceTracker.Add(key); 
      } 
      return key; 
     }).GetValue(null).ToString(); 
    } 
    finally 
    { 
     foreach (var res in resourceTracker) 
     { 
      res.Dispose(); 
     } 
    } 
    return ret; 
} 

あなたはCERでこれを行うために試みることができるが、私は新しい鍵を開けるかなり確信しては、CLRがとにかくCERとして扱いません意味の割り当てとしてカウントされます。しかし、これはおそらく十分安全であるはずです。クラスはビットを拡張することができることを

public static string QueryRegistry (RegistryKey root, string path) 
{ 
    string ret = null; 
    using (var resourceTracker = new DisposableCollection() { root }) 
    { 
     ret = path.Split(Path.DirectorySeparatorChar) 
     .Aggregate(root, (r, k) => 
     { 
      var key = r?.OpenSubKey(k); 
      if (key != null) 
      { 
       resourceTracker.Add(key); 
      } 
      return key; 
     }).GetValue(null).ToString(); 
    } 
    return ret; 
} 

：その後のように使用することができ

public class DisposableCollection : IList<IDisposable>, IDisposable 
{ 
    private List<IDisposable> disposables = new List<IDisposable>(); 

    #region IList<IDisposable> support 

    public int Count 
    { 
     get 
     { 
      return ((IList<IDisposable>)disposables).Count; 
     } 
    } 

    public bool IsReadOnly 
    { 
     get 
     { 
      return ((IList<IDisposable>)disposables).IsReadOnly; 
     } 
    } 

    public int IndexOf(IDisposable item) 
    { 
     return ((IList<IDisposable>)disposables).IndexOf(item); 
    } 

    public void Insert(int index, IDisposable item) 
    { 
     ((IList<IDisposable>)disposables).Insert(index, item); 
    } 

    public void RemoveAt(int index) 
    { 
     ((IList<IDisposable>)disposables).RemoveAt(index); 
    } 

    public void Add(IDisposable item) 
    { 
     ((IList<IDisposable>)disposables).Add(item); 
    } 

    public void Clear() 
    { 
     ((IList<IDisposable>)disposables).Clear(); 
    } 

    public bool Contains(IDisposable item) 
    { 
     return ((IList<IDisposable>)disposables).Contains(item); 
    } 

    public void CopyTo(IDisposable[] array, int arrayIndex) 
    { 
     ((IList<IDisposable>)disposables).CopyTo(array, arrayIndex); 
    } 

    public bool Remove(IDisposable item) 
    { 
     return ((IList<IDisposable>)disposables).Remove(item); 
    } 

    public IEnumerator<IDisposable> GetEnumerator() 
    { 
     return ((IList<IDisposable>)disposables).GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return ((IList<IDisposable>)disposables).GetEnumerator(); 
    } 

    public void AddRange(IEnumerable<IDisposable> range) 
    { 
     disposables.AddRange(range); 
    } 

    public IDisposable this[int index] 
    { 
     get 
     { 
      return ((IList<IDisposable>)disposables)[index]; 
     } 

     set 
     { 
      ((IList<IDisposable>)disposables)[index] = value; 
     } 
    } 
    #endregion 

    #region IDisposable Support 
    private bool disposedValue = false; // To detect redundant calls 


    protected virtual void Dispose(bool disposing) 
    { 
     if (!disposedValue) 
     { 
      if (disposing) 
      { 
       foreach(var disposable in disposables) 
       { 
        disposable.Dispose(); 
       } 
      } 

      // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. 
      // TODO: set large fields to null. 

      disposedValue = true; 
     } 
    } 

    // TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources. 
    // ~DisposableCollection() { 
    // // Do not change this code. Put cleanup code in Dispose(bool disposing) above. 
    // Dispose(false); 
    // } 

    // This code added to correctly implement the disposable pattern. 
    public void Dispose() 
    { 
     // Do not change this code. Put cleanup code in Dispose(bool disposing) above. 
     Dispose(true); 
     // TODO: uncomment the following line if the finalizer is overridden above. 
     // GC.SuppressFinalize(this); 
    } 


    #endregion 
} 

：（rory.apが提案多少のような）

これはそうのようなコレクションに抽象化することができ（ConcurrentBagまたはConcurrentQueueなどを使用して）、より具体的なニーズ（例えば、RegistryKeyのコレクション）に拡張することができ、複数の場所でこのロジックが必要な場合に便利です。