Difference Between Class and Struct in C#

Overview

Struct and Class in C# are integral components for creating and managing objects, but they fundamentally differ. Understanding the difference between struct and class in C# empowers developers to make informed decisions, optimizing their code for specific requirements and use cases.

What are Structs and Classes?

In C#, structs and classes are used to define custom data types and encapsulate data and behavior within an object-oriented programming paradigm.

Classes in C#

A class in C# is a fundamental building block of object-oriented programming (OOP) that allows you to define a blueprint or template for creating objects. It serves as a container for data members (fields) and functions (methods) that define the state and behavior of objects of that class.

A class can contain

• Data Members: Also known as fields, these are variables that store the state or data of an object.
• Methods: Functions defined within the class that represent the behavior or actions that the objects of the class can perform.
• Properties: Special methods that provide access to private data members, allowing controlled read and write access to the class's data.
• Constructors: Special methods that are called when an object is created and used to initialize its state.

Classes serve as blueprints that define the structure and behavior of objects, but they are not objects themselves. Objects are instances of a class created at runtime based on the class definition.

Struct in C#

In C#, a struct (short for "structure") is a composite data type that allows you to encapsulate related data members of different data types into a single unit. It is a value type, meaning instances of a struct are stored directly in memory, where they are declared and typically used for lightweight data structures.

Unlike classes, structs are not reference types; they are copied by value rather than by reference. When you pass a struct to a method or assign it to another variable, a new copy of the struct is created, and modifications to one copy do not affect the others.

Struct Vs Class in C#

Here's a table outlining the key difference between struct and class in C#.

Aspect	Struct	Class
Memory Allocation	Value type allocated on stack or inline	Reference type allocated on the heap
Inheritance	It cannot be inherited from another type	Can inherit from another class
Polymorphism	No support for polymorphism	Supports polymorphism and can implement interfaces
Default Constructor	Not provided automatically	Provided automatically, it can be overridden
Constructors	Can have a parameterless constructor	Can have parameterless constructors and constructors with parameters
Nullable Value Types	It cannot be null	Can be null
Memory Overhead	Lower memory overhead	Higher memory overhead due to object header and additional features
Usage	Suitable for small data structures, simple types	Suitable for complex objects, business logic
Performance Consideration	It can be more efficient for small data	Slightly less efficient due to heap allocation, indirection, and overhead

Explanation

• Memory allocation: Structs are value types and are generally allocated on the stack or inline within other structures. This can lead to better memory usage and performance. Classes, being reference types, are allocated on the heap, which might involve additional memory overhead and management.
• Inheritance: Structs cannot inherit from other types, whereas classes can be used as a base for inheritance hierarchies.
• Polymorphism: Structs do not support polymorphism, which means they cannot participate in polymorphic behavior or be used in polymorphic collections. Classes can take advantage of polymorphism, allowing different derived classes to be treated as instances of their base class.
• Default constructor: Structs do not have a default parameterless constructor provided automatically. Classes, on the other hand, have a default parameterless constructor that can be overridden if needed.
• Constructors: Both structs and classes can have constructors. Structs can have a parameterless constructor, and classes can have both parameterless constructors and constructors with parameters.
• Nullable value types: Structs cannot have a null value (unless they are used as nullable value types with the Nullable struct). Classes can be assigned a value of null.
• Memory overhead: Structs have lower memory overhead since they don't require an object header or additional features like garbage collection. Classes have slightly higher memory overhead due to the object header and the management required for heap-based allocation.
• Usage: Structs are suitable for small data structures and simple types that do not require complex behavior. Classes are used for more complex objects, business logic, and scenarios where inheritance and polymorphism are required.
• Performance consideration: Structs can be more efficient for small data structures due to stack allocation and reduced overhead. However, classes are slightly less efficient due to heap allocation, additional indirection through references, and the object header.

Selecting either a struct or a class should hinge on your application's particular requirements and the attributes of the data or entities you intend to represent.

Memory allocation for Structs and Classes

Structs and classes in C# have distinct memory allocation and performance characteristics. When you create a struct, it is allocated on the stack, making it more efficient than classes, which are allocated on the heap. Consequently, structs are well-suited for performance-critical functions with low memory requirements.

However, structs have a size limit of 16 bytes. If a struct exceeds this limit, it will be allocated on the heap, potentially causing performance issues when working with large structs.

In contrast, classes have no size limit and are more suitable for complex data structures that require a significant amount of memory. However, this comes at the cost of efficiency, making classes less ideal for high-performance functions with low memory usage.

Furthermore, classes support inheritance and polymorphism, enabling more flexible and modular code design. On the other hand, structs lack support for inheritance and polymorphism, restricting them to simpler data structures without the advantages of object-oriented features.

Performance Comparison Structs vs Classes

Due to their memory allocation differences, structs are generally faster than classes. If you’re working with a large amount of data, structs can be more efficient because they don’t require the overhead of heap memory allocation.

However, there are some cases where classes are faster than structs. For example, when copying large objects, classes can be more efficient because they only copy a reference to the object instead of the object itself.

Another advantage of using structs is that they are value types, meaning that they are copied by value rather than by reference. This feature proves valuable when you aim to guarantee that the initial data remains unmodified throughout subsequent operations.

On the other hand, classes are reference types, which means that they are passed by reference. This can be useful in situations where you want to modify the original data without creating a new copy of it.

When to Use Struct or Classes?

To provide a suitable answer, it is essential to have a comprehensive understanding of the difference between struct and class in C#.

• Structs are value types allocated either on the stack or inline in containing types. Classes are reference types, allocated on the heap, and garbage-collected.
• Allocations and de-allocations of value types are, in general, cheaper than allocations and de-allocations of reference types. Assignments of large reference types are cheaper than assignments of large value types.
• In structs, each variable holds its independent copy of the data (excluding ref and out parameter variables), and manipulating one variable does not impact another variable. In classes, two variables can hold references to the same object, and any operation performed on one variable can impact the object and, consequently, the other variable.

Example of Struct

using System;
struct Location
{
    public int x, y;
    public Location(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}
public class HelloWorld
{
    public static void Main(string[] args)
    {
        Location a = new Location(20, 20);
        Location b = a;
        a.x = 100;
        Console.WriteLine(b.x);
    }
}

The output is 20. When the value of a.x changes, b remains unaffected since it is a copy of a and refers to a different object. However, in the context of a class, the output will be 100 because both a and b will point to the same object, causing their values to be synchronized.

In practice, you should opt for a structure only when certain conditions are met.

• When it logically represents a single value, resembling primitive types (int, double, etc.).
• When it remains immutable, meaning its state doesn't change after creation.
• When it doesn't require frequent boxing and unboxing operations.

In all other situations, it's advisable to define your custom types as classes.

Examples of Structs and Classes in C#

Here are some instances of how struct and classes might be used in a C# program.

Example 1. Representing a Point.

struct Point
{
    public int X;
    public int Y;
}
class PointClass
{
    public int X;
    public int Y;
}

Example 2. Representing a Student.

struct Student {
    public string Name;
    public int Rollno;
}

class Student {
    public string Name;
    public int Rollno;
}

Conclusion

• The difference between struct and class in C# has significant implications for data representation and performance.
• Structs, being value types, offer stack allocation, making them efficient for small, lightweight data, while classes, as reference types, provide more versatility and support complex behaviors but utilize heap allocation.
• Structs are copied by value, ensuring independence between instances, whereas classes are copied by reference, leading to shared data instances. Structs lack support for inheritance, limiting their use to simple data structures, while classes facilitate inheritance and enable the creation of complex object hierarchies.
• The decision to use structs or classes depends on the specific requirements of data representation, memory management, and performance optimization in C# programming.