What is the purpose of the static keyword

The static a keyword in C# is used to define members (fields, methods, properties) or classes that belong to the type itself rather than to a specific instance. It allows access without creating an object of the class.

Also worth remembering In C#, one important but often overlooked fact about static is that a static constructor cannot be async, and if a static constructor ever throws an exception, the entire type becomes permanently unusable for the lifetime of the application domain. That means every future access to the class will fail with a TypeInitializationException, and there is no way to recover without restarting the process. Microsoft strongly recommends avoiding heavy work or any kind of I/O inside static constructors .

It depends on how it is used. It can be used for classes, individual members of classes, the entry point of a C# program or some other less common purpose.

Static classes are created at the beginning of the program and exist for the life of the program. Therefore we refer to them by their class name, not using a reference. Static members are similar; we also refer to them by the class name, not a reference.

One special case is the entry point of C# programs; they are always a static method.

What is static in C#?

The static keyword means that the member or class belongs to the type itself, not to any specific object (instance).

In other words:

You don’t need to create an object to access static members — they belong to the class, not an instance.

1. Static Variables (Fields)

A static variable is shared among all instances of a class.

Example:

public class Counter
{
    public static int Count = 0; // shared by all objects

    public Counter()
    {
        Count++;
    }
}

Usage:

Counter c1 = new Counter();
Counter c2 = new Counter();
Console.WriteLine(Counter.Count); // Output: 2 (shared across all)

Purpose: Keeps common data shared across all objects (like total users, settings, etc.).

2. Static Methods

A static method can be called without creating an object.

Example:

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

Usage:

int result = MathHelper.Add(5, 3); // No object needed

Purpose: Use for utility or helper functions that don’t depend on instance data.

3. Static Classes

A static class:

• Can only contain static members

• Cannot be instantiated

• Is automatically sealed (can’t be inherited)

Example:

public static class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine("Log: " + message);
    }
}

Usage:

Logger.Log("System started"); // Direct call, no object needed

Purpose: Group common utilities or helper methods (like Math, Console, File).

4. Static Constructors

A static constructor runs once per class, before any object or static member is used.

Example:

public class Config
{
    public static string AppName;

    static Config() // static constructor
    {
        AppName = "My Application";
        Console.WriteLine("Static constructor executed!");
    }
}

Purpose: Initialize static data or perform setup once before class use.

5. Static vs Instance Members

6. Real-Life Example

public class BankAccount
{
    public static double InterestRate = 6.5; // same for all accounts
    public string AccountHolder;

    public BankAccount(string name)
    {
        AccountHolder = name;
    }

    public void Display()
    {
        Console.WriteLine($"{AccountHolder} - Interest: {InterestRate}%");
    }
}

Usage:

BankAccount a1 = new BankAccount("Sandhiya");
BankAccount a2 = new BankAccount("Priya");

BankAccount.InterestRate = 7.0; // update static variable

a1.Display(); // Sandhiya - Interest: 7%
a2.Display(); // Priya - Interest: 7%

Purpose: Shared values (like interest rate, tax rate, or configuration).

Summary Table

https://www.c-sharpcorner.com/UploadFile/36bc15/static-keyword-in-C-Sharp/

The Static keyword in C# defines members or classes that belong to the type itself rather than any instance, allowing access without object creation.

In C# (.NET), the static keyword is used for defining members or types that belong to the type itself rather than to any specific object (instance) of the type. It applies to classes, methods, variables, constructors, and properties.