Difference between struct and class in C#

In this article, we will discuss the difference between struct and class in C#. But before discussing its differences, we must know about the struct and class in C#. Classes and structures can be used in C# to build custom data types but have important differences. Unlike structures, classes can be inherited from other classes. Put differently, a structure cannot be inherited from a class.

The difference between a reference type and a value type is that classes are reference types, meaning whenever you create a component of a class, a reference to that object is also created, and any changes to the object in question are reflected whenever the reference is used.

On the other hand, a structure is an integer type, which implies that when you create a structure-type variable, the variable's actual amount is saved in memory. In contrast, modifications to the variables cannot be seen elsewhere.

What is a Class?

A class is a user-defined blueprint or prototype used to build things. A class combines fields and methods (member functions defining actions) into a single unit.

Example:

Filename: Class.cs

using System;
// Define a Writer class
public class Writer {

    // Declare public data members for the writer's information
    public string authorName;        // Name of the author
    public string primaryLanguage;   // Primary programming language
    public int publishedArticles;    // Total published articles
    public int authoredImprovements; // Total authored improvements

    // Method to set and display author details
    public void AuthorDetails(string authorName, string primaryLanguage,
                              int publishedArticles, int authoredImprovements)
    {
        // Set the class data members with provided values
        this.authorName = authorName;
        this.primaryLanguage = primaryLanguage;
        this.publishedArticles = publishedArticles;
        this.authoredImprovements = authoredImprovements;

        // Display author's details using Console.WriteLine
        Console.WriteLine("Author's Name: " + authorName
                        + "\nPrimary Language: " + primaryLanguage
                        + "\nTotal Published Articles: " + publishedArticles
                        + "\nTotal Authored Improvements: " + authoredImprovements);
    }

    // Main method where the program starts execution
    public static void Main(String[] args)
    {
        // Create an instance of the Writer class
        Writer writerObj = new Writer();

        // Call the AuthorDetails method to set and display author details
        writerObj.AuthorDetails("John Doe", "C#", 80, 50);
    }
}

Output:

Author's Name: John Doe
Primary Language: C#
Total Published Articles: 80
Total Authored Improvements: 50

What is Structure?

Structure is a value type and a collection of variables of various data kinds contained within a single unit. It is comparable to a class because both are user-defined data types that hold a variety of data types. C# allows you to use predefined data types. However, the user may need to design its own data types, commonly called User-Defined Data Types. Although it falls under the value type, the user can edit it to meet their needs, which is also known as the user-defined information type.

Syntax:

It has the following syntax:

// Define a C# struct with the following components:
// - Access Modifier (e.g., public, private, internal)
// - Struct Name (the name of the structure)

struct StructureName
{
    // Fields (variables to store data)
    // Parameterized Constructor (a special method to initialize the structure)
    // Constants (immutable values that don't change during runtime)
    // Properties (getters and setters for accessing and modifying data)
    // Indexers (special properties to access elements in the structure)
    // Events (mechanisms for handling and notifying events)
    // Methods (functions that perform actions or calculations)
}

Example:

Filename: Struct.cs

using System;
namespace MyUniqueApplication {

    // Define a structure named PersonDetails
    public struct PersonDetails
    {
        // Declare fields with different data types
        public string FullName;
        public int Age;
        public int BodyWeight;

    }

    class MyProgram {
        
        // Main Method
        static void Main(string[] args)
        {

            // Declare person1 of type PersonDetails
            PersonDetails person1;

            // Assign values to person1's fields
            person1.FullName = "Alice Johnson";
            person1.Age = 25;
            person1.BodyWeight = 65;

            // Display the stored information
            Console.WriteLine("Information about person1: " +
                            "Name: " + person1.FullName +
                            ", Age: " + person1.Age +
                            ", Body Weight: " + person1.BodyWeight);

        }
    }
}

Output:

Information about person1: Name: Alice Johnson, Age: 25, Body Weight: 65

Main Difference between Struct and Class:

There are several main differences between struct and class in C#. Some main Differences between struct and class are as follows:

Default Constructor: The default constructor is always called whenever a class's object is formed. On the other hand, a structure doesn't come with a default constructor.

Initialization: Whenever you create a class object, its components are set to the default settings (null for types of references and 0 for values types). Whenever you create an object of the type variable, all its members have been set using their default values. Whenever you create a variable of the structure's type, users can supply initial values for each structure component.

Size of performance: Structures are typically smaller than classes since they don't include reference parameters or overhead. It means structures may be faster than classes to pass as arguments or copy.

In C#, the key distinctions between subclasses and structures include inheritance, reference type vs. value type, default constructor, its initialization, and size/performance. The structures serve the purpose of smaller, simpler things that are used regularly and need to be passed around fast, whereas classes are used for larger, more sophisticated objects. However, both classes and structures have advantages and disadvantages, and the project's specific requirements ultimately determine their decision.

Head-to-head comparison between struct and class in c#

There are several head-to-head comparisons between struct and class in C#. Some main Differences between struct and class are as follows:

Class	Structure
Classes are of the *reference type*	Structs are *value types*.
All of the reference types are assigned heap memory.	Any of the value types are allotted stack memory.
Allocation of large reference types is less expensive than allocating large value types.	Allocation and de-allocation are less expensive in the value type compared to the reference type.
The class has numerous aspects.	Struct has limited capabilities.
Classes are commonly utilized in large programs.	Structs are used in small programs.
Classes can include constructors and destructors.	Structures have not parameter less or destructors, although they may have parameterized or static constructors.
Classes created instances with the new keyword.	With or without the new keyword, Struct can generate an instance.
A class can be descended from a different group.	It is not permitted for a Struct to inherit from a different struct or class.
A class's data component can be encrypted.	A struct's data member cannot be protected.
A class function member can be private or abstract.	The struct's function members can't be virtual or abstract.
Two variables of the same class can have the same object's reference. It is and actions performed on one variable can affect another.	Every variable in struct has its own copy of data (with the exception of the in-ref and out-parameter variables), and any action performed on one variable has no effect on another.