Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Unterstützung
  4. C# Struct vs. Class – Ein Vergleich
.NET HILFE

C# Struct vs Class (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

In C# dienen sowohl Strukturen als auch Klassen als grundlegende Bausteine zum Organisieren und Speichern von Daten, weisen jedoch unterschiedliche Eigenschaften auf, die sie für verschiedene Szenarien geeignet machen. Das Verständnis der Unterschiede zwischen C#-Strukturen und Klassen ist entscheidend, um fundierte Entscheidungen bei der Gestaltung Ihrer C#-Anwendungen zu treffen.

In diesem Artikel werden wir die wesentlichen Unterschiede zwischen Strukturen und Klassen untersuchen und ihre Anwendungsfälle, Speicherverwaltung und Leistungsauswirkungen diskutieren. Außerdem werden wir besprechen, wie man Strukturen und Klassen mit IronPDF für 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 im Heap befindet, was bedeutet, dass beim Erstellen einer Instanz einer Klasse ein Verweis auf das Objekt im Speicher gespeichert wird.

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

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

Vererbung: Klassen unterstützen die Vererbung, sodass abgeleitete Klassen mit gemeinsamen Merkmalen erstellt werden können.

using System;

// Define a class
public class MyClass
{
    // Fields (data members)
    public int MyField;

    // Constructor
    public MyClass(int value)
    {
        MyField = value;
    }

    // Method to display the value
    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 to display the value
    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 to display the value
	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
$vbLabelText   $csharpLabel

C# Struct vs Class (How It Works For Developers): Abbildung 1 - Ausgabe in der Konsole aus dem vorherigen Code

1.2. Strukturen (Werttypen)

Wertetypen: Strukturen sind Wertetypen, was bedeutet, dass die eigentlichen Daten dort gespeichert werden, wo die Variable deklariert ist, und nicht an einem separaten Ort im Speicher wie primitive Typen. Dies bedeutet auch, dass der Struktur kein Nullwert als Wertetyp ohne den Nullable<>-Tag zugewiesen werden kann.

Stack-Speicherzuweisung: Strukturinstanzen werden im Stack Speicher zugewiesen, was zu schnellerer Zuweisung und Freigabe führt, jedoch mit Einschränkungen bei Größe und Umfang.

Kein Standardkonstruktor: Strukturen haben keinen Standardkonstruktor, es sei denn, einer wird explizit definiert. Jedes Feld muss während 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 to display the value
    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 to display the value
    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 to display the value
	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
$vbLabelText   $csharpLabel

C# Struct vs Class (How It Works For Developers): Abbildung 2 - Ausgabe in der Konsole aus dem vorherigen Code

2: Anwendungsfälle und Richtlinien

2.1. Wann man Klassen verwenden sollte

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 möchten und möchten, dass Änderungen in verschiedenen Teilen Ihres Codes widergespiegelt werden, sind Klassen die geeignete Wahl.

2.2. Wann man Strukturen verwenden sollte

Einfache Datenstrukturen: Strukturen sind ideal für einfachere Datenstrukturen, die leichtgewichtige Entitäten wie kleine Datenstrukturen darstellen, wie Punkte, Rechtecke, Schlüssel-Wert-Paare oder wenn die Struktur logisch einen einzigen Wert repräsentiert, ähnlich wie primitive Typen.

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

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

3 Unterschiede in der Speicherzuweisung

3.1. Klassen

Referenzzählung: Der Speicher für Instanzen von Klassen wird durch Referenzzählung des Garbage Collectors verwaltet. Objekte sind für die Garbage Collection geeignet, wenn keine Verweise mehr auf sie existieren.

Potenzial für Speicherlecks: Unzureichende Handhabung von Verweisen 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 verlassen sich nicht auf die Garbage Collection, da sie Wertetypen sind und anders verwaltet werden. Sie werden automatisch freigegeben, wenn sie aus dem Gültigkeitsbereich herausfallen.

Begrenzter Speicher-Overhead: Strukturen haben im Vergleich zu Klassen einen geringeren Speicher-Overhead, was sie effizient macht für Szenarien, in denen der Speicherverbrauch ein Thema ist.

4. leistungsbezogene Überlegungen

Klassen

Indirekter Zugriff: Da auf Instanzen von Klassen über Referenzen zugegriffen wird, gibt es eine zusätzliche Ebene der Indirektion, die einen geringen Leistungs-Overhead verursachen kann.

Heap-Speicherzuweisung: Die dynamische Zuweisung von Speicher im Heap kann zu längeren Erstellungs- und Zerstörungszeiten von Objekten führen.

Strukturen

Direkter Zugriff: Auf Strukturen wird direkt zugegriffen, wodurch die Notwendigkeit für eine zusätzliche Ebene der Indirektion entfällt. Dies kann zu einer besseren Leistung bei kleinen, häufig verwendeten Objekten führen.

Stack-Speicherzuweisung: Die Stapelspeicherzuweisung bietet schnellere Erstellung und Zerstörung von Strukturinstanzen.

5. Einführung in IronPDF

IronPDF-Übersicht: Robuste C#-Bibliothek für die PDF-Manipulation ist für nahtlose PDF-Erzeugung, -Manipulation und -Rendering innerhalb von .NET-Anwendungen konzipiert. Mit IronPDF können Entwickler mühelos PDF-Dokumente erstellen, bearbeiten und interagieren, was es zu einem unverzichtbaren Werkzeug für Aufgaben macht, die vom dynamischen Erzeugen von PDFs aus HTML-Inhalten bis hin zum Extrahieren von Daten aus vorhandenen Dokumenten reichen. Diese vielseitige Bibliothek vereinfacht PDF-bezogene Funktionen und bietet eine umfassende Reihe von Funktionen für Entwickler, die an Webanwendungen, Desktop-Software oder jedem .NET-Projekt arbeiten, das ein effizientes PDF-Handling erfordert.

5.1. Installieren von IronPDF

Bevor Sie in die Codebeispiele eintauchen, müssen Sie IronPDF installieren. Sie können dies mit der NuGet-Paket-Manager-Konsole tun oder indem Sie einen Verweis auf die IronPDF-Bibliothek in Ihr Projekt hinzufügen. Die folgenden Schritte skizzieren den Installationsprozess:

  1. NuGet-Paket-Manager-Konsole:

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

Sobald IronPDF installiert ist, sind Sie bereit, dessen Fähigkeiten für den Umgang mit PDF-Dateien in Ihren C#-Anwendungen zu nutzen.

5.2. Verwendung von Struct und Class mit IronPDF

using IronPdf;
using System;

// Sample class representing a person with Name and Age properties
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Sample struct representing a point in a 2D coordinate system with X and Y properties
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

class Program
{
    static void Main()
    {
        // Creating instances of the 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 using IronPDF
        var renderer = new ChromePdfRenderer();

        // Construct HTML content using 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 representing a person with Name and Age properties
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Sample struct representing a point in a 2D coordinate system with X and Y properties
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

class Program
{
    static void Main()
    {
        // Creating instances of the 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 using IronPDF
        var renderer = new ChromePdfRenderer();

        // Construct HTML content using 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 representing a person with Name and Age properties
Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

' Sample struct representing a point in a 2D coordinate system with X and Y properties
Friend Structure Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Structure

Friend Class Program
	Shared Sub Main()
		' Creating instances of the 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 using IronPDF
		Dim renderer = New ChromePdfRenderer()

		' Construct HTML content using 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
$vbLabelText   $csharpLabel
  • 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. Ausgabe der PDF-Datei

C# Struct vs Class (How It Works For Developers): Abbildung 3 - Das ausgegebene PDF-Dokument aus dem vorherigen Code

6. Fazit

Zusammenfassend hängt die Entscheidung zwischen der Verwendung von C#-Strukturen und Klassen von den spezifischen Anforderungen und Merkmalen Ihrer Anwendung ab. Klassen, die Referenztypen sind, eignen sich zur Modellierung komplexer Entitäten mit Zustand und Verhalten, unterstützen die Vererbung und erleichtern gemeinschaftlich genutzte Instanzen. Andererseits sind Strukturen, als Wertetypen, ideal für leichtgewichtige Datenstrukturen mit Wertesemantik und bieten Leistungsverbesserungen hinsichtlich Stapelspeicherzuweisung und direktem Zugriff.

IronPDF bietet eine Kostenlose Testlizenz zur Bewertung für Benutzer, die eine gute Gelegenheit ist, die Funktionen und die Funktionalität 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 unter IronPDF PDF-Erstellungstutorial verfügbar.

Häufig gestellte Fragen

Was ist der Unterschied zwischen Strukturen und Klassen in C#?

Strukturen sind Werttypen, die auf dem Stack gespeichert werden, ideal für leichte Datenstrukturen mit Leistungsverbesserungen aufgrund des direkten Zugriffs. Klassen sind Referenztypen, die auf dem Heap gespeichert werden und Vererbung unterstützen, was sie für komplexe Datenstrukturen geeignet macht.

Wie kann ich zwischen der Verwendung einer Struktur oder einer Klasse in C# wählen?

Wählen Sie Strukturen für einfache, häufig verwendete Datenstrukturen, bei denen Leistung entscheidend ist. Entscheiden Sie sich für Klassen, wenn Sie mit komplexen Datenstrukturen arbeiten, die Vererbung oder gemeinsame Instanzen erfordern.

Was sind die Leistungsimplikationen der Verwendung von Strukturen in C#?

Strukturen bieten Leistungsverbesserungen, da sie auf dem Stack zugewiesen werden, was zu einer schnelleren Zuweisung und Freigabe im Vergleich zu Heap-zugewiesenen Klassen führt. Dies macht sie geeignet für leistungsrelevante Anwendungen.

Wie werden Strukturen und Klassen mit einer PDF-Bibliothek in C# integriert?

Mit einer PDF-Bibliothek wie IronPDF können Sie Klassen für komplexe Daten und Strukturen für einfache Daten definieren und sie dann verwenden, um PDF-Dokumente effizient innerhalb von .NET-Anwendungen zu erstellen und zu bearbeiten.

Was sind die Unterschiede im Speicher-Management zwischen Strukturen und Klassen?

Strukturen werden auf dem Stack zugewiesen, was zu einer schnelleren Speicherverwaltung führt, während Klassen auf dem Heap zugewiesen werden und vom Garbage Collector verwaltet werden, was zu einem Overhead führen kann.

Können C#-Strukturen nullbar sein?

Standardmäßig können Strukturen nicht null sein, da sie Werttypen sind. Sie können jedoch mithilfe des Nullable<>-Konstrukt nullbar gemacht werden, sodass sie null Werte zugewiesen werden können.

Was ist eine zuverlässige Bibliothek für die PDF-Generierung in C#?

IronPDF ist eine robuste Bibliothek für die PDF-Generierung, die es Entwicklern ermöglicht, PDF-Dokumente effizient in .NET-Anwendungen zu erstellen, zu modifizieren und darzustellen. Sie vereinfacht komplexe PDF-Funktionalitäten.

Wie kann ich eine PDF-Manipulationsbibliothek in einem C#-Projekt installieren?

IronPDF kann über die NuGet-Paketmanager-Konsole mit dem Befehl Install-Package IronPdf oder über die Paketmanager-Benutzeroberfläche durch Suchen und Installieren der neuesten Version installiert werden.

Was ist der empfohlene Anwendungsfall für Strukturen in C#-Anwendungen?

Strukturen werden für einfache, leichte Datenstrukturen empfohlen, die häufig verwendet werden und eine effiziente Speicherzuweisung erfordern, was sie ideal für leistungsrelevante Anwendungen macht.

Gibt es eine Testversion für C#-PDF-Bibliotheken?

Ja, IronPDF bietet eine kostenlose Testlizenz an, die es Entwicklern ermöglicht, die Funktionen und Funktionalitäten zu evaluieren. Weitere Informationen finden Sie in der IronPDF-Dokumentation und in den Tutorials.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen