C# Struct vs Class |Top 15+ Differences Between C# Struct and Class

C# Struct vs. Class: In C#, Struct and Class are user-defined data types that can contain a bunch of different data types. The main difference between these two is that class is a reference type, and Struct is a value type.

C# struct vs class
C# struct vs class

What is a C# class?

In C#, a Class is a user-defined blueprint, prototype, or template for creating objects.

A class is a reference type that represents a complex data structure. Classes are user-defined data types that can contain fields, methods, properties, and other types of members, which can be accessed and used by creating an instance of that class.

Because classes are reference types, they are stored in a heap and require garbage collection. That can make them slower and less efficient than structs for storing small amounts of data, but they are more powerful and flexible for creating complex objects.


public class MyClass
    // Fields
    private int myField1;
    private string myField2;
    // Properties
    public int MyProperty1 { get; set; }
    public string MyProperty2 { get; set; }
    // Constructor
    public MyClass(int field1, string field2)
        myField1 = field1;
        myField2 = field2;
    // Methods
    public void MyMethod1()
        // Method logic here
    public string MyMethod2(int parameter)
        // Method logic here
        return "Result";

What is a C# struct?

In C#, a Struct is a user-defined value type data type. It allows you to create a single variable to hold related data of different types.

A struct is a value type that represents a simple data structure. Structs are similar to classes because they can also contain fields, methods, and properties, but they have several key differences.

The main difference is that structs are value types, meaning they are stored directly in memory and don’t require garbage collection. It can make them faster and more efficient for storing small data.


We can create a structure using the struct keyword followed by the structure name.

struct MyStruct
    // Fields, properties, and methods go here

C# Struct vs Class

The following is the list of differences between struct and class in C#.

  • In C#, Class is a reference type, whereas Struct is a value type.
  • A class object is allocated on the heap memory, whereas Struct type variables are allocated on the stack memory.
  • All struct types implicitly inherit from the class System.ValueType, whereas every Class is implicitly a subclass of the System.Object class.
  • Value types are immediately destroyed when the scope is lost, whereas the garbage collector only destroys reference-type objects. As a result, value type allocations and deallocations are generally less expensive than reference types.
  • A class object is passed by reference to a method, whereas a structure is passed as a value rather than a reference to the method (except ref and out parameter variables).
  • Since Struct is not a reference type, Boxing and unboxing operations convert between a struct type and an object in C#.
  • In C#, Destructors are not allowed in structures, but they are allowed in classes.
  • Parameterless constructors are not allowed in the structure. However, parameterized and static constructors are allowed. A class, on the other hand, can have any constructor.
  • Structs can be instantiated with or without the new keyword, whereas classes require the new keyword to be instantiated.
  • A class can inherit from another class, but a struct cannot inherit from another struct or Class. However, a structure type can implement interfaces.
  • The structure cannot be a base class and is implicitly sealed, while the Class can be a base class.
  • By default, members of a class are private, whereas members of a structure are public.
  • The data member of a class can be declared as protected, while the data member of a struct cannot.
  • A struct type variable directly contains the struct data, whereas a class type variable contains a reference to the data.
  • Instance fields cannot have initializers in a struct, which means that you cannot declare a member of the structure like the below image:
field initializers in struct in C#
Field initializers in the struct

Parameter less constructors and field initializers in the struct in C# 10.0

Note: Starting with C# 10.0, you can declare a (default) parameter less constructor and field Initializers in a struct type. You are now allowed to initialize an instance field or property during declaration time with C# 10.


using System;
namespace StructInCSharp
    // Example: field Iinitializers in a struct  in C#10
    public readonly struct Employee
        public double Salary { get; init; }

        // Initialize an instance field or property at its declaration
        public string Name { get; init; } = "Shekh Ali";
        public Employee(double salary)
            Salary = salary;
        public override string ToString() => $" Salary= $ {Salary} Name=({Name})";

    public static void Main(string[] args)
        Employee employee = new Employee(5000);
        Console.WriteLine(employee);  // output: Salary= $ 5000 Name=(Shekh Ali)

C# Struct Example

A structure can be created by using the struct keyword.
In C#, a structure-type variable can’t be null so you must initialize a declared variable before it can be used.
The following is an example of how to create a structure in C#.


We can also instantiate a structure type without using the new operator if all its instance fields are accessible. In that situation, we must initialize all instance fields before the instance is used for the first time. The example below demonstrates how to do so:

using System;
namespace StructInCSharp
    public static class StructWithoutNewOperator
        public struct Coordinates
            public double x;
            public double y;

        public static void Main()
            //Example- Struct without new operator
            Coordinates  c;
            c.x = 3;
            c.y = 5;
            Console.WriteLine($" Coordinates : (x = {c.x}, y = {c.y})");

            // Output:  Coordinates : (x = 3, y = 5)

When to Choose Struct Over Class in C#?

Choosing between Structs and Classes in C# can be difficult, and it ultimately depends on the specific requirements of your code. However, here are five reasons why you might choose to use a Struct over a Class:

  1. Avoiding Garbage Collection Overhead: Structs are value types allocated on the stack, meaning they do not require garbage collection. That can result in faster performance and reduced memory usage, especially for small data types.
  2. Faster Performance for Small Data Types: Because Structs are allocated on the stack and do not require memory management overhead, they can be created and copied more quickly than Classes. That makes them ideal for small data types that do not need to be modified frequently.
  3. Creation of Immutable Types: Structs are often used for immutable types, objects that cannot be changed once created. Because Structs are value types, any changes to the Struct result in creating a new Struct, which can help ensure immutability.
  4. Simpler Syntax: Structs have a simpler syntax than Classes, making them easier to use and understand for developers new to C#.
  5. Compatibility with Other Languages: Structs are compatible with other languages that use similar value types, such as C and C++. That can make it easier to work with code written in other languages or integrate C# code with existing systems.

When to Choose Class Over Struct in C#?

While Structs have their advantages, there are also situations where a Class might be a better choice. Here are five reasons why you might choose to use a Class over a Struct in C#:

  1. Inheritance and Polymorphism: Classes support inheritance and polymorphism, which means that you can create complex object hierarchies and use them in a flexible and extensible way. Structs, however, do not support inheritance and cannot be used similarly.
  2. Ability to Create Complex Objects: Classes are reference types that can create complex objects with properties, methods, and events. That makes them ideal for situations where you need to create objects with a lot of functionality and state.
  3. Better Memory Management for Large Data Types: While Structs are ideal for small data types, Classes are better suited to large data types that require more memory management. Classes are allocated on the heap and can be garbage collected when they are no longer needed, which can help reduce memory usage and prevent memory leaks.
  4. Dynamic Allocation: Classes can be dynamically allocated at runtime, meaning you can create objects on the fly and use them flexibly. Structs, however, are allocated on the stack and must be explicitly created and destroyed.
  5. When Working with Libraries or Frameworks: Many libraries and frameworks are designed to work with Classes, so if you want to take advantage of these tools, you will need to use Classes in your code. Additionally, if you are working in a team environment, using Classes can make it easier for other developers to understand and work with your code.

Reference MSDN: Class and struct differences


Q: Can structs inherit from classes in C#?

No, structs cannot inherit from classes in C#. Structs are value types, whereas classes are reference types. Inheritance is only possible between reference types.

Q: Is struct faster than class in C#?

Structs are faster than classes for small data types because they avoid the overhead of garbage collection.
However, classes might be faster for larger data types because they can take advantage of the CPU cache.

Q: Can a struct be null in C#?

No, a struct cannot be null in C#. Structs are value types allocated on the stack, so they cannot be assigned a null value. However, you can use nullable value types to represent the absence of a value for a struct variable.

What is the difference between a struct and a class in C#?

Structs are value types allocated on the stack, while classes are reference types allocated on the heap. Structs are typically used for small data types, while classes are used for more complex object types.

Q: When should I use a struct in C#?

Structs are best used for small data types that don’t require complex functionality or inheritance. They are also useful for creating immutable types and avoiding garbage collection overhead.

Q: When should I use a class in C#?

Classes are best used for more complex object types that require inheritance and polymorphism. They are also useful for creating objects with lots of functionality and managing memory for larger data types.


In summary, Structs and Classes have different advantages and disadvantages, and the choice between the two depends on the specific requirements of your code.
Structs are ideal for small, simple data types and immutable types, while Classes are better for complex objects and inheritance.

When making decision, consider the memory usage and performance requirements of your code, as well as the specific needs of your project. Choosing the right data type ensures that your code is efficient, easy to maintain, and performs well.

Recommended Articles:

Let others know about this post by sharing it and leaving your thoughts in the comments section.

5 1 vote
Article Rating
Notify of

Inline Feedbacks
View all comments