Thread-sichere Liste in C#

1. Thread-sichere Liste mit der Klasse ConcurrentBag in C#
2. Thread-sichere Liste mit der Klasse ConcurrentQueue in C#
3. Thread-sichere Liste mit der Klasse SynchronizedCollection in C#

In diesem Tutorial werden die Methoden zum Erstellen einer thread-sicheren Liste in C# vorgestellt.

Thread-sichere Liste mit der Klasse ConcurrentBag in C#

Die Klasse ConcurrentBag wird verwendet, um eine thread-sichere, ungeordnete Sammlung von Daten in C# zu erstellen. Die Klasse ConcurrentBag ist der List in C# sehr ähnlich und kann in C# als threadsichere Liste verwendet werden. Um die Klasse ConcurrentBag zu verwenden, müssen wir den Namespace System.Collections.Concurrent in unser Projekt importieren. Mehrere Threads können gleichzeitig auf ein ConcurrentBag-Objekt zugreifen, der Inhalt im ConcurrentBag-Objekt kann jedoch nur synchron geändert werden. Es macht es sowohl mit mehreren Threads für gleichzeitige Vorgänge verwendbar als auch sicher vor versehentlichem Datenverlust. Das folgende Codebeispiel zeigt, wie Sie mit der Klasse ConcurrentBag in C# eine thread-sichere Liste erstellen.

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

namespace thread_safe_list {
  class Program {
    static void Main(string[] args) {
      ConcurrentBag<int> numbers = new ConcurrentBag<int>();
      numbers.Add(0);
      numbers.Add(1);
      numbers.Add(2);
      numbers.Add(3);
      numbers.Add(4);
      numbers.Add(5);
      Console.WriteLine("ConcurrentBag");
      foreach (var number in numbers) {
        Console.WriteLine(number);
      }
      List<int> nums = new List<int>();
      nums.Add(0);
      nums.Add(1);
      nums.Add(2);
      nums.Add(3);
      nums.Add(4);
      nums.Add(5);
      Console.WriteLine("List");
      foreach (var number in nums) {
        Console.WriteLine(number);
      }
    }
  }
}

Ausgabe:

ConcurrentBag
5
4
3
2
1
0
List
0
1
2
3
4
5

Im obigen Code haben wir eine thread-sichere Liste mit der Klasse ConcurrentBag in C# erstellt. Die Funktion zum Hinzufügen neuer Elemente Add() ist in den Datenstrukturen ConcurrentBag und List gleich. Der einzige Unterschied besteht darin, dass die Liste nach dem Prinzip des First-In-First-Out (FIFO) arbeitet, während die ConcurrentBag nach dem Prinzip des Last-In-First-Out (LIFO) arbeitet. Dieses Problem wird in den folgenden Codebeispielen behoben.

Thread-sichere Liste mit der Klasse ConcurrentQueue in C#

Mit der Klasse ConcurrentQueue wird eine threadsichere Warteschlangendatenstruktur in C# erstellt. Die ConcurrentQueue arbeitet nach dem Prinzip des First In, First Out, genau wie die List in C#. Das Objekt ConcurrentQueue kann anstelle des Objekts List verwendet werden, um eine thread-sichere Datenstruktur zu erstellen. Siehe den folgenden Beispielcode.

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

namespace thread_safe_list {
  class Program {
    static void Main(string[] args) {
      Console.WriteLine("Concurrent Queue");
      ConcurrentQueue<int> numbers = new ConcurrentQueue<int>();
      numbers.Enqueue(0);
      numbers.Enqueue(1);
      numbers.Enqueue(2);
      numbers.Enqueue(3);
      numbers.Enqueue(4);
      numbers.Enqueue(5);
      foreach (var number in numbers) {
        Console.WriteLine(number);
      }
      Console.WriteLine("List");
      List<int> nums = new List<int>();
      nums.Add(0);
      nums.Add(1);
      nums.Add(2);
      nums.Add(3);
      nums.Add(4);
      nums.Add(5);
      foreach (var number in nums) {
        Console.WriteLine(number);
      }
    }
  }
}

Ausgabe:

Concurrent Queue
0
1
2
3
4
5
List
0
1
2
3
4
5

Im obigen Code haben wir eine thread-sichere Listendatenstruktur mit der Klasse ConcurrentQueue in C# erstellt. Es gibt einige Unterschiede zwischen den in den Datenstrukturen List und ConcurrentQueue verfügbaren Methoden. Die Methode zum Hinzufügen eines neuen Elements in der Datenstruktur Liste lautet beispielsweise Add(). Im Gegensatz dazu lautet die Methode zum Hinzufügen eines neuen Elements zur Datenstruktur ConcurrentQueue Enqueue(), was einer herkömmlichen Datenstruktur Queue in C# ähnelt. Dieser Nachteil der Datenstruktur ConcurrentQueue wird im folgenden Beispiel angesprochen.

Thread-sichere Liste mit der Klasse SynchronizedCollection in C#

Die Klasse SynchronizedCollection wird verwendet, um eine thread-sichere Sammlung von Objekten eines bestimmten Typs in C# zu erstellen. Die Datenstruktur SynchronizedCollection ist der Datenstruktur List in C# sehr ähnlich. Beide Datenstrukturen arbeiten nach dem Prinzip von first in first out. Die Funktion zum Hinzufügen eines neuen Elements sowohl in der Datenstruktur SynchronizedCollection als auch in der Datenliste List lautet Add(). Siehe folgendes Beispiel.

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

namespace thread_safe_list {
  class Program {
    static void Main(string[] args) {
      Console.WriteLine("Synchronized Collection");
      SynchronizedCollection<int> numbers = new SynchronizedCollection<int>();
      numbers.Add(0);
      numbers.Add(1);
      numbers.Add(2);
      numbers.Add(3);
      numbers.Add(4);
      numbers.Add(5);
      foreach (var number in numbers) {
        Console.WriteLine(number);
      }
      Console.WriteLine("List");
      List<int> nums = new List<int>();
      nums.Add(0);
      nums.Add(1);
      nums.Add(2);
      nums.Add(3);
      nums.Add(4);
      nums.Add(5);
      foreach (var number in nums) {
        Console.WriteLine(number);
      }
    }
  }
}

Ausgabe:

Synchronized Collection
0
1
2
3
4
5
List
0
1
2
3
4
5

Im obigen Code haben wir eine thread-sichere Liste mit der Klasse SynchronizedCollection in C# erstellt. Bisher ist dieser Ansatz der beste unter den beiden anderen Ansätzen zur Implementierung der Funktionalität einer Listendatenstruktur in C#, da er demselben FIFO-Prinzip folgt und dieselben Methoden enthält.