Le c?ur de la conception d'objets immuables et de structures de données en C # est de s'assurer que l'état de l'objet n'est pas modifié après la création, améliorant ainsi la sécurité des threads et la réduction des bogues causés par les changements d'état. 1. Utilisez des champs Readonly et initialisez-les avec des constructeurs pour vous assurer que les champs ne sont attribués que des valeurs pendant la construction, comme indiqué dans la classe de personne; 2. Encapsulez le type de collection et utilisez des interfaces de collecte immuables telles que ReadOnlyCollection ou Immutablelist pour empêcher la modification externe des collections internes; 3. Utilisez l'enregistrement pour simplifier la définition du modèle immuable et générer des attributs en lecture seule et des constructeurs par défaut, adaptés à la modélisation des données; 4. Lors de la création d'opérations de collecte immuables, il est recommandé d'utiliser les types de System.Collections. Immutable, comme l'immutrabilité. Chaque modification renvoie une nouvelle instance pour s'assurer que les données d'origine restent inchangées et que la réutilisation de la mémoire est optimisée. Les méthodes ci-dessus garantissent conjointement l'immuabilité de l'objet tout au long de son cycle de vie.

Dans la conception d'objets immuables et de structures de données en C #, le noyau est de s'assurer qu'une fois un objet créé, son état ne peut pas être modifié. Cela aide non seulement à rédiger du code de filetage, mais réduit également les bogues potentiels causés par les changements d'état. La clé de la mise en ?uvre est d'utiliser des champs en lecture seule, de l'initialisation du constructeur et d'éviter d'exposer des états mutables.

1. Initialiser à l'aide de champs et de constructeurs readonly

L'objet immuable le plus fondamental en C # est implémenté en initialisant le champ et le constructeur readonly . readonly garantit que les champs ne peuvent être attribués qu'une seule fois dans le constructeur et ne peuvent pas être modifiés par la suite.

 classe publique
{
    public String FirstName {get; }
    public String LastName {get; }

    Personne publique (String FirstName, String LastName)
    {
        FirstName = FirstName;
        LastName = LastName;
    }
}

• Cette approche convient aux petits objets ou aux objets de valeur (tels que DTO).
• Toutes les propriétés sont en lecture seule et ne peuvent pas être modifiées à l'extérieur.
• Le constructeur est responsable de toutes les initialisations, claires et claires.

Cette méthode est simple et efficace, mais lorsque la structure de l'objet est complexe, vous pouvez rencontrer certaines limites, par exemple si les objets imbriqués restent également immuables.

2. Les types de collecte encapsulées pour maintenir l'immuabilité

Si votre objet contient des membres de la classe de collection, le renvoi List<T> ou Dictionary<TKey, TValue> peut directement briser l'immuabilité car l'appelant peut modifier le contenu de la collection.

La bonne fa?on de le faire est d'utiliser ReadOnlyCollection<T> ou ImmutableList<T> :

 Ordre de classe publique
{
    Liste de lecture privée <string> _Items;

    public ireaNonlyCollection <string> items => _items.asreadonly ();

    Ordre publique (éléments Ienumerable <string>)
    {
        _Items = new list <string> (items);
    }
}

Ou utilisez le type fourni par System.Collections.Immutable :

 Utilisation de System.Collections.imutable;

Ordre de classe publique
{
    public iimutableList <string> items {get; }

    Commande publique (iMMutableList <string> éléments)
    {
        Articles = articles ?? ImmutableList <string> .empty;
    }
}

• Il est recommandé d'utiliser des interfaces telles que IImmutableList<T> pour passer des collections invariantes.
• évitez d'exposer des collections internes directement aux modifications externes.
• Copiez en profondeur les données d'origine lors de l'initialisation pour empêcher les modifications ultérieures des références externes qui affectent l'état interne.

3. Simplifier les modèles immuables avec des enregistrements

En commen?ant par C # 9, record est idéal pour définir des types immuables. Il génère des propriétés en lecture seule par défaut et implémente automatiquement la logique égale et la sémantique immuable.

 Public Record Person (String FirstName, String LastName);

• Le compilateur génère automatiquement des constructeurs, des propriétés en lecture seule et With des expressions.
• Prend en charge la correspondance des modèles et la sémantique de valeur, qui sont idéales pour la modélisation des données.
• Si vous avez besoin de méthodes d'extension ou de logique supplémentaire, vous pouvez les ajouter en enregistrement.

Il convient de noter que bien que l'instance d'enregistrement soit immuable par défaut, si le champ lui-même est un objet mutable (comme une classe normale), la structure entière peut toujours être "immuable peu profonde". Par conséquent, il est nécessaire de s'assurer que les objets imbriqués sont également immuables.

4. Opération suggestions pour créer des collections immuables

Lorsque vous avez besoin d'exploiter fréquemment des collections (comme l'ajout et la suppression des éléments) et que vous souhaitez maintenir l'immuabilité, il est recommandé d'utiliser les types fournis par System.Collections.Immutable , par exemple: par exemple:

 Utilisation de System.Collections.imutable;

var list = immuableList <nt> .Empty;
list = list.add (1) .add (2); // Renvoie une nouvelle instance

• Chaque opération renvoie une nouvelle instance immuable au lieu de modifier l'objet d'origine.
• La réutilisation de la mémoire est optimisée en interne, avec de meilleures performances que la création de nouvelles listes à chaque fois.
• Les types communs incluent ImmutableList<t></t> , ImmutableDictionary<tkey tvalue></tkey> et ImmutableHashSet<t></t> .

Soyez prudent lorsque vous utilisez ces types:

• Ne mélangez pas les ensembles mutables et immuables, car ils peuvent facilement conduire à une mauvaise opération.
• Essayez d'utiliser IImmutableList<t></t> au lieu de classes d'implémentation concrète dans l'interface API, pour un remplacement et des tests faciles.
• Au cours de l'initialisation, les collections existantes peuvent être rapidement converties via .ToImmutableList() .

Fondamentalement, c'est tout. Le foyer de conception des objets immuables est de contr?ler les changements d'état et d'utiliser les fonctionnalités linguistiques et la prise en charge de la bibliothèque rationnellement. Bien qu'il s'agisse d'un peu plus d'étapes à écrire que la classe normale, les avantages en termes de concurrence et de cohérence des données en valent la peine.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!