Liste des threads sécurisés en C#

1. Liste des threads sécurisés avec la classe ConcurrentBag en C#
2. Thread Safe List avec la classe ConcurrentQueue en C#
3. Thread Safe List avec la classe SynchronizedCollection en C#

Ce didacticiel présentera les méthodes pour créer une liste thread-safe en C#.

Liste des threads sécurisés avec la classe ConcurrentBag en C#

La classe ConcurrentBag est utilisée pour créer une collection de données non ordonnée thread-safe en C#. La classe ConcurrentBag est très similaire à la List en C# et peut être utilisée comme une liste thread-safe en C#. Pour utiliser la classe ConcurrentBag, nous devons importer le namespace System.Collections.Concurrent dans notre projet. Plusieurs threads peuvent accéder simultanément à un objet ConcurrentBag, mais le contenu de l’objet ConcurrentBag ne peut être modifié que de manière synchrone. Cela le rend à la fois utilisable avec plusieurs threads pour des opérations simultanées et à l’abri de la perte accidentelle de données. L’exemple de code suivant nous montre comment créer une liste thread-safe avec la classe ConcurrentBag en C#.

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);
      }
    }
  }
}

Production:

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

Dans le code ci-dessus, nous avons créé une liste thread-safe avec la classe ConcurrentBag en C#. La fonction pour ajouter de nouveaux éléments Add() est la même dans les structures de données ConcurrentBag et List. La seule différence est que la List fonctionne sur le principe du premier entré, premier sorti (FIFO), tandis que le ConcurrentBag fonctionne sur le principe du dernier entré, premier sorti (LIFO). Ce problème est abordé dans les exemples de code ci-dessous.

Thread Safe List avec la classe ConcurrentQueue en C#

La classe ConcurrentQueue permet de créer une structure de données de file d’attente thread-safe en C#. La ConcurrentQueue fonctionne sur le principe du premier entré, premier sorti, tout comme la List en C#. L’objet ConcurrentQueue peut être utilisé à la place de l’objet List pour créer une structure de données thread-safe. Consultez l’exemple de code suivant.

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);
      }
    }
  }
}

Production:

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

Dans le code ci-dessus, nous avons créé une structure de données List thread-safe avec la classe ConcurrentQueue en C#. Il y a pas mal de différences entre les méthodes disponibles dans les structures de données List et ConcurrentQueue. Par exemple, la méthode pour ajouter un nouvel élément dans la structure de données List est Add(). En revanche, la méthode pour ajouter un nouvel élément dans la structure de données ConcurrentQueue est Enqueue(), qui ressemble à une structure de données Queue conventionnelle en C#. Cet inconvénient de la structure de données ConcurrentQueue est abordé dans l’exemple suivant.

Thread Safe List avec la classe SynchronizedCollection en C#

La classe SynchronizedCollection est utilisée pour créer une collection d’objets thread-safe d’un type spécifié en C#. La structure de données SynchronizedCollection est très similaire à la structure de données List en C#. Les deux structures de données fonctionnent sur le principe du premier entré, premier sorti. La fonction pour ajouter un nouvel élément dans les structures de données SynchronizedCollection et List est Add(). Consultez l’exemple suivant.

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);
      }
    }
  }
}

Production:

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

Dans le code ci-dessus, nous avons créé une liste thread-safe avec la classe SynchronizedCollection en C#. Jusqu’à présent, cette approche est la meilleure parmi les deux autres approches pour implémenter la fonctionnalité d’une structure de données de liste en C# car elle suit le même principe FIFO et contient les mêmes méthodes.