> ## 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# Using Static Directive The `using static` directive imports the static members and nested types of a specific type directly into the current compilation unit or namespace scope. This allows developers to invoke static methods, properties, fields, events, and constants without qualifying them with their declaring type name. ## Syntax ```csharp theme={"dark"} using static ; ``` Unlike a standard `using` directive, which imports all types within a namespace, `using static` targets a specific class, struct, interface, or enum. ## Mechanics and Scope When the compiler encounters a `using static` directive, it modifies the name resolution rules for the current file or namespace block. **Included Members:** * **Static Methods, Properties, and Fields:** Accessed directly by their identifier. * **Constants:** Because `const` fields are implicitly static, they are imported. * **Nested Types:** Types declared within the target type become accessible without qualification. * **Enum Members:** When applied to an enumeration, the individual enum values are imported into the local scope. **Excluded Members:** * **Instance Members:** The directive strictly ignores instance-level methods, properties, and fields. * **Extension Methods (Unqualified):** Extension methods declared in the target type are brought into scope for *extension method invocation* (e.g., `object.ExtensionMethod()`), but they are **not** imported for unqualified static invocation. To call them as standard static methods, the type name must still be provided. ## Code Visualization ```csharp theme={"dark"} using System; using static System.Math; using static System.Console; using static System.DayOfWeek; namespace DirectiveDemonstration { class Program { static void Main() { // 'WriteLine' is resolved from System.Console WriteLine("Demonstrating using static"); // 'PI' and 'Pow' are resolved from System.Math double area = PI * Pow(5, 2); // 'Monday' is resolved from System.DayOfWeek enum DateTime nextMeeting = GetNextDay(Monday); } static DateTime GetNextDay(DayOfWeek day) => DateTime.Now; } } ``` ## Name Resolution and Ambiguity Rules The C# compiler enforces strict precedence rules to handle naming collisions when `using static` is employed: 1. **Local Precedence:** Members declared within the current type always take precedence over members imported via `using static`. If a local method and an imported static method share the same signature, the compiler binds to the local method. 2. **Ambiguous Invocation:** If multiple `using static` directives import members with identical names and signatures from different types, the compiler does not raise an error at the directive declaration. However, if that ambiguous member is invoked, the compiler throws error **CS0121** (The call is ambiguous between the following methods or properties). The invocation must then be explicitly qualified with the type name. ## Global Modifier (C# 10+) The `using static` directive can be combined with the `global` modifier to apply the static import across all compilation units within the project. ```csharp theme={"dark"} global using static System.Math; ``` When declared globally, the static members of the specified type are injected into the root scope of the entire assembly, subjecting the entire project to the same name resolution and ambiguity rules described above.

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