C# Struct

En C#, une struct est un type valeur utilisé pour organiser et stocker des données associées.

En C#, une struct est une structure de données de type valeur, qui permet à une seule variable de stocker des données associées de divers types de données.

structLe mot-clé est utilisé pour créer une struct.

Une struct est utilisée pour représenter un enregistrement. Supposons que vous souhaitiez suivre le statut des livres dans une bibliothèque ; vous voudrez peut-être suivre les attributs suivants de chaque livre :

  • Title
  • Auteur
  • Sujet
  • ID du livre

Définir une struct

Pour définir une struct, vous devez utiliserstructinstruction.

structL'instruction définit un nouveau type de données avec plusieurs membres pour le programme.

Par exemple, vous pouvez déclarer la struct Book de la manière suivante :

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};

Le programme suivant démontre l'utilisation des structures :

Exemple

using System;
using System.Text;
     
struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1;        /* Déclarer Book1 de type Books */
      Books Book2;        /* Déclarer Book2 de type Books */

      /* détails du livre 1 */
      Book1.title = "Programmation C";
      Book1.author = "Nuha Ali";
      Book1.subject = "Tutoriel de programmation C";
      Book1.book_id = 6495407;

      /* détails du livre 2 */
      Book2.title = "Facturation télécom";
      Book2.author = "Zara Ali";
      Book2.subject =  "Tutoriel sur la facturation télécom";
      Book2.book_id = 6495700;

      /* Afficher les informations de Book1 */
      Console.WriteLine( "Titre du livre 1 : {0}", Book1.title);
      Console.WriteLine("Auteur du livre 1 : {0}", Book1.author);
      Console.WriteLine("Sujet du livre 1 : {0}", Book1.subject);
      Console.WriteLine("Identifiant du livre 1 :{0}", Book1.book_id);

      /* Afficher les informations de Book2 */
      Console.WriteLine("Titre du livre 2 : {0}", Book2.title);
      Console.WriteLine("Auteur du livre 2 : {0}", Book2.author);
      Console.WriteLine("Sujet du livre 2 : {0}", Book2.subject);
      Console.WriteLine("ID du livre 2 : {0}", Book2.book_id);      

      Console.ReadKey();

   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Caractéristiques des structures C#

Une structure fournit un type de données léger, adapté à la représentation de structures de données simples, avec de bonnes caractéristiques de performance et une sémantique de valeur :

  • Une structure peut avoir des méthodes, des champs, des index, des propriétés, des méthodes d'opérateur et des événements, et est adaptée pour représenter des situations de données légères telles que des coordonnées, des plages, des dates, des heures, etc.
  • Une structure peut définir des constructeurs, mais ne peut pas définir de destructeurs. Toutefois, vous ne pouvez pas définir de constructeur sans paramètre pour une structure. Le constructeur sans paramètre (par défaut) est automatiquement défini et ne peut pas être modifié.
  • Contrairement aux classes, les structures ne peuvent pas hériter d'autres structures ou classes.
  • Une structure ne peut pas être utilisée comme structure de base pour d'autres structures ou classes.
  • Les structures peuvent implémenter une ou plusieurs interfaces.
  • Les membres d'une structure ne peuvent pas être déclarés abstract, virtual ou protected.
  • Lorsque vous utilisezNewLorsque l’opérateur `new` est utilisé pour créer un objet struct, le constructeur approprié est appelé pour créer le struct. Contrairement aux classes, les structs peuvent être instanciés sans utiliser l’opérateur `new`.
  • Si l'opérateur New n'est pas utilisé, ce n'est qu'après que tous les champs ont été initialisés que les champs seront assignés et que l'objet sera utilisable.
  • Les variables de type struct sont généralement allouées sur la pile, ce qui rend leur création et leur destruction plus rapides. Toutefois, si un struct est utilisé comme champ d'une classe, et que la classe est un type référence, le struct sera stocké sur le tas.
  • Les structs sont mutables par défaut, ce qui signifie que vous pouvez modifier leurs champs. Toutefois, si un struct est défini comme readonly, ses champs seront immuables.

Classe vs Structure

Les classes et les structs ont des considérations différentes en matière de conception et d'utilisation. Les classes conviennent pour représenter des objets et des comportements complexes, en prenant en charge l'héritage et le polymorphisme, tandis que les structs conviennent mieux pour représenter des données légères et des types valeur, afin d'améliorer les performances et d'éviter la surcharge de la gestion des références.

Les classes et les structs présentent les différences fondamentales suivantes :

Types valeur vs types référence :

  • Un struct est un type valeur (Value Type) :Les structs sont des types valeur. Ils allouent de la mémoire sur la pile plutôt que sur le tas. Lorsqu'une instance de struct est passée à une méthode ou assignée à une autre variable, l'intégralité du contenu du struct est copiée.
  • Une classe est un type référence (Reference Type) :Les classes sont des types référence. Elles allouent de la mémoire sur le tas. Lorsqu'une instance de classe est passée à une méthode ou assignée à une autre variable, ce qui est réellement passé est la référence (adresse mémoire), et non une copie de l'objet entier.

Héritage et polymorphisme :

  • Les structs ne peuvent pas hériter :Un struct ne peut pas hériter d'autres structs ou classes, ni servir de classe de base pour d'autres structs ou classes.
  • Les classes prennent en charge l'héritage :Les classes prennent en charge l'héritage et le polymorphisme, et peuvent étendre les fonctionnalités des classes existantes en dérivant de nouvelles classes.

Constructeur par défaut :

  • Les structures ne peuvent pas avoir de constructeurs sans paramètre :Une structure ne peut pas contenir de constructeur sans paramètre.
  • Les classes peuvent avoir des constructeurs sans paramètre :Une classe peut contenir un constructeur sans paramètre. Si aucun constructeur n'est fourni, le système fournit un constructeur par défaut sans paramètre.

Comportement d'affectation :

  • Lorsqu'une variable d'un type de classe est affectée, elle stocke une référence, donc deux variables pointent vers le même objet.
  • Lorsqu'une variable de type structure est affectée, la structure entière est copiée, donc chaque variable possède sa propre copie indépendante.

Mode de passage :

  • Les objets de type classe sont passés par référence lors des appels de méthode, ce qui signifie que les modifications apportées à l'objet à l'intérieur d'une méthode affectent l'objet d'origine.
  • Les objets de type structure sont généralement passés par valeur, ce qui signifie qu'une copie de la structure est passée, et non l'objet de type structure d'origine lui-même. Par conséquent, les modifications apportées à la structure à l'intérieur d'une méthode n'affectent pas l'objet d'origine.

Nullabilité :

  • Une structure est un type valeur et ne peut pas être directement affectée ànull：carnullest la valeur par défaut d'un type référence, et non la valeur par défaut d'un type valeur. Si vous devez représenter l'état manquant ou non valide d'une variable de structure, vous pouvez utiliserNullable<T>ou appelésT?types Nullable.
  • Les classes peuvent être null par défaut :Les instances de classe peuvent par défaut êtrenull, car ce sont des types référence.

Performance et allocation de mémoire :

  • Les structures sont généralement plus légères :Comme les structs sont des types valeur et allouent de la mémoire sur la pile, elles sont généralement plus légères que les classes et adaptées à une représentation simple des données.
  • Les classes peuvent avoir plus de surcharge :Comme les classes sont des types référence, elles peuvent impliquer plus de surcharge mémoire et de gestion.

Dans l'exemple suivant, MyStruct est une struct, tandis que MyClass est une classe.

La section commentée démontre que les structures ne peuvent pas contenir de constructeurs sans paramètre, ne peuvent pas hériter, et que la copie d'une instance de struct copie l'intégralité du contenu de la struct. En revanche, les classes peuvent contenir des constructeurs sans paramètre, peuvent hériter, et la copie d'instance copie la référence.

Exemple

using System;

// Déclaration de struct
struct MyStruct
{
    public int X;
    public int Y;

    // Les structs ne peuvent pas avoir de constructeurs sans paramètre
    // public MyStruct()
    // {
    // }

    // Constructeur paramétré
    public MyStruct(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Une structure ne peut pas hériter
    // struct MyDerivedStruct : MyBaseStruct
    // {
    // }
}

// Déclaration de classe
class MyClass
{
    public int X;
    public int Y;

    // Une classe peut avoir un constructeur sans paramètre
    public MyClass()
    {
    }

    // Constructeur paramétré
    public MyClass(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Les classes prennent en charge l'héritage
    // class MyDerivedClass : MyBaseClass
    // {
    // }
}

class Program
{
    static void Main()
    {
        // Les structures sont des types valeur, allouées sur la pile
        MyStruct structInstance1 = new MyStruct(1, 2);
        MyStruct structInstance2 = structInstance1; // Copier toute la structure

        // Les classes sont des types de référence, allouées sur le tas
        MyClass classInstance1 = new MyClass(3, 4);
        MyClass classInstance2 = classInstance1; // Copier la référence, pointant vers le même objet

        // La modification d'une instance de structure n'affecte pas les autres instances
        structInstance1.X = 5;
        Console.WriteLine($"Structure : {structInstance1.X}, {structInstance2.X}");

        // La modification d'une instance de classe affectera les autres instances
        classInstance1.X = 6;
        Console.WriteLine($"Classe : {classInstance1.X}, {classInstance2.X}");
    }
}

D'après la discussion ci-dessus, réécrivons l'exemple précédent :

Exemple

using System;
using System.Text;
     
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void setValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id;
   }
   public void display()
   {
      Console.WriteLine("Titre : {0}", title);
      Console.WriteLine("Auteur : {0}", author);
      Console.WriteLine("Sujet : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1 = new Books(); /* Déclarer Book1 de type Books */
      Books Book2 = new Books(); /* Déclare Book2 de type Books */

      /* détails du livre 1 */
      Book1.setValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* détails du livre 2 */
      Book2.setValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

      /* Afficher les informations de Book1 */
      Book1.display();

      /* Afficher les informations de Book2 */
      Book2.display();

      Console.ReadKey();

   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Title : C Programming
Author : Nuha Ali
Subject : C Programming Tutorial
Book_id : 6495407
Title : Telecom Billing
Author : Zara Ali
Subject : Telecom Billing Tutorial
Book_id : 6495700
autres extensions