C# Struct vs Class (How It Works For Developers)

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 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
    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. 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
    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. 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 is a robust C# library 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:

1. NuGet Package Manager Console:

   Install-Package IronPdf

2. 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
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 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

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 users, which is a good opportunity to get to know the IronPDF features and functionality. To learn more about IronPDF visit the following link and a detailed tutorial for creating PDF files using IronPDF is available at the following link.