> ## 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 Directive The `using` directive in C# instructs the compiler to resolve unqualified type names by searching specified namespaces. It brings the types contained within a namespace into the current lexical scope, eliminating the requirement to write fully qualified type names (e.g., writing `List` instead of `System.Collections.Generic.List`). *Note: The `using` directive is strictly a scope and naming resolution mechanism and is distinct from the `using` statement, which is used for deterministic disposal of `IDisposable` objects.* The directive operates in the following syntactical forms and mechanisms: ## 1. Standard Namespace Import Imports all accessible types from a specified namespace into the current scope. It does not recursively import nested namespaces; each namespace must be explicitly declared. ```csharp theme={"dark"} using System.Collections.Generic; ``` ## 2. Static Import (`using static`) Imports the static members and nested types of a specific type (which includes classes, structs, interfaces, and enums) directly into the current scope. This allows the invocation of static methods, properties, or enum values without qualifying them with their declaring type name. ```csharp theme={"dark"} using static System.Math; using static System.ConsoleColor; double radius = 5.0; // 'PI' is resolved directly from System.Math double area = PI * radius * radius; // 'Red' is resolved directly from System.ConsoleColor System.Console.ForegroundColor = Red; ``` ## 3. Alias Directive Creates a local identifier (alias) for a fully qualified namespace or type. This is the primary mechanism for resolving naming collisions when identical type names exist in multiple imported namespaces, or for shortening complex generic type signatures. ```csharp theme={"dark"} // Type alias using StringMap = System.Collections.Generic.Dictionary; // Namespace alias using WinUI = System.Windows.Controls; ``` ## 4. Global Modifier (`global using`) Introduced in C# 10, appending the `global` modifier applies the `using` directive to the entire compilation (the project or assembly), rather than restricting it to the current compilation unit (a single source file). ```csharp theme={"dark"} global using System.Linq; global using static System.Math; global using JsonMap = System.Text.Json.Nodes.JsonObject; ``` ## 5. Implicit Usings Implicit usings are an MSBuild/.NET SDK feature. They are controlled via the `.csproj` file: ```xml theme={"dark"} enable ``` When enabled, the SDK automatically generates a hidden C# source file during the build process containing `global using` directives for foundational namespaces based on the project SDK type (e.g., Console, Web). The C# compiler itself has no concept of implicit usings; it simply compiles the SDK-generated file alongside the rest of the source code, removing the need to explicitly declare those namespaces in individual source files. ## Scope and Resolution Rules * **Placement:** `using` directives must precede any member declarations within their enclosing declaration space. They are not strictly required to be at the top of a file; they simply must appear before any type or namespace declarations within that specific file scope or namespace body. * **Namespace-level Scope:** A `using` directive can be placed inside a `namespace` block. When declared this way, its scope is restricted exclusively to that specific namespace declaration. * **Global Placement:** `global using` directives must precede all non-global `using` directives in a compilation unit. * **Ambiguity:** If an unqualified type exists in multiple imported namespaces, the compiler does not prioritize one over the other. Instead, it emits an ambiguous reference error (CS0104). The developer must resolve this by using a fully qualified name or defining a `using` alias.

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