Créer des données encapsulées avec des structs en C#

En travaillant sur le projet pour suivre les détails de la commande, vous avez besoin d’un moyen de conserver les informations connexes telles que le nom du client, l’adresse d’expédition et le total des commandes ensemble. Les structs en C# vous permettent de créer un conteneur encapsulé de base pour ces données, ce qui facilite l’utilisation et la transmission en tant qu’unité unique.

Comprendre les structs

Les structs sont des types valeur en C#, ce qui signifie qu’ils stockent directement leurs données plutôt que de les référencer. Vous utilisez le struct mot clé pour définir un struct. Les structs sont généralement utilisés pour les petits types centrés sur les données qui fournissent un comportement minimal.

• Les structs ont une sémantique de valeur, ce qui signifie que leurs valeurs sont copiées pendant les appels d’affectation ou de méthode.
• Les cas d’usage courants incluent des nombres, des valeurs booléennes, des caractères et des instances de temps.
• Les structs sont couramment utilisés pour représenter des données légères telles que des formes géométriques (par exemple, , RectangleCircle), des coordonnées ou des paramètres de configuration.

Les structs conviennent mieux aux données petites, immuables et critiques en matière de performances. Pour les objets plus volumineux et plus complexes ou lorsque le comportement est un focus, envisagez d’utiliser des classes à la place. Contrairement aux classes, les structs ne peuvent pas hériter d’autres structs ou classes, mais ils peuvent implémenter des interfaces.

Définir et implémenter un struct

public struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

L’exemple de code montre comment définir un struct avec des champs et un constructeur en C#.

Les structs peuvent également implémenter des interfaces, mais ne peuvent pas hériter d’autres classes ou structs.

Encapsuler des données avec des structs

L’encapsulation vous permet de contrôler l’accès aux données dans un struct. Utilisez des modificateurs d’accès tels que private, publicou internal pour spécifier l’accessibilité.

• Les champs et propriétés peuvent être rendus privés pour restreindre l’accès direct.
• Les méthodes peuvent fournir des moyens contrôlés d’interagir avec les données.

Par exemple:

public struct Rectangle
{
    private int width;
    private int height;

    public Rectangle(int width, int height)
    {
        this.width = width;
        this.height = height;
    }

    public int Area => width * height;
}

L’exemple de code illustre un struct en C# avec des champs encapsulés et une propriété calculée pour la zone.

Appliquer un modificateur en lecture seule aux structs pour l’immuabilité

L’immuabilité garantit qu’une fois qu’un struct est créé, ses données ne peuvent pas être modifiées. Un struct est utile lors de l’utilisation de données qui doivent rester constantes tout au long de sa durée de vie, telles que les coordonnées ou les valeurs de configuration. Lorsque vous appliquez le readonly modificateur à un struct, vous pouvez appliquer l’immuabilité, ce qui rend votre code plus prévisible et moins sujet aux erreurs provoquées par des modifications involontaires.

public readonly struct ImmutablePoint
{
    public int X { get; init; }
    public int Y { get; init; }

    public ImmutablePoint(int x, int y)
    {
        X = x;
        Y = y;
    }
}

L’exemple de code illustre l’utilisation du readonly modificateur pour créer un struct immuable en C#.

Utiliser des initialiseurs d’objets avec des structs

Lorsque vous utilisez des structs, vous devez souvent initialiser plusieurs propriétés. Les initialiseurs d’objets fournissent un moyen simple et lisible de créer et d’initialiser des instances de struct en une seule étape. Cette approche réduit le code répétitif et rend votre intention claire.

L’exemple de code suivant définit un struct avec des propriétés qui regroupent les données associées et facilitent l’initialisation et l’utilisation d’instances du struct.

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

À l’aide d’un initialiseur d’objet, vous pouvez créer et initialiser un Point:

var point = new Point { X = 10, Y = 20 };

L’exemple de code montre comment utiliser un initialiseur d’objet pour définir des valeurs de propriété lors de la création d’une instance de struct.

Exemple pratique : utilisation de structs pour représenter des points dans l’espace 2D

Les structs sont souvent utilisés pour représenter de petites structures de données immuables. Par exemple, vous pouvez utiliser un struct pour représenter un point dans l’espace 2D et calculer la distance entre deux points :

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public double DistanceTo(Point other)
    {
        int dx = X - other.X;
        int dy = Y - other.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

var point1 = new Point(3, 4);
var point2 = new Point(7, 1);
Console.WriteLine($"Distance between points: {point1.DistanceTo(point2)}");

Cet exemple montre comment définir un struct pour un point, calculer la distance entre deux points et utiliser le struct dans un programme simple.

La combinaison d’encapsulation, d’immuabilité et d’initialiseurs d’objets vous permet de créer des structs efficaces et prévisibles. Ces fonctionnalités vous aident à gérer les données associées de manière propre et organisée.