Static vs Non-Static Classes in C#: Understanding the Differences and Use Cases

In C#, a class is a blueprint for creating objects, providing initial values for member variables or properties, and implementations of member methods or functions. A class can have fields (variables), properties, constructors, methods, and events.

In C#, classes can be defined as either non-static or static. Non-static classes, also known as instance classes, can be instantiated and contain both static and instance members. They are useful for representing objects that have a specific state and behavior.

On the other hand, static classes are classes that cannot be instantiated and contain only static members. They are useful for holding utility methods and other functionality that is not specific to a particular instance of an object.

But, what are the main differences between static and non-static classes?

Static Classes

A static class in C# is a class that cannot be instantiated and contains only static members. For example, let us have a look at the MathHelper class:

public static class MathHelper 
{
    public static int Add(int a, int b) 
    {
        return a + b;
    }
}

MathHelper class is a static class that contains a single static method, Add. Because it is a static class, you cannot create an instance of it using the “new” keyword. Instead, you can access its static members directly by using the class name:

int result = MathHelper.Add(2, 3); // Output: 5

One of the advantages of using a static class is that it can be accessed without creating an instance of the class, which can save resources and improve performance.

Non-Static Classes

A normal class (non-static class) can be instantiated and contains both static and instance members. As an example let us create a MathHelper class, but as a non-static one:

public class MathHelper 
{
    public int a { get; set; }
    public int b { get; set; }

    public MathHelper(int a, int b)
    {
        this.a = a;
        this.b = b;
    }

    public int Add(int a, int b) 
    {
        return a + b;
    }
}

In this example, MatHelper is a class that contains properties a and b and a constructor. The properties are used to store data, and the constructor is used to initialize the data when an object of the class is created.

In a class, you can also define methods, which are functions that perform specific actions on the class’s data. As an example, I have added the Add method, which is used to add two numbers.

MathHelper mathHelper = new MathHelper(1, 2);
mathHelper.Add(); // Output: 3

If you do not want to set the values using the constructor you can also use a parameterless constructor and set the values at the method level. The class above would look like this:

 public class MathHelper
    {
        public MathHelper()
        {
        }

        public int Add(int a, int b)
        {
            return a + b;
        }
    }

To call the Add method you need to create a class object and call the Add method.

MathHelper mathHelper = new MathHelper();
mathHelper.Add(1, 2); // Output: 3

In C#, if you want to create an object with no parameters, then you do not need to have a constructor in your class, so you could only have the method and you would still get the same result.

Classes can also be inherited, whereas a derived class can inherit the properties and methods of a base class. This is a powerful feature of object-oriented programming, as it allows for the reuse of existing code and the creation of more specialized classes.

Key differences

There are a few key differences between static classes and normal (non-static) classes in C#:

1. Instance: A static class cannot be instantiated using the “new” keyword, while a normal class can.
2. Members: A static class can only contain static members, while a normal class can contain both static and instance members.
3. Inheritance: A static class cannot be inherited by other classes, while a normal class can be inherited.
4. Accessibility: A static class can only be accessed through its static members, while a normal class can be accessed through both its static and instance members.
5. Use cases: Static classes are typically used to hold utility methods and other functionality that is not specific to a particular instance of an object. On the other hand, normal classes are used to represent objects that have a specific state and behavior.

Overall, the choice between using a static class or a normal class will depend on the specific requirements of the application

18. C# - Class

33. C# - Static