When should I use a struct rather than a class in C#?

In C#, you should use a struct rather than a class when you want to represent a lightweight, simple value type that has value semantics rather than reference semantics. Structs are ideal for small data structures that don't require the overhead of object-oriented features like inheritance, garbage collection, and reference tracking.

Here are some scenarios where using a struct might be more appropriate:

    Small Data Structures: When you need to represent a small group of related data fields with simple value types (integers, booleans, etc.), a struct can be more memory-efficient and faster to access than a reference-type class.

    Value Semantics: When you want value semantics, meaning that the instance is copied when assigned to a new variable or passed to a method, rather than having multiple references pointing to the same object.

    Performance-Critical Code: In performance-critical scenarios, structs can be more efficient due to their stack allocation and reduced memory overhead compared to reference-type objects.

    Immutable Data: When the data doesn't need to be modified after creation, using a struct ensures that the values remain constant throughout their lifetime.

Here's an example illustrating the use of a struct:

csharp

using System;

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

class Program
{
    static void Main()
    {
        Point point1 = new Point(2, 3);
        Point point2 = point1; // Copy the struct

        Console.WriteLine("Point 1: " + point1); // Output: (2, 3)
        Console.WriteLine("Point 2: " + point2); // Output: (2, 3)

        point2 = new Point(5, 7);
        Console.WriteLine("Point 2 after modification: " + point2); // Output: (5, 7)
    }
}

In this example, Point is a struct representing a simple point with X and Y coordinates. The instances of Point are copied by value, so modifying one instance does not affect the other.

Remember that using a struct comes with some trade-offs. They are value types, which means they can be less efficient for large data structures and can lead to unnecessary copying if not used carefully. Additionally, structs cannot be used as a base class and have certain limitations compared to reference types like classes.