C# parallel Lesezugriff ohne zur Liste Kopieren

Question

folgendes Beispiel:

class Example 
{ 
    private readonly List<string> _list = new List<string>(); 
    private readonly object _lock = new object(); 

    public IReadOnlyList<string> Contents 
    { 
     get 
     { 
      lock (_lock) 
      { 
       return new List<string>(_list); 
      } 
     } 
    } 

    public void ModifyOperation(string example) 
    { 
     lock (_lock) 
     { 
      // ... 
      _list.Add(example); 
      // ... 
     } 
    } 
} 

Wie parallel Zugriff auf die Contents Liste lesen konnte, ohne das Kopieren der gesamten Liste erreicht werden? In C# gibt es gleichzeitig Collections, aber es gibt keine threadsichere Liste. In Java gibt es so etwas wie die CopyOnWriteArrayList.

Answer 1

Meiner Meinung nach ist die ImmutableList<T> Klasse von System.Collections.Immutable Paket für solche Szenario perfekt. Es implementiert IReadOnlyList<T>, und da es unveränderlich ist, d. H. Nie geändert, können Sie es direkt aus dem Lesezugriff zurückgeben. Die Synchronisation benötigt wird zwischen den modifizierenden Operationen sein:

class Example 
{ 
    private ImmutableList<string> _list = ImmutableList<string>.Empty; 
    private readonly object _lock = new object(); 

    public IReadOnlyList<string> Contents => _list; 

    public void ModifyOperation(string example) 
    { 
     lock (_lock) 
     { 
      // ... 
      _list = _list.Add(example); 
      // ... 
     } 
    } 
} 

Answer 2

Lock-Free-Vorschlag ...

class Example 
{ 
    private ImmutableList<String> _list = ImmutableList<String>.Empty; 

    public IReadOnlyList<String> Contents { get { return _list; } } 

    public void ModifyOperation(String example) 
    { 
     ImmutableList<String> original; 
     ImmutableList<String> afterChange; 
     do 
     { 
      original = _list; 
      afterChange = _list.Add(example); 
     } 
     while (Interlocked.CompareExchange(ref _list, afterChange, original) != original); 
    } 
}