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. Verstehen der Unterschiede zwischen C#-Strukturen und -Klassen ist wichtig, um beim Entwurf Ihrer C#-Anwendungen fundierte Entscheidungen treffen zu können.

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 für die Erstellung von PDF-Dateien.

1. Überblick über Strukturen und Klassen

1.1. Klassen (Referenztypen)

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

Heap-Zuweisung: Klasseninstanzen wird Speicher auf dem Heap-Speicher zugewiesen, was Flexibilität bei der Größe bietet und die gemeinsame Nutzung von Objekten durch verschiedene Teile des Codes ermöglicht.

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

Vererbung: Klassen unterstützen Vererbung und ermöglichen die Erstellung abgeleiteter Klassen mit gemeinsamen Merkmalen.

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 ist, und nicht an einer separaten Stelle im Speicher wie bei primitiven Typen. Dies bedeutet auch, dass der Struktur kein Nullwert als Werttyp zugewiesen werden kann, ohne dass sie mit dem Tag Nullable<> zu einem nullbaren Typ gemacht wird.

Stack Allocation: Strukturelle Instanzen erhalten Speicher auf dem Stack zugewiesen, was zu einer schnelleren Zuweisung und Freigabe führt, jedoch mit Einschränkungen bei Größe und Umfang.

Kein Standard-Konstruktor: Strukturen haben keinen Standard-Konstruktor, es sei denn, einer ist ausdrücklich definiert. Jedes Feld muss bei der Instanziierung initialisiert werden.

Keine Vererbung: Structs 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?

Komplexe Zustände und Verhalten: Verwenden Sie Klassen, wenn Sie komplexe Datenstrukturen mit Zuständen und Verhalten modellieren müssen. Klassen eignen sich zur Darstellung komplexer Objekte mit mehreren Eigenschaften und Methoden.

Referenzsemantik: Wenn Sie Instanzen von Objekten gemeinsam nutzen und Änderungen in verschiedenen Teilen Ihres Codes widergespiegelt haben möchten, sind Klassen die richtige Wahl.

2.2. Wann werden Strukturen verwendet?

Einfache Datenstrukturen: Strukturen sind ideal für einfachere Datenstrukturen, die leichtgewichtige Entitäten wie kleine Datenstrukturen darstellen, z. B. Punkte, Rechtecke, Schlüssel-Wert-Paare, oder wenn die Struktur logisch einen einzelnen Wert darstellt, ähnlich wie bei primitiven Typen.

Wert-Semantik: Wenn Sie die Wert-Semantik bevorzugen und den Overhead der Heap-Allokation vermeiden wollen, sind Structs eine gute Wahl.

Leistungserwägungen: In Szenarien, in denen die Leistung kritisch ist, insbesondere für kleine, häufig verwendete Objekte, können Structs aufgrund der Stack-Zuweisung 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 Referenzen kann zu Speicherlecks führen, wenn Objekte nicht ordnungsgemäß entsorgt werden, wenn sie nicht mehr benötigt werden.

3.2. Strukturen

Keine Garbage Collection: Strukturen sind nicht auf die Garbage Collection angewiesen, da sie Werttypen sind und anders verwaltet werden. Sie werden automatisch freigegeben, wenn sie den Anwendungsbereich verlassen.

Begrenzter Speicher-Overhead: Strukturen haben im Vergleich zu Klassen einen geringeren Speicher-Overhead, was sie für Szenarien effizient macht, in denen die Speichernutzung ein Problem darstellt.

4. Überlegungen zur Leistung

Klassen

Direkter Zugriff: Da auf Klasseninstanzen über Referenzen zugegriffen wird, gibt es eine zusätzliche Ebene der Indirektion, die zu einem leichten Leistungs-Overhead fü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

Direktzugriff: Auf Strukturen wird direkt zugegriffen, so dass eine zusätzliche Umleitungsebene überflüssig ist. Dies kann zu einer besseren Leistung bei kleinen, häufig verwendeten Objekten führen.

Stack-Allokation: Die Stack-Allokation von Speicher ermöglicht eine schnellere Erstellung und Zerstörung von struct-Instanzen.

5. Einführung in IronPDF

IronPDF ist eine robuste C#-Bibliothek für die nahtlose PDF-Erzeugung, -Bearbeitung und -Rendering in .NET-Anwendungen. 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 Package Manager Konsole:

    :ProductInstall

2. Package Manager UI: Suchen Sie in der NuGet Package Manager UI nach "IronPDF" 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.
• Es werden Instanzen der Klassen Person und Point struct 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 für Benutzer, was eine gute Gelegenheit ist, die Eigenschaften und Funktionen von IronPDF kennenzulernen. Um mehr über IronPDF zu erfahren, besuchen Sie die folgende Website Link und eine ausführliche Anleitung zur Erstellung von PDF-Dateien mit IronPDF finden Sie unter folgender Adresse Link.