C# Struktur

In C# ist eine Struktur ein Werttyp, der verwendet wird, um zusammengehörige Daten zu organisieren und zu speichern.

In C# ist eine Struktur eine Datenstruktur vom Werttyp, die es einer einzelnen Variablen ermöglicht, zusammengehörige Daten verschiedener Datentypen zu speichern.

structDas Schlüsselwort wird verwendet, um eine Struktur zu erstellen.

Eine Struktur wird verwendet, um einen Datensatz darzustellen. Angenommen, Sie möchten den Status von Büchern in einer Bibliothek nachverfolgen; dann möchten Sie möglicherweise die folgenden Attribute jedes Buches nachverfolgen:

  • Title
  • Autor
  • Thema
  • Buch-ID

Struktur definieren

Um eine Struktur zu definieren, müssen Sie diestruct-Anweisung verwenden.

structDie Anweisung definiert einen neuen Datentyp mit mehreren Membern für das Programm.

Beispielsweise können Sie die Book-Struktur wie folgt deklarieren:

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

Das folgende Programm demonstriert die Verwendung von Strukturen:

Beispiel

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;        /* Book1 vom Typ Books deklarieren */
      Books Book2;        /* Book2 vom Typ Books deklarieren */

      /* Details zu Buch 1 */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali";
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* Details zu Buch 2 */
      Book2.title = "Telekommunikationsabrechnung";
      Book2.author = "Zara Ali";
      Book2.subject =  "Tutorial zur Telekommunikationsabrechnung";
      Book2.book_id = 6495700;

      /* Book1-Informationen ausgeben */
      Console.WriteLine( "Buch 1 Titel : {0}", Book1.title);
      Console.WriteLine("Buch 1 Autor : {0}", Book1.author);
      Console.WriteLine("Buch 1 Thema : {0}", Book1.subject);
      Console.WriteLine("Buch 1 book_id :{0}", Book1.book_id);

      /* Book2-Informationen ausgeben */
      Console.WriteLine("Buch 2 Titel : {0}", Book2.title);
      Console.WriteLine("Buch 2 Autor : {0}", Book2.author);
      Console.WriteLine("Buch 2 Thema : {0}", Book2.subject);
      Console.WriteLine("Buch 2 book_id : {0}", Book2.book_id);      

      Console.ReadKey();

   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

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

Merkmale von C#-Strukturen

Eine Struktur bietet einen leichtgewichtigen Datentyp, der sich für die Darstellung einfacher Datenstrukturen eignet und gute Leistungseigenschaften und Wertsemantik aufweist:

  • Eine Struktur kann Methoden, Felder, Indexer, Eigenschaften, Operatormethoden und Ereignisse enthalten und eignet sich für die Darstellung leichtgewichtiger Datensituationen wie Koordinaten, Bereiche, Datumsangaben, Zeiten usw.
  • Eine Struktur kann Konstruktoren definieren, aber keine Destruktoren. Ein parameterloser Konstruktor kann jedoch nicht für eine Struktur definiert werden. Der parameterlose Konstruktor (Standard) wird automatisch definiert und kann nicht geändert werden.
  • Im Gegensatz zu Klassen können Strukturen nicht von anderen Strukturen oder Klassen erben.
  • Eine Struktur kann nicht als Basisstruktur für andere Strukturen oder Klassen verwendet werden.
  • Strukturen können eine oder mehrere Schnittstellen implementieren.
  • Strukturmember können nicht als abstract, virtual oder protected deklariert werden.
  • Bei Verwendung vonNewWenn der `new`-Operator verwendet wird, um ein Struktur-Objekt zu erstellen, wird der entsprechende Konstruktor aufgerufen, um die Struktur zu erstellen. Im Gegensatz zu Klassen können Strukturen instanziiert werden, ohne den `new`-Operator zu verwenden.
  • Wenn der New-Operator nicht verwendet wird, werden die Felder erst dann zugewiesen und das Objekt erst dann verwendbar, nachdem alle Felder initialisiert wurden.
  • Strukturvariablen werden normalerweise auf dem Stack zugewiesen, was ihre Erstellung und Zerstörung schneller macht. Wenn eine Struktur jedoch als Feld einer Klasse verwendet wird und die Klasse ein Verweistyp ist, wird die Struktur auf dem Heap gespeichert.
  • Strukturen sind standardmäßig veränderbar, was bedeutet, dass Sie ihre Felder ändern können. Wenn eine Struktur jedoch als readonly definiert ist, sind ihre Felder unveränderlich.

Klasse vs. Struktur

Klassen und Strukturen haben unterschiedliche Überlegungen in Design und Verwendung. Klassen eignen sich zur Darstellung komplexer Objekte und Verhaltensweisen, unterstützen Vererbung und Polymorphismus, während Strukturen besser zur Darstellung leichter Daten und Werttypen geeignet sind, um die Leistung zu verbessern und den Overhead der Referenzverwaltung zu vermeiden.

Klassen und Strukturen haben die folgenden grundlegenden Unterschiede:

Werttypen vs. Verweistypen:

  • Eine Struktur ist ein Werttyp (Value Type):Strukturen sind Werttypen. Sie belegen Speicher auf dem Stack statt auf dem Heap. Wenn eine Strukturinstanz an eine Methode übergeben oder einer anderen Variablen zugewiesen wird, wird der gesamte Inhalt der Struktur kopiert.
  • Eine Klasse ist ein Verweistyp (Reference Type):Klassen sind Verweistypen. Sie belegen Speicher auf dem Heap. Wenn eine Klasseninstanz an eine Methode übergeben oder einer anderen Variablen zugewiesen wird, wird tatsächlich die Referenz (Speicheradresse) übergeben, nicht eine Kopie des gesamten Objekts.

Vererbung und Polymorphismus:

  • Strukturen können nicht erben:Eine Struktur kann nicht von anderen Strukturen oder Klassen erben und kann auch nicht als Basisklasse für andere Strukturen oder Klassen dienen.
  • Klassen unterstützen Vererbung:Klassen unterstützen Vererbung und Polymorphismus und können die Funktionalität vorhandener Klassen erweitern, indem neue Klassen abgeleitet werden.

Standardkonstruktor:

  • Strukturen können keine parameterlosen Konstruktoren haben:Eine Struktur kann keinen parameterlosen Konstruktor enthalten.
  • Klassen können parameterlose Konstruktoren haben:Eine Klasse kann einen parameterlosen Konstruktor enthalten. Wenn kein Konstruktor angegeben wird, stellt das System einen standardmäßigen parameterlosen Konstruktor bereit.

Zuweisungsverhalten:

  • Wenn einer Variablen eines Klassentyps ein Wert zugewiesen wird, speichert sie eine Referenz, sodass zwei Variablen auf dasselbe Objekt verweisen.
  • Wenn einer Strukturvariable ein Wert zugewiesen wird, wird die gesamte Struktur kopiert, sodass jede Variable eine eigene unabhängige Kopie besitzt.

Übergabemethode:

  • Objekte vom Klassentyp werden bei Methodenaufrufen per Referenz übergeben, was bedeutet, dass sich Änderungen, die innerhalb einer Methode am Objekt vorgenommen werden, auf das ursprüngliche Objekt auswirken.
  • Struktur-Objekte werden normalerweise per Wert übergeben, was bedeutet, dass eine Kopie der Struktur übergeben wird, nicht das ursprüngliche Strukturobjekt selbst. Daher wirken sich Änderungen, die innerhalb einer Methode an der Struktur vorgenommen werden, nicht auf das ursprüngliche Objekt aus.

Nullbarkeit:

  • Eine Struktur ist ein Werttyp und kann nicht direkt aufnull：gesetzt werden, weilnullder Standardwert eines Referenztyps ist, nicht der Standardwert eines Werttyps. Wenn Sie den fehlenden oder ungültigen Zustand einer Strukturvariable darstellen müssen, können SieNullable<T>oder genanntT?Nullable-Typen.
  • Klassen können standardmäßig null sein:Klasseninstanzen können standardmäßig null seinnull, weil sie Referenztypen sind.

Leistung und Speicherzuweisung:

  • Strukturen sind normalerweise leichtgewichtiger:Da Strukturen Werttypen sind und Speicher auf dem Stack belegen, sind sie im Allgemeinen leichter als Klassen und für einfache Datendarstellung geeignet.
  • Klassen können mehr Overhead haben:Da Klassen Referenztypen sind, können sie mehr Speicher-Overhead und Verwaltungsaufwand mit sich bringen.

Im folgenden Beispiel ist MyStruct eine Struktur, während MyClass eine Klasse ist.

Der auskommentierte Abschnitt zeigt, dass Strukturen keine parameterlosen Konstruktoren enthalten können, nicht erben können und dass das Kopieren einer Strukturinstanz den gesamten Inhalt der Struktur kopiert. Im Gegensatz dazu können Klassen parameterlose Konstruktoren enthalten, erben, und beim Kopieren einer Instanz wird die Referenz kopiert.

Beispiel

using System;

// Struct-Deklaration
struct MyStruct
{
    public int X;
    public int Y;

    // Strukturen können keine parameterlosen Konstruktoren haben
    // public MyStruct()
    // {
    // }

    // Parametrisierter Konstruktor
    public MyStruct(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Struktur kann nicht erben
    // struct MyDerivedStruct : MyBaseStruct
    // {
    // }
}

// Klassendeklaration
class MyClass
{
    public int X;
    public int Y;

    // Eine Klasse kann einen parameterlosen Konstruktor haben
    public MyClass()
    {
    }

    // Parametrisierter Konstruktor
    public MyClass(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Klassen unterstützen Vererbung
    // class MyDerivedClass : MyBaseClass
    // {
    // }
}

class Program
{
    static void Main()
    {
        // Strukturen sind Werttypen und werden auf dem Stack zugewiesen
        MyStruct structInstance1 = new MyStruct(1, 2);
        MyStruct structInstance2 = structInstance1; // Die gesamte Struktur kopieren

        // Klassen sind Referenztypen und werden auf dem Heap allokiert
        MyClass classInstance1 = new MyClass(3, 4);
        MyClass classInstance2 = classInstance1; // Die Referenz kopieren, die auf dasselbe Objekt zeigt

        // Das Ändern einer Strukturinstanz wirkt sich nicht auf andere Instanzen aus
        structInstance1.X = 5;
        Console.WriteLine($"Struktur: {structInstance1.X}, {structInstance2.X}");

        // Das Ändern einer Klasseninstanz wirkt sich auf andere Instanzen aus
        classInstance1.X = 6;
        Console.WriteLine($"Klasse: {classInstance1.X}, {classInstance2.X}");
    }
}

Auf Grundlage der obigen Diskussion wollen wir das vorherige Beispiel umschreiben:

Beispiel

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("Titel : {0}", title);
      Console.WriteLine("Autor : {0}", author);
      Console.WriteLine("Thema : {0}", subject);
      Console.WriteLine("Buch_id :{0}", book_id);
   }

};  

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

      Books Book1 = new Books(); /* Book1 vom Typ Books deklarieren */
      Books Book2 = new Books(); /* Deklariere Book2 vom Typ Books */

      /* Details zu Buch 1 */
      Book1.setValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* Details zu Buch 2 */
      Book2.setValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

      /* Book1-Informationen ausgeben */
      Book1.display();

      /* Book2-Informationen ausgeben */
      Book2.display();

      Console.ReadKey();

   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

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
Weitere Erweiterungen