C# Struct vs Class (Wie es für Entwickler funktioniert)

In C# dienen sowohl Structs als auch Klassen als grundlegende Bausteine für die Organisation und Speicherung von Daten, aber sie haben unterschiedliche Eigenschaften, die sie für verschiedene Szenarien geeignet machen. Das Verständnis der Unterschiede zwischen C#-Structs und -Klassen ist entscheidend, um fundierte Entscheidungen bei der Gestaltung Ihrer C#-Anwendungen zu treffen.

In diesem Artikel werden wir die wichtigsten Unterschiede zwischen Strukturen und Klassen untersuchen und ihre Anwendungsfälle, Speicherverwaltung und Leistungsauswirkungen erörtern. Außerdem werden wir besprechen, wie man Strukturen und Klassen mit IronPDF for C# zur Erstellung von PDF-Dateien verwendet.

1. Überblick über Strukturen und Klassen

1.1. Klassen (Referenztypen)

Referenztypen: Eine Klasse in C# ist ein Referenztyp, der sich auf dem Heap befindet. Das bedeutet, dass, wenn eine Instanz einer Klasse erstellt wird, ein Verweis auf das Objekt im Speicher gespeichert wird.

Heap-Zuweisung: Klasseninstanzen werden im Heap-Speicher zugewiesen, was Flexibilität in der Größe bietet und es ermöglicht, Objekte zwischen verschiedenen Teilen des Codes zu teilen.

Standardkonstruktor: Klassen können einen Standardkonstruktor haben, der automatisch bereitgestellt wird, wenn keiner explizit definiert ist.

Vererbung: Klassen unterstützen die Vererbung, was die Erstellung abgeleiteter Klassen mit gemeinsamen Merkmalen ermöglicht.

using System;
// Define a class
public class MyClass
{
    // Fields (data members)
    public int MyField;
    // Constructor
    public MyClass(int value)
    {
        MyField = value;
    }
    // Method
    public void Display()
    {
        Console.WriteLine($"Value in MyClass: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        // Create an instance of the class
        MyClass myClassInstance = new MyClass(10);
        // Access field and call method
        myClassInstance.Display();
        // Classes are reference types, so myClassInstance refers to the same object in memory
        MyClass anotherInstance = myClassInstance;
        anotherInstance.MyField = 20;
        // Both instances refer to the same object, so the change is reflected in both
        myClassInstance.Display();
        anotherInstance.Display();
    }
}

using System;
// Define a class
public class MyClass
{
    // Fields (data members)
    public int MyField;
    // Constructor
    public MyClass(int value)
    {
        MyField = value;
    }
    // Method
    public void Display()
    {
        Console.WriteLine($"Value in MyClass: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        // Create an instance of the class
        MyClass myClassInstance = new MyClass(10);
        // Access field and call method
        myClassInstance.Display();
        // Classes are reference types, so myClassInstance refers to the same object in memory
        MyClass anotherInstance = myClassInstance;
        anotherInstance.MyField = 20;
        // Both instances refer to the same object, so the change is reflected in both
        myClassInstance.Display();
        anotherInstance.Display();
    }
}

Imports System
' Define a class
Public Class [MyClass]
	' Fields (data members)
	Public MyField As Integer
	' Constructor
	Public Sub New(ByVal value As Integer)
		MyField = value
	End Sub
	' Method
	Public Sub Display()
		Console.WriteLine($"Value in MyClass: {MyField}")
	End Sub
End Class
Friend Class Program
	Shared Sub Main()
		' Create an instance of the class
		Dim myClassInstance As [MyClass] = New [MyClass](10)
		' Access field and call method
		myClassInstance.Display()
		' Classes are reference types, so myClassInstance refers to the same object in memory
		Dim anotherInstance As [MyClass] = myClassInstance
		anotherInstance.MyField = 20
		' Both instances refer to the same object, so the change is reflected in both
		myClassInstance.Display()
		anotherInstance.Display()
	End Sub
End Class

1.2. Strukturen (Werttypen)

Werttypen: Strukturen sind Werttypen, was bedeutet, dass die tatsächlichen Daten dort gespeichert werden, wo die Variable deklariert wird, anstatt in einem separaten Speicherort wie primitive Typen. Das bedeutet auch, dass der Struktur kein Nullwert als ihr Werttyp zugewiesen werden kann, ohne dass er mit dem Nullable<>-Tag als nullable Typ festgelegt wird.

Stapelzuweisung: Strukturinstanzen werden im Speicher auf dem Stapel zugewiesen, was zu einer schnelleren Zuweisung und Freigabe führt, jedoch mit Einschränkungen bei Größe und Umfang.

Kein Standardkonstruktor: Strukturen haben keinen Standardkonstruktor, es sei denn, es ist explizit einer definiert. Jedes Feld muss bei der Instanziierung initialisiert werden.

Keine Vererbung: Strukturen unterstützen keine Vererbung. Sie werden hauptsächlich für leichtgewichtige Datenstrukturen verwendet.

using System;
// Define a struct
public struct MyStruct
{
    // Fields (data members)
    public int MyField;
    // Constructor
    public MyStruct(int value)
    {
        MyField = value;
    }
    // Method
    public void Display()
    {
        Console.WriteLine($"Value in MyStruct: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        // Create an instance of the struct
        MyStruct myStructInstance = new MyStruct(10);
        // Access field and call method
        myStructInstance.Display();
        // Structs are value types, so myStructInstance is a copy
        MyStruct anotherInstance = myStructInstance;
        anotherInstance.MyField = 20;
        // Changes to anotherInstance do not affect myStructInstance
        myStructInstance.Display();
        anotherInstance.Display();
    }
}

using System;
// Define a struct
public struct MyStruct
{
    // Fields (data members)
    public int MyField;
    // Constructor
    public MyStruct(int value)
    {
        MyField = value;
    }
    // Method
    public void Display()
    {
        Console.WriteLine($"Value in MyStruct: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        // Create an instance of the struct
        MyStruct myStructInstance = new MyStruct(10);
        // Access field and call method
        myStructInstance.Display();
        // Structs are value types, so myStructInstance is a copy
        MyStruct anotherInstance = myStructInstance;
        anotherInstance.MyField = 20;
        // Changes to anotherInstance do not affect myStructInstance
        myStructInstance.Display();
        anotherInstance.Display();
    }
}

Imports System
' Define a struct
Public Structure MyStruct
	' Fields (data members)
	Public MyField As Integer
	' Constructor
	Public Sub New(ByVal value As Integer)
		MyField = value
	End Sub
	' Method
	Public Sub Display()
		Console.WriteLine($"Value in MyStruct: {MyField}")
	End Sub
End Structure
Friend Class Program
	Shared Sub Main()
		' Create an instance of the struct
		Dim myStructInstance As New MyStruct(10)
		' Access field and call method
		myStructInstance.Display()
		' Structs are value types, so myStructInstance is a copy
		Dim anotherInstance As MyStruct = myStructInstance
		anotherInstance.MyField = 20
		' Changes to anotherInstance do not affect myStructInstance
		myStructInstance.Display()
		anotherInstance.Display()
	End Sub
End Class

2. Anwendungsfälle und Leitlinien

2.1. Wann werden Klassen verwendet?

Komplexer Zustand und Verhalten: Verwenden Sie Klassen, wenn Sie komplexe Datenstrukturen mit Zustand und Verhalten modellieren müssen. Klassen eignen sich zur Darstellung komplexer Objekte mit mehreren Eigenschaften und Methoden.

Referenzsemantik: Wenn Sie Instanzen von Objekten teilen und Änderungen in verschiedenen Teilen Ihres Codes widerspiegeln möchten, sind Klassen die geeignete Wahl.

2.2. Wann werden Strukturen verwendet?

Einfacher Datenstrukturen: Strukturen sind ideal für einfachere Datenstrukturen, die leichtgewichtige Entitäten wie kleine Datenstrukturen repräsentieren, z.B. Punkte, Rechtecke, Schlüssel-Wert-Paare, oder wenn die Struktur logisch einen einzelnen Wert darstellt, ähnlich wie primitive Datentypen.

Wertsemantik: Wenn Sie Wertsemantik bevorzugen und den Overhead der Heap-Allocation vermeiden möchten, sind Strukturen eine gute Wahl.

Leistungsüberlegungen: In Szenarien, in denen die Leistung kritisch ist, insbesondere bei kleinen, häufig verwendeten Objekten, können Strukturen aufgrund der Stapelspeicherung effizienter sein.

3. Unterschiede bei der Speicherzuweisung

3.1. Klassen

Referenzzählung: Der Speicher für Klasseninstanzen wird durch Referenzzählung vom Garbage Collector verwaltet. Objekte kommen für die Garbage Collection in Frage, wenn es keine Verweise mehr auf sie gibt.

Potenzial für Speicherlecks: Unsachgemäße Handhabung von Verweisen kann zu Speicherlecks führen, wenn Objekte nicht ordnungsgemäß freigegeben werden, wenn sie nicht mehr benötigt werden.

3.2. Strukturen

Keine Garbage Collection: Strukturen (Structs) sind Werttypen und erfordern keine Garbage Collection, da sie anders verwaltet werden. Sie werden automatisch freigegeben, wenn sie den Anwendungsbereich verlassen.

Begrenzter Speicherbedarf: Structs haben einen geringeren Speicherbedarf im Vergleich zu Klassen, was sie effizient für Szenarien macht, bei denen der Speicherverbrauch eine Rolle spielt.

4. Überlegungen zur Leistung

Klassen

Indirekter Zugriff: Da Klasseninstanzen über Referenzen zugegriffen werden, gibt es eine zusätzliche Indirektionsebene, die möglicherweise einen geringfügigen Leistungsaufwand einführen kann.

Heap-Zuweisung: Die dynamische Zuweisung von Speicher auf dem Heap kann zu längeren Zeiten für die Erstellung und Zerstörung von Objekten führen.

Strukturen

Direkter Zugriff: Strukturen werden direkt angesprochen, wodurch eine zusätzliche Ebene der Indirektion vermieden wird. Dies kann zu einer besseren Leistung bei kleinen, häufig verwendeten Objekten führen.

Stapelzuweisung: Die Stapelzuweisung von Speicher ermöglicht eine schnellere Erstellung und Zerstörung von Strukturinstanzen.

5. Einführung in IronPDF

IronPDF Übersicht: Robuste C#-Bibliothek für die PDF-Bearbeitung ist für nahtlose PDF-Erstellung, -Manipulation und -Renderung innerhalb von .NET-Anwendungen konzipiert. Mit IronPDF können Entwickler mühelos PDF-Dokumente erstellen, ändern und mit ihnen interagieren. Dies macht es zu einem unverzichtbaren Werkzeug für Aufgaben, die von der dynamischen Generierung von PDFs aus HTML-Inhalten bis zur Extraktion von Daten aus vorhandenen Dokumenten reichen. Diese vielseitige Bibliothek vereinfacht PDF-bezogene Funktionalitäten und bietet einen umfassenden Satz von Funktionen für Entwickler, die an Webanwendungen, Desktop-Software oder einem beliebigen .NET-Projekt arbeiten, das eine effiziente PDF-Verarbeitung erfordert.

5.1. Installation von IronPDF

Bevor Sie sich mit den Codebeispielen beschäftigen, müssen Sie IronPDF installieren. Sie können dies über die NuGet Package Manager Console tun oder einen Verweis auf die IronPDF-Bibliothek in Ihr Projekt einfügen. Die folgenden Schritte beschreiben den Installationsvorgang:

1. NuGet-Paket-Manager-Konsole:

    :ProductInstall

    :ProductInstall

2. Package-Manager-UI: Suchen Sie nach "IronPDF" in der NuGet Package Manager UI und installieren Sie die neueste Version.

   Sobald IronPDF installiert ist, können Sie seine Funktionen für die Handhabung von PDF-Dateien in Ihren C#-Anwendungen nutzen.

5.2. Verwendung von Struct und Class mit IronPDF

using IronPdf;
using System;
// Sample class
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
// Sample struct
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}
class Program
{
    static void Main()
    {
        // Sample instances of class and struct
        Person person = new Person { Name = "John Doe", Age = 30 };
        Point point = new Point { X = 10, Y = 20 };
        // Create a new PDF document
        var renderer = new ChromePdfRenderer();
        // Add content with information from class and struct
        string content = $@"<!DOCTYPE html>
                            <html>
                            <body>
                                <h1>Information in IronPDF</h1>
                                <p>Name: {person.Name}</p>
                                <p>Age: {person.Age}</p>
                                <p>Point X: {point.X}</p>
                                <p>Point Y: {point.Y}</p>
                            </body>
                            </html>";
        // Render HTML content to PDF
        var pdf = renderer.RenderHtmlAsPdf(content);
        // Save the PDF to a file
        pdf.SaveAs("InformationDocument.pdf");
    }
}

using IronPdf;
using System;
// Sample class
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
// Sample struct
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}
class Program
{
    static void Main()
    {
        // Sample instances of class and struct
        Person person = new Person { Name = "John Doe", Age = 30 };
        Point point = new Point { X = 10, Y = 20 };
        // Create a new PDF document
        var renderer = new ChromePdfRenderer();
        // Add content with information from class and struct
        string content = $@"<!DOCTYPE html>
                            <html>
                            <body>
                                <h1>Information in IronPDF</h1>
                                <p>Name: {person.Name}</p>
                                <p>Age: {person.Age}</p>
                                <p>Point X: {point.X}</p>
                                <p>Point Y: {point.Y}</p>
                            </body>
                            </html>";
        // Render HTML content to PDF
        var pdf = renderer.RenderHtmlAsPdf(content);
        // Save the PDF to a file
        pdf.SaveAs("InformationDocument.pdf");
    }
}

Imports IronPdf
Imports System
' Sample class
Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class
' Sample struct
Friend Structure Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Structure
Friend Class Program
	Shared Sub Main()
		' Sample instances of class and struct
		Dim person As New Person With {
			.Name = "John Doe",
			.Age = 30
		}
		Dim point As New Point With {
			.X = 10,
			.Y = 20
		}
		' Create a new PDF document
		Dim renderer = New ChromePdfRenderer()
		' Add content with information from class and struct
		Dim content As String = $"<!DOCTYPE html>
                            <html>
                            <body>
                                <h1>Information in IronPDF</h1>
                                <p>Name: {person.Name}</p>
                                <p>Age: {person.Age}</p>
                                <p>Point X: {point.X}</p>
                                <p>Point Y: {point.Y}</p>
                            </body>
                            </html>"
		' Render HTML content to PDF
		Dim pdf = renderer.RenderHtmlAsPdf(content)
		' Save the PDF to a file
		pdf.SaveAs("InformationDocument.pdf")
	End Sub
End Class

• Person ist eine Beispielklasse, die eine Person mit den Eigenschaften Name und Alter darstellt.
• Point ist eine Beispielstruktur, die einen Punkt in einem 2D-Koordinatensystem mit den Eigenschaften X und Y darstellt.
• Instanzen der Person-Klasse und der Point-Struktur werden erstellt.
• Der HTML-Inhalt wird dann in das PDF-Dokument gerendert, das als "InformationDocument.pdf" gespeichert wird

5.2.1. PDF-Datei ausgeben

6. Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Entscheidung zwischen der Verwendung von C#-Strukturen und -Klassen von den spezifischen Anforderungen und Eigenschaften Ihrer Anwendung abhängt. Klassen sind Referenztypen und eignen sich für die Modellierung komplexer Entitäten mit Zustand und Verhalten, unterstützen die Vererbung und erleichtern die gemeinsame Nutzung von Instanzen. Andererseits sind Structs als Werttypen ideal für leichtgewichtige Datenstrukturen mit Wertesemantik und bieten Leistungsvorteile bei der Stackzuweisung und dem direkten Zugriff.

IronPDF bietet eine kostenlose Testlizenz zur Evaluierung für Nutzer an, was eine gute Gelegenheit ist, die Funktionen und Features von IronPDF kennenzulernen. Um mehr über IronPDF zu erfahren, besuchen Sie die umfassende IronPDF-Dokumentation und ein detailliertes Tutorial zur Erstellung von PDF-Dateien mit IronPDF ist im IronPDF-PDF-Erstellungstutorial verfügbar.