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

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();
    }
}

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();
    }
}

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

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.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.1. Output PDF File