C# - Static Keyword

Static Keyword in C# 

Introduction to C# Static Keyword

The C# static keyword is one of the most important and frequently used concepts in C# programming. Understanding the static keyword in C# is essential for building scalable, efficient, and well-structured applications using the .NET framework. Whether you are preparing for interviews, learning C# basics, or developing enterprise-level software, mastering static members will significantly improve your coding skills.

In C#, the static keyword is used to declare members that belong to the type itself rather than to a specific object. This means static members are shared among all instances of a class. You can apply the static modifier to:

• Static Variables (Static Fields)
• Static Methods
• Static Classes
• Static Constructors
• Static Properties

What is the Static Keyword in C#?

In simple terms, the static keyword in C# is used to create members that are shared across all objects of a class. A static member belongs to the class itself rather than any instance of the class.

When a member is declared as static:

• Memory is allocated only once.
• All objects share the same copy.
• It can be accessed without creating an object.

Let’s understand this with a simple example.

using System;

class Student
{
    public static string SchoolName = "ABC Public School";
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Student.SchoolName);
    }
}

In this example, SchoolName is a static variable. We accessed it using the class name without creating an object of the Student class.

Static Variable in C#

Definition

A static variable in C# is shared among all instances of a class. It is created only once in memory.

Why Use Static Variables?

• To store common data shared by all objects.
• To maintain counters.
• To track global state within a class.

Example: Static Variable Counter

using System;

class Counter
{
    public static int count = 0;

    public Counter()
    {
        count++;
    }
}

class Program
{
    static void Main()
    {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();

        Console.WriteLine("Total Objects Created: " + Counter.count);
    }
}

Output:

Total Objects Created: 3

Here, the static variable count is shared among all objects.

Key Points About Static Variables

• Allocated memory only once.
• Shared across all instances.
• Accessed using class name.
• Loaded when the class is loaded.

Static Method in C#

Definition

A static method in C# belongs to the class rather than an instance. It can be called without creating an object.

Rules of Static Methods

• Can access only static members directly.
• Cannot access non-static members directly.
• Called using the class name.

Example of Static Method

using System;

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

class Program
{
    static void Main()
    {
        int result = MathOperations.Add(10, 20);
        Console.WriteLine("Sum: " + result);
    }
}

This is a common example of using a static method for utility functions.

Real-World Example

The Math class in C# is a static class. For example:

Console.WriteLine(Math.Sqrt(25));

Here, Sqrt() is a static method.

Static Class in C#

Definition

A static class in C# cannot be instantiated. It can only contain static members.

Rules of Static Class

• Cannot create objects.
• Must contain only static members.
• Cannot inherit from another class.
• Cannot be inherited.

Example of Static Class

using System;

static class Utility
{
    public static void ShowMessage()
    {
        Console.WriteLine("Welcome to C# Static Class");
    }
}

class Program
{
    static void Main()
    {
        Utility.ShowMessage();
    }
}

When to Use Static Class?

• Helper methods
• Mathematical operations
• Utility functions
• Extension methods container

Static Constructor in C#

Definition

A static constructor in C# is used to initialize static data members. It runs only once.

Characteristics

• No access modifiers allowed.
• No parameters.
• Called automatically.
• Executed only once.

Example

using System;

class Demo
{
    public static int number;

    static Demo()
    {
        number = 100;
        Console.WriteLine("Static Constructor Executed");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Demo.number);
    }
}

The static constructor executes before accessing the static member.

Difference Between Static and Non-Static in C#

Static Members

• Belong to class.
• Shared across all objects.
• Accessed using class name.
• Memory allocated once.

Non-Static Members

• Belong to object.
• Separate copy for each object.
• Accessed using object reference.
• Memory allocated per instance.

Example Comparison

using System;

class Example
{
    public static int staticValue = 10;
    public int instanceValue = 20;
}

class Program
{
    static void Main()
    {
        Example obj1 = new Example();
        Example obj2 = new Example();

        obj1.instanceValue = 50;

        Console.WriteLine(obj2.instanceValue);
        Console.WriteLine(Example.staticValue);
    }
}

Memory Management and Static Members

Static members are stored in a special memory area associated with the type. In the .NET runtime, static data is stored in the managed heap but tied to the type metadata.

Key Points:

• Loaded when the class is first referenced.
• Remain in memory for the application's lifetime.
• Garbage Collector does not remove static members until application ends.

Common Interview Questions on Static Keyword in C#

1. Can a static method access non-static members?

No. Static methods can only directly access static members.

2. Can we declare a class as both static and abstract?

No. A static class is implicitly sealed and abstract.

3. How many times does a static constructor execute?

Only once per type.

4. Can static members be overridden?

No. Static members cannot be overridden.

Advantages of Static Keyword

• Memory efficient.
• Faster access.
• Ideal for shared resources.
• Useful for constants and configuration.

Disadvantages of Static Keyword

• Hard to unit test.
• Global state issues.
• Thread safety concerns.
• Reduced flexibility.

Real-World Use Cases of Static in C#

• Logger classes
• Configuration manager
• Utility helpers
• Mathematical libraries
• Singleton pattern support

The C# static keyword plays a crucial role in object-oriented programming. Understanding static class in C#, static method in C#, static variable in C#, and static constructor in C# is essential for writing efficient and maintainable applications.

Knowing the difference between static and non-static in C# helps developers design better software architecture. Static members provide performance benefits but must be used carefully to avoid design and testing challenges.

By mastering the static keyword in C#, you improve your understanding of memory management, performance optimization, and OOP principles in the .NET framework.