.NET HILFE

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

Aktualisiert:Juni 22, 2025

In C#, both structs and classes serve as fundamental building blocks for organizing and storing data, but they have distinct characteristics that make them suitable for different scenarios. Understanding the differences between C# structs and classes is crucial for making informed decisions when designing your C# applications.

In this article, we'll explore the key distinctions between structs and classes, discussing their use cases, memory management, and performance implications. Also, we will discuss how to use structs and classes with IronPDF for C# for PDF file creation.

1. Overview of Structs and Classes

1.1. Classes (Reference Types)

Reference Types: A Class in C# is a reference type residing on the heap, meaning that when an instance of a class is created, a reference to the object is stored in memory.

Heap Allocation: Class instances are allocated memory on the heap memory allocation, providing flexibility in size and allowing objects to be shared among different parts of the code.

Default Constructor: Classes can have a default constructor, which is automatically provided if none is explicitly defined.

Inheritance: Classes support inheritance, allowing the creation of derived classes with shared characteristics.

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): Figure 1 - Output in the console from the previous code

1.2. Structs (Value Types)

Value Types: Structs are value types, which means that the actual data is stored where the variable is declared, rather than in a separate location in memory like primitive types. This also means that the struct cannot be assigned a null value as its value type without it being made a nullable type with the Nullable<> tag.

Stack Allocation: Struct instances are allocated memory on the stack, leading to faster allocation and deallocation but with limitations on size and scope.

No Default Constructor: Structs do not have a default constructor unless one is explicitly defined. Every field must be initialized during instantiation.

No Inheritance: Structs do not support inheritance. They are primarily used for lightweight data structures.

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): Figure 2 - Output in the console from the previous code

2. Use Cases and Guidelines

2.1. When to Use Classes

Complex State and Behavior: Use classes when you need to model complex data structures with state and behavior. Classes are suitable for representing complex objects with multiple properties and methods.

Reference Semantics: If you want to share instances of objects and have changes reflected across different parts of your code, classes are the appropriate choice.

2.2. When to Use Structs

Simple Data Structures: Structs are ideal for simpler data structures that represent lightweight entities like small data structures, such as points, rectangles, key-value pairs, or if the struct logically represents a single value, similar to primitive types.

Value Semantics: When you prefer value semantics and want to avoid the overhead of heap allocation, structs are a good fit.

Performance Considerations: In scenarios where performance is critical, especially for small, frequently used objects, structs can be more efficient due to stack allocation.

3. Memory Allocation Differences

3.1. Classes

Reference Counting: Memory for class instances is managed through reference counting by the garbage collector. Objects are eligible for garbage collection when there are no more references to them.

Potential for Memory Leaks: Improper handling of references may lead to memory leaks if objects are not properly disposed of when no longer needed.

3.2. Structs

No Garbage Collection: Structs do not rely on garbage collection since they are value types and are managed differently. They are automatically deallocated when they go out of scope.

Limited Memory Overhead: Structs have lower memory overhead compared to classes, making them efficient for scenarios where memory usage is a concern.

4. Performance Considerations

Classes

Indirect Access: Since class instances are accessed through references, there is an additional level of indirection, which may introduce a slight performance overhead.

Heap Allocation: The dynamic allocation of memory on the heap can lead to longer object creation and destruction times.

Structs

Direct Access: Structs are accessed directly, eliminating the need for an extra level of indirection. This can result in better performance for small, frequently used objects.

Stack Allocation: The stack allocation of memory provides faster creation and destruction of struct instances.

5. Introducing IronPDF

IronPDF Overview: Robust C# Library for PDF Manipulation is designed for seamless PDF generation, manipulation, and rendering within .NET applications. With IronPDF, developers can effortlessly create, modify, and interact with PDF documents, making it an essential tool for tasks ranging from dynamically generating PDFs from HTML content to extracting data from existing documents. This versatile library simplifies PDF-related functionalities, providing a comprehensive set of features for developers working on web applications, desktop software, or any .NET project requiring efficient PDF handling.

5.1. Installing IronPDF

Before diving into the code examples, you need to install IronPDF. You can do this using the NuGet Package Manager Console or by adding a reference to the IronPDF library in your project. The following steps outline the installation process:

NuGet Package Manager Console:
```
Install-Package IronPdf
```
Package Manager UI: Search for "IronPDF" in the NuGet Package Manager UI and install the latest version.

Once IronPDF is installed, you're ready to leverage its capabilities for PDF file handling in your C# applications.

5.2. Using Struct and Class with 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 is a sample class representing a person with Name and Age properties.
Point is a sample struct representing a point in a 2D coordinate system with X and Y properties.
Instances of the Person class and Point struct are created.
The HTML content is then rendered into the PDF document, which is saved as "InformationDocument.pdf."

5.2.1. Output PDF File

C# Struct vs Class (How It Works For Developers): Figure 3 - The outputted PDF file from the previous code

6. Conclusion

In conclusion, the choice between using C# structs and classes depends on the specific requirements and characteristics of your application. Classes, being reference types, are suitable for modeling complex entities with state and behavior, supporting inheritance, and facilitating shared instances. On the other hand, structs, as value types, are ideal for lightweight data structures with value semantics, offering performance advantages in terms of stack allocation and direct access.

IronPDF offers a Free Trial License for Evaluation for users, which is a good opportunity to get to know the IronPDF features and functionality. To learn more about IronPDF visit the Comprehensive IronPDF Documentation and a detailed tutorial for creating PDF files using IronPDF is available at the IronPDF PDF Generation Tutorial.

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.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

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

1. Overview of Structs and Classes

1.1. Classes (Reference Types)

1.2. Structs (Value Types)

2. Use Cases and Guidelines

2.1. When to Use Classes

2.2. When to Use Structs

3. Memory Allocation Differences

3.1. Classes

3.2. Structs

4. Performance Considerations

Classes

Structs

5. Introducing IronPDF

5.1. Installing IronPDF

5.2. Using Struct and Class with IronPDF

5.2.1. Output PDF File

6. Conclusion

Häufig gestellte Fragen

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

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

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

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

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

Können C#-Strukturen nullbar sein?

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

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

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

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

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

1. Overview of Structs and Classes

1.1. Classes (Reference Types)

1.2. Structs (Value Types)

2. Use Cases and Guidelines

2.1. When to Use Classes

2.2. When to Use Structs

3. Memory Allocation Differences

3.1. Classes

3.2. Structs

4. Performance Considerations

Classes

Structs

5. Introducing IronPDF

5.1. Installing IronPDF

5.2. Using Struct and Class with IronPDF

5.2.1. Output PDF File

6. Conclusion

Häufig gestellte Fragen

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

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

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

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

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

Können C#-Strukturen nullbar sein?

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

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

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

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

Verwandte Artikel

RandomNumberGenerator C#

C# String Equals (Wie es für Entwickler funktioniert)

C# Switch-Fallmuster (Wie es für Entwickler funktioniert)

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Trusted by Over 2 Million Engineers Worldwide