LINQ延遲執行中返回IEnumerable的

Question

考慮一個簡單的Registry類被多個線程訪問方法使用鎖時：

public class Registry 
{ 
    protected readonly Dictionary<int, string> _items = new Dictionary<int, string>(); 
    protected readonly object _lock = new object(); 

    public void Register(int id, string val) 
    { 
     lock(_lock) 
     { 
      _items.Add(id, val); 
     } 
    } 

    public IEnumerable<int> Ids 
    { 
     get 
     { 
      lock (_lock) 
      { 
       return _items.Keys; 
      } 
     } 
    } 
} 

和典型用法：

var ids1 = _registry.Ids;//execution deferred until line below 
var ids2 = ids1.Select(p => p).ToArray(); 

這個類不是線程安全的，因爲它是可能收到System.InvalidOperationException

收藏被修改;枚舉操作可能不會執行。

時IDS2分配如果作爲_items.Keys執行不鎖下進行的線程調用Register！

這可以通過修改Ids返回一個IList予以糾正：

public IList<int> Ids 
    { 
     get 
     { 
      lock (_lock) 
      { 
       return _items.Keys.ToList(); 
      } 
     } 
    } 

但你失去了很多的延遲執行的「善」的，例如

var ids = _registry.Ids.First(); //much slower! 

所以，
1）在這種特殊情況下，是否有任何線程安全的選項，涉及IEnumerable
2）什麼是一些最佳實踐時wo與IEnumerable和鎖？

Answer 1

當訪問您的Ids屬性，則該詞典不能被更新，但沒有什麼可以從在同一時間爲IEnumerator<int>從Ids得到了LINQ延遲執行更新停止字典。

在Ids屬性內調用.ToArray()或.ToList()，並且鎖內部將消除此處的線程問題，只要字典的更新也被鎖定。不鎖定字典和ToArray()的更新，它仍然可能導致競爭條件，因爲內部.ToArray()和.ToList()對IEnumerable進行操作。

爲了解決這個問題，你需要在鎖內取得ToArray的性能命中率，並鎖定你的字典更新，或者你可以創建一個自己的線程安全的自定義IEnumerator<int>。只有通過控制迭代（並在該點鎖定），或者通過鎖定數組副本，才能實現這一點。

• Iterating Atomically
• Thread Safe Enumeration

Answer 2

如果使用yield return內的財產，那麼編譯器將確保鎖被採取的第一次調用MoveNext()：

一些例子可以在下面找到，並在統計員被處置時被釋放。

但是，我會避免使用這個，因爲執行不當的調用者代碼可能會忘記調用Dispose，從而造成死鎖。

public IEnumerable<int> Ids  
{ 
    get  
    { 
     lock (_lock)    
     { 
      // compiler wraps this into a disposable class where 
      // Monitor.Enter is called inside `MoveNext`, 
      // and Monitor.Exit is called inside `Dispose` 

      foreach (var item in _items.Keys) 
       yield return item; 
     }   
    }  
} 

Answer 3

只需使用ConcurrentDictionary<TKey, TValue>。

注意ConcurrentDictionary<TKey, TValue>.GetEnumerator是線程安全的：

普查員從字典返回的安全與讀取和寫入字典