> ## 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. # C# Static Property A static property in C# is a property declared with the `static` modifier, binding it to the type itself rather than to any specific instance of that type. Consequently, a static property shares a single state across all instances of a class or struct, and it is accessed directly through the type name rather than through an object reference. ```csharp theme={"dark"} public class ServerConfig { // Auto-implemented static property with an initializer public static int MaxConnections { get; set; } = 100; // Static backing field private static string _environmentName; // Static property with explicit accessors public static string EnvironmentName { get => _environmentName; set => _environmentName = value; } } public class Program { public static void Main() { // Accessing static properties (invoked on the Type, not an instance) ServerConfig.MaxConnections = 250; string currentEnv = ServerConfig.EnvironmentName; } } ``` ## Technical Characteristics **Instance Independence** Because static properties do not belong to an object instance, the `this` keyword is invalid within their `get` or `set` accessors. Furthermore, a static property cannot directly access non-static (instance) fields, methods, or properties of its containing type. It can only interact with other static members. **Static Classes** Static properties are a foundational component of `static` classes. When a class is declared with the `static` modifier, it cannot be instantiated, and the C# compiler enforces that all of its members—including properties, fields, and methods—must be explicitly declared as `static`. **Initialization and Static Constructors** While static properties can be initialized inline, complex initialization logic, exception handling, or multi-step setup requires a static constructor (`static ClassName()`). The Common Language Runtime (CLR) guarantees that the static constructor executes in a thread-safe manner exactly once per type before any static members are accessed or any instances are created. ```csharp theme={"dark"} public class DatabaseConfig { public static string ConnectionString { get; } // Static constructor static DatabaseConfig() { // Complex initialization logic ConnectionString = "Server=myServer;Database=myDataBase;"; } } ``` **Behavior in Generic Classes** When a static property is declared within a generic class, instances of that generic class share the static state only if they share the exact same type arguments. The C# compiler and CLR generate a completely independent static state and backing field for each *closed constructed type*. ```csharp theme={"dark"} using System; public class StateContainer { public static int InitializationCount { get; set; } } public class Program { public static void Main() { StateContainer.InitializationCount = 5; StateContainer.InitializationCount = 10; // Output is 5. The and types maintain isolated static states. Console.WriteLine(StateContainer.InitializationCount); } } ``` **Memory Allocation and Lifecycle** The compiler generates a static backing field for auto-implemented static properties. The CLR allocates memory for these static fields in the High Frequency Heap when the type is first loaded into the Application Domain (or `AssemblyLoadContext` in modern .NET). This memory remains allocated for the lifetime of the application domain, meaning the state persists globally until the application terminates or the context is unloaded. **Polymorphism and Inheritance** In classes and structs, static properties are resolved at compile-time (early binding) and cannot be marked as `virtual`, `abstract`, or `override`. A derived class hides a base class's static property by declaring a static property with the same name (member shadowing). This shadowing occurs even if the `new` keyword is omitted, though omitting it generates a compiler warning (`CS0108`). Explicitly using the `new` keyword suppresses this warning. Starting with C# 11, interfaces can declare `static abstract` and `static virtual` properties. This feature explicitly enables static polymorphism over types, allowing generic constraints to enforce that a type implements specific static properties. ```csharp theme={"dark"} public interface IConfigurable { // C# 11 static abstract property in an interface static abstract string DefaultConfig { get; } } public class AppConfig : IConfigurable { // Implementation of the static abstract property public static string DefaultConfig => "appsettings.json"; } public class BaseClass { public static string Status { get; set; } = "Base"; } public class DerivedClass : BaseClass { // Hides the static property of the base class, suppressing CS0108 public static new string Status { get; set; } = "Derived"; } ``` **Thread Safety and Synchronization** By default, static properties are not thread-safe. Because they represent shared global state, concurrent read/write operations from multiple threads can result in race conditions or data corruption. If a static property is mutable and shared across threads, explicit synchronization is required. When using the `lock` statement to synchronize access, developers must use a dedicated reference type synchronization object. Attempting to lock a value type backing field results in a compiler error (`CS0185`). To maintain thread-isolated static properties without the overhead of locking, developers use thread-local storage. This is achieved by applying the `[ThreadStatic]` attribute to a static backing field or by using the `ThreadLocal` type, which ensures each thread maintains its own independent state for that static property. ```csharp theme={"dark"} using System.Threading; public class ThreadSafeConfig { private static int _activeConnections; private static readonly object _lockObj = new object(); // Synchronized shared static property public static int ActiveConnections { get { lock (_lockObj) { return _activeConnections; } } set { lock (_lockObj) { _activeConnections = value; } } } // Thread-isolated static property private static readonly ThreadLocal _transactionId = new ThreadLocal(); public static string TransactionId { get => _transactionId.Value; set => _transactionId.Value = value; } } ``` **Access Modifiers** The `static` modifier dictates *binding*, not *visibility*. Static properties can be assigned any standard access modifier (`public`, `private`, `protected`, `internal`, etc.). A `private static` property is only accessible to other members (static or instance) within the same class.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More