Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

A static class in C# is a class declared with the static modifier that cannot be instantiated and is strictly limited to containing only static members and constant values. It serves as a structural container for state and behavior that is bound directly to the type itself, rather than to any specific object instance. 
public static class StaticClassName
{
    // Fields, properties, methods, and events must be explicitly static
    public static int StaticField;
    
    // Constants are implicitly static and are permitted
    public const string Version = "1.0.0";
    
    public static void StaticMethod() 
    { 
        // Implementation
    }

    // Nested types do not require the static modifier
    public class NestedClass { }
    public enum NestedEnum { OptionA, OptionB }
}

​
Core Architectural Rules

  • Instantiation: The compiler strictly prohibits the use of the new operator on a static class. Attempting to instantiate it results in compile-time error CS0712.
  • Inheritance: Static classes are implicitly sealed. They cannot be inherited by any other class. Furthermore, they cannot inherit from any class other than System.Object, and they cannot implement interfaces.
  • Member Restrictions: Every field, property, method, and event within a static class must explicitly include the static modifier. The inclusion of any instance member triggers a compile-time error. However, there are two critical exceptions regarding type members:
    • Constants: const fields are implicitly static and are permitted. Explicitly applying the static modifier to a const field results in compile-time error CS0106.
    • Nested Types: Nested types (classes, structs, enums, delegates, and interfaces) do not require the static modifier. Furthermore, nested structs, enums, and interfaces are perfectly valid inside a static class but cannot be marked static at all.
  • Extension Methods: Static classes are the only architectural construct in C# capable of hosting Extension Methods (methods defined with the this modifier on the first parameter). To host extension methods, the static class must be non-generic and non-nested.

​
Constructor Constraints

Static classes cannot contain instance constructors. They are permitted to have a single static constructor, subject to the following constraints:
  • It must be parameterless.
  • It cannot have access modifiers (e.g., public, private).
  • It is invoked automatically by the Common Language Runtime (CLR) exactly once per Application Domain (AppDomain), strictly before any static member is referenced.
public static class ApplicationState
{
    public static readonly string StartupTime;

    // Static constructor
    static ApplicationState()
    {
        StartupTime = System.DateTime.UtcNow.ToString("O");
    }

    public static void RegisterState()
    {
        // Method logic
    }
}

​
Memory Allocation and Lifecycle

When a C# application executes, the type object for a static class is loaded into the High-Frequency Heap of the AppDomain. Because there are no instances, memory is allocated only for the static fields defined within the class. The lifecycle of a static class and its state is intrinsically tied to the AppDomain. The CLR initializes the class upon first access, and the memory allocated for its static fields is not eligible for garbage collection until the AppDomain itself is unloaded. Consequently, state held within a static class is globally accessible and persists for the lifetime of the application.
Master C# with Deep Grasping Methodology!Learn More