Struct and Class

When developing applications in C#, understanding the difference between a struct and a class is crucial. Although both are used to define custom data types, they have key differences in how they behave and how they are stored in memory. This difference is important to understand, especially when working on performance-critical applications or when deciding between value types and reference types.

Value Type vs Reference Type

The most significant difference between structs and classes is that structs are value types, while classes are reference types.

Structs: When you assign a struct to another variable, a copy of the struct is made. Each variable holds its own independent copy of the data.

struct Point
{
    public int X;
    public int Y;
}
 
Point p1 = new Point() { X = 10, Y = 20 };
Point p2 = p1;  // p2 is a copy of p1
p2.X = 30;      // Modifying p2 does not affect p1

Classes: When you assign a class to another variable, both variables refer to the same object in memory. Changes made to one reference affect all references to that object.

 class Point
 {
     public int X;
     public int Y;
 }
 
 Point p1 = new Point() { X = 10, Y = 20 };
 Point p2 = p1;  // p2 and p1 refer to the same object
 p2.X = 30;      // Modifying p2 also affects p1

Memory Allocation

Structs: Being value types, structs are typically stored on the stack, which means they are more efficient when it comes to small data structures and short-lived objects. However, structs can also be stored on the heap if they are part of a reference type (e.g., an array or a class).
Classes: Classes are stored on the heap, and a reference to the object is stored on the stack. This means that class objects are managed by the garbage collector, which can introduce overhead but also ensures memory management.

Default Constructor

Structs: A struct can be created without a constructor, and its fields are automatically initialized to their default values (e.g., 0 for numeric types, null for reference types).

    struct Point
    {
        public int X;
        public int Y;
    }
    Point p = new Point();  // X and Y are initialized to 0

Classes: Classes can have an explicit default constructor, and you can define constructors with parameters as well.

    class Point
    {
        public int X;
        public int Y;
        public Point() { X = 0; Y = 0; }  // Default constructor
    }
    Point p = new Point();  // X and Y are initialized to 0

Inheritance

Structs: Structs cannot inherit from other structs or classes, and they cannot be the base of a class. However, a struct can implement interfaces.

Classes: Classes support inheritance, meaning a class can inherit from another class and override methods. This provides a powerful way to create complex and reusable object hierarchies.

    class Shape
    {
        public virtual void Draw()
        {
            Console.WriteLine("Drawing a shape");
        }
    }
    class Circle : Shape
    {
        public override void Draw()
        {
            Console.WriteLine("Drawing a circle");
        }
    }

Nullability

Structs: Structs are value types and cannot be null. If you need a nullable value type, you can use the Nullable<T> struct or the shorthand T? syntax.
```
  int x = 10;
  // x = null; // Error: cannot assign null to a value type
 
  int? y = null;  // Valid: nullable type
```
Classes: Classes are nullable by default, meaning you can assign null to a class reference, indicating that the object is not initialized.

Performance Considerations

Structs: Structs tend to have better performance when they are small and short-lived, especially when used in arrays or passed around as method parameters. However, using large structs can have a performance hit due to copying data, especially if they are passed around frequently.
Classes: Classes, while more flexible due to inheritance, have more overhead since they are allocated on the heap and require garbage collection. This can lead to performance issues if used excessively in performance-sensitive areas.

When to Use Struct vs Class ?

Use Structs:
- For small data structures that are short-lived.
- When you need to pass data by value rather than by reference.
- When you want to avoid heap allocation and garbage collection overhead.
- When you need to define a custom value type (e.g., Point, Rectangle).
Use Classes:
- For complex data structures that require inheritance and polymorphism.
- When you need to represent entities with identity and state.
- When you need to manage object lifetimes and references.
- When you need to define a custom reference type (e.g., List, Dictionary).
- When the object is large or complex enough that copying it would be inefficient.

Conclusion

Understanding when to use a struct or a class can help optimize your application's performance and memory usage. Structs are value types that offer efficient memory management for small data types, while classes are reference types that offer more flexibility through inheritance and polymorphism

Example and Test

    // Define a struct for example
    struct PointStruct
    {
        public int X;
        public int Y;
 
        public PointStruct(int x, int y)
        {
            X = x;
            Y = y;
        }
    }
 
    // Define a class for example
    class PointClass
    {
        public int X;
        public int Y;
 
        public PointClass(int x, int y)
        {
            X = x;
            Y = y;
        }
    }
 
    static void Main()
    {
        // Create a struct and a class
        PointStruct struct1 = new PointStruct(10, 20);
        PointClass class1 = new PointClass(30, 40);
 
        // Using GCHandle to get the memory address of the struct
        GCHandle handleStruct = GCHandle.Alloc(struct1, GCHandleType.Pinned);
        IntPtr addressStruct = (IntPtr)handleStruct.AddrOfPinnedObject();
 
        // Using GCHandle to get the memory address of the class
        GCHandle handleClass = GCHandle.Alloc(class1, GCHandleType.Pinned);
        IntPtr addressClass = (IntPtr)handleClass.AddrOfPinnedObject();
 
        Console.WriteLine($"Memory address of struct1: {addressStruct}");
        Console.WriteLine($"Memory address of class1: {addressClass}");
 
        // Modify the values and observe the effects
        PointStruct struct2 = struct1; // copy of the data
        PointClass class2 = class1; // reference
 
        // Modify the variables
        struct2.X = 100;
        class2.X = 200;
 
        // Using GCHandle to get the memory address of the struct
        GCHandle handleStruct2 = GCHandle.Alloc(struct2, GCHandleType.Pinned);
        IntPtr addressStruct2 = (IntPtr)handleStruct2.AddrOfPinnedObject();
 
        // Using GCHandle to get the memory address of the class
        GCHandle handleClass2 = GCHandle.Alloc(class2, GCHandleType.Pinned);
        IntPtr addressClass2 = (IntPtr)handleClass2.AddrOfPinnedObject();
 
        Console.WriteLine($"Memory address of struct2: {addressStruct2}");
        Console.WriteLine($"Memory address of class2: {addressClass2}");
 
        Console.WriteLine("\nAfter modification:");
        Console.WriteLine($"struct1.X: {struct1.X}, struct2.X: {struct2.X}");
        Console.WriteLine($"class1.X: {class1.X}, class2.X: {class2.X}");
 
        // Reprint memory addresses after modification
        addressStruct = (IntPtr)handleStruct.AddrOfPinnedObject();
        addressClass = (IntPtr)handleClass.AddrOfPinnedObject();
 
        addressStruct2 = (IntPtr)handleStruct2.AddrOfPinnedObject();
        addressClass2 = (IntPtr)handleClass2.AddrOfPinnedObject();
 
        Console.WriteLine($"Memory address of struct1 after modification: {addressStruct}");
        Console.WriteLine($"Memory address of class1 after modification: {addressClass}");
        Console.WriteLine($"Memory address of struct2 after modification: {addressStruct2}");
        Console.WriteLine($"Memory address of class2 after modification: {addressClass2}");
 
        // Free the handles
        handleStruct.Free();
        handleClass.Free();
    }

Result

    Memory address of struct1: 2794799039528
    Memory address of class1: 2794799039504
    Memory address of struct2: 2794799097048
    Memory address of class2: 2794799039504
 
    After modification:
 
    struct1.X: 10, struct2.X: 100
    class1.X: 200, class2.X: 200
 
    Memory address of struct1 after modification: 2794799039528
    Memory address of class1 after modification: 2794799039504
    Memory address of struct2 after modification: 2794799097048
    Memory address of class2 after modification: 2794799039504