The using directive

The using directive allows you to use types defined in a namespace without specifying the fully qualified namespace of that type. In its basic form, the using directive imports all the types from a single namespace, as shown in the following example:

using System.Text;

You can apply two modifiers to a using directive:

• The global modifier has the same effect as adding the same using directive to every source file in your project.
• The static modifier imports the static members and nested types from a single type rather than importing all the types in a namespace.

You can combine both modifiers to import the static members from a type to all source files in your project.

You can also create an alias for a namespace or a type with a using alias directive.

using Project = PC.MyCompany.Project;

You can use the global modifier on a using alias directive.

The scope of a using directive without the global modifier is the file in which it appears.

The global using directive must appear before all namespace and type declarations. All global using directives must appear in a source file before any nonglobal using directives.

Other using directives can appear:

• At the beginning of a source code file, before any namespace or type declarations.
• In any blocked-scoped namespace, but before any namespaces or types declared in that namespace.

Otherwise, a compiler error is generated.

Create a using directive to use the types in a namespace without having to specify the namespace. A using directive doesn't give you access to any namespaces that are nested in the namespace you specify. Namespaces come in two categories: user-defined and system-defined. User-defined namespaces are namespaces defined in your code. For a list of the system-defined namespaces, see .NET API Browser.

The global modifier

Adding the global modifier to a using directive means that using is applied to all files in the compilation (typically a project):

global using <fully-qualified-namespace>;

Where fully-qualified-namespace is the fully qualified name of the namespace whose types can be referenced without specifying the namespace.

A global using directive can appear at the beginning of any source code file. All global using directives in a single file must appear before:

• All using directives without the global modifier.
• All namespace and type declarations in the file.

You can add global using directives to any source file. Typically, you want to keep them in a single location. The order of global using directives doesn't matter, either in a single file, or between files.

The global modifier can be combined with the static modifier. The global modifier can be applied to a using alias directive. In both cases, the directive's scope is all files in the current compilation. The following example enables using all the methods declared in the System.Math in all files in your project:

global using static System.Math;

You can also globally include a namespace by adding a <Using> item to your project file, for example, <Using Include="My.Awesome.Namespace" />. For more information, see <Using> item.

Analyzers issue diagnostics if you duplicate global using directives in different locations. These same analyzers also inform you if you add a using directive for a namespace or type that a global using directive already references. You might find it easier to manage your global usings by keeping them together in one file in the project.

The static modifier

The using static directive names a type whose static members and nested types you can access without specifying a type name. Its syntax is:

// not within a namespace
using static <fully-qualified-type-name>;

The <fully-qualified-type-name> is the name of the type whose static members and nested types can be referenced without specifying a type name. If you don't provide a fully qualified type name (the full namespace name along with the type name), C# generates compiler error CS0246: "The type or namespace name 'type/namespace' couldn't be found (are you missing a using directive or an assembly reference?)".

If the using static directive is applied within the context of a namespace (either file-scoped or nested in a namespace block, it isn't necessary to fully qualify the type.

The using static directive applies to any type that has static members (or nested types), even if it also has instance members. However, instance members can only be invoked through the type instance.

You can access static members of a type without having to qualify the access with the type name:

using static System.Console;
using static System.Math;
class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4));
    }
}

Ordinarily, when you call a static member, you provide the type name along with the member name. Repeatedly entering the same type name to invoke members of the type can result in verbose, obscure code. For example, the following definition of a Circle class references many members of the Math class.

using System;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * Math.PI; }
   }

   public double Area
   {
      get { return Math.PI * Math.Pow(Radius, 2); }
   }
}

By eliminating the need to explicitly reference the Math class each time a member is referenced, the using static directive produces cleaner code:

using System;
using static System.Math;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}

using static imports only accessible static members and nested types declared in the specified type. Inherited members aren't imported. You can import from any named type with a using static directive, including Visual Basic modules. If F# top-level functions appear in metadata as static members of a named type whose name is a valid C# identifier, then the F# functions can be imported.

using static makes extension members declared in the specified type available for extension member lookup. However, the names of the extension members aren't imported into scope for unqualified reference in code.

Methods with the same name imported from different types by different using static directives in the same compilation unit or namespace form a method group. Overload resolution within these method groups follows normal C# rules.

The following example uses the using static directive to make the static members of the Console, Math, and