Structs in C# are value types that are typically used to encapsulate small groups of related variables. Unlike classes, structs are allocated on the stack and can provide better performance for certain use cases. This tutorial covers the basics of structs, their differences from classes, when to use structs, and best practices.

1. Understanding Structs

Structs are value types, which means they are stored on the stack and their values are directly accessible. This differs from reference types, such as classes, which are stored on the heap and accessed via references. Structs are useful for representing lightweight objects.

        
            namespace StructExamples;

// Define a struct
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

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

    public void Display()
    {
        Console.WriteLine($"Point: ({X}, {Y})");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Point point = new Point(3, 4);
        point.Display(); // Output: Point: (3, 4)
    }
}
        
    

2. Differences Between Structs and Classes

While structs and classes are both used to define objects, they have several key differences:

• Value Type vs. Reference Type: Structs are value types and are stored on the stack, while classes are reference types and are stored on the heap.
• Default Constructor: Structs cannot have explicit parameterless constructors, while classes can.
• Inheritance: Structs do not support inheritance, whereas classes do.
• Performance: Structs can provide better performance in scenarios where small data structures are frequently created and destroyed.

        
            namespace StructExamples;

// Define a struct
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

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

// Define a class
class PointClass
{
    public int X { get; set; }
    public int Y { get; set; }

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

class Program
{
    static void Main(string[] args)
    {
        Point pointStruct = new Point(3, 4);
        PointClass pointClass = new PointClass(3, 4);

        // Value type: copied by value
        Point anotherPointStruct = pointStruct;
        anotherPointStruct.X = 5;

        // Reference type: copied by reference
        PointClass anotherPointClass = pointClass;
        anotherPointClass.X = 5;

        Console.WriteLine($"pointStruct.X: {pointStruct.X}, anotherPointStruct.X: {anotherPointStruct.X}"); // Output: pointStruct.X: 3, anotherPointStruct.X: 5
        Console.WriteLine($"pointClass.X: {pointClass.X}, anotherPointClass.X: {anotherPointClass.X}"); // Output: pointClass.X: 5, anotherPointClass.X: 5
    }
}
        
    

3. When to Use Structs

Structs should be used when you need a lightweight object that represents a single value or a small group of related values. Common scenarios include:

• Representing points, vectors, and other geometric data.
• Encapsulating multiple related variables in a single value.
• Creating performance-critical components where heap allocation is undesirable.

4. Struct Members

Structs can contain fields, properties, methods, and constructors with parameters. However, structs cannot contain default constructors, destructors, or finalizers.

        
            namespace StructExamples;

// Define a struct with members
struct Rectangle
{
    public int Width { get; }
    public int Height { get; }

    public Rectangle(int width, int height)
    {
        Width = width;
        Height = height;
    }

    public int Area()
    {
        return Width * Height;
    }

    public override string ToString()
    {
        return $"Rectangle: {Width}x{Height}";
    }
}

class Program
{
    static void Main(string[] args)
    {
        Rectangle rect = new Rectangle(3, 4);
        Console.WriteLine(rect); // Output: Rectangle: 3x4
        Console.WriteLine($"Area: {rect.Area()}"); // Output: Area: 12
    }
}
        
    

5. Best Practices for Using Structs

• Keep Structs Small: Ensure that structs remain small and lightweight. Large structs can negatively impact performance due to copying overhead.
• Avoid Mutable Structs: Mutable structs can lead to unintended behavior. Prefer immutable structs by using readonly fields and properties.
• Use Structs for Simple Data: Use structs to encapsulate simple, related data values that do not require complex behavior or inheritance.
• Consider Performance Implications: Be aware of the performance characteristics of structs, particularly in scenarios involving boxing and unboxing or large data structures.

Conclusion

Structs in C# are value types that are useful for encapsulating small, related groups of variables. By understanding their differences from classes, when to use them, and best practices, you can effectively leverage structs to build performant and maintainable applications.