Sdílet prostřednictvím


using – direktiva

Direktiva using umožňuje používat typy definované v oboru názvů bez zadání plně kvalifikovaného oboru názvů tohoto typu. V základní podobě direktiva using importuje všechny typy z jednoho oboru názvů, jak je znázorněno v následujícím příkladu:

using System.Text;

U direktivy můžete použít dva modifikátory using :

  • global Modifikátor má stejný účinek jako přidání stejné using direktivy ke každému zdrojovému souboru v projektu. Tento modifikátor byl zaveden v jazyce C# 10.
  • static Modifikátor importuje static členy a vnořené typy z jednoho typu místo importu všech typů v oboru názvů.

Oba modifikátory můžete zkombinovat pro import statických členů z typu ve všech zdrojových souborech v projektu.

Můžete také vytvořit alias pro obor názvů nebo typ s direktivou using alias.

using Project = PC.MyCompany.Project;

Modifikátor můžete použít global u direktivy using alias.

Poznámka:

Klíčové using slovo se také používá k vytváření using příkazů, které pomáhají zajistit správné IDisposable zpracování objektů, jako jsou soubory a písma. Další informace o using příkazu naleznete using v příkazu.

Obor using direktivy bez modifikátoru global je soubor, ve kterém se zobrazuje.

Direktiva using se může zobrazit:

  • Na začátku souboru zdrojového kódu před deklaracemi oboru názvů nebo typu.
  • V libovolném oboru názvů, ale před všemi obory názvů nebo typy deklarované v tomto oboru názvů, pokud global není použit modifikátor, v takovém případě se direktiva musí objevit před všemi deklaracemi oboru názvů a typů.

V opačném případě se vygeneruje chyba kompilátoru CS1529 .

Vytvořte direktivu using pro použití typů v oboru názvů, aniž byste museli určit obor názvů. Direktiva using neposkytuje přístup k žádným oborům názvů, které jsou vnořené do zadaného oboru názvů. Obory názvů mají dvě kategorie: uživatelem definované a definované systémem. Obory názvů definované uživatelem jsou obory názvů definované v kódu. Seznam systémově definovaných oborů názvů najdete v tématu Prohlížeč rozhraní .NET API.

globální modifikátor

Přidání modifikátoru globalusing do direktivy znamená, že použití se použije na všechny soubory v kompilaci (obvykle projekt). Direktiva global using byla přidána v jazyce C# 10. Jeho syntaxe je:

global using <fully-qualified-namespace>;

kde plně kvalifikovaný obor názvů je plně kvalifikovaný název oboru názvů, jehož typy lze odkazovat bez zadání oboru názvů.

Globální direktiva using se může objevit na začátku libovolného souboru zdrojového kódu. Všechny global using direktivy v jednom souboru musí být uvedeny před:

  • Všechny using direktivy bez modifikátoru global .
  • Všechny deklarace oboru názvů a typu v souboru.

Direktivy můžete přidat global using do libovolného zdrojového souboru. Obvykle je budete chtít uchovávat v jednom umístění. Pořadí global using direktiv nezáleží, buď v jednom souboru, nebo mezi soubory.

global Modifikátor lze kombinovat s modifikátoremstatic. Modifikátor global lze použít na direktivu using alias. V obou případech je obor direktivy všechny soubory v aktuální kompilaci. Následující příklad umožňuje používat všechny metody deklarované ve System.Math všech souborech v projektu:

global using static System.Math;

Obor názvů můžete také globálně zahrnout přidáním <Using> položky do souboru projektu, <Using Include="My.Awesome.Namespace" />například . Další informace najdete v <Using> položce.

Důležité

Šablony jazyka C# pro .NET 6 používají příkazy nejvyšší úrovně. Pokud jste už upgradovali na .NET 6, vaše aplikace nemusí odpovídat kódu v tomto článku. Další informace najdete v článku o generování příkazů nejvyšší úrovně v nových šablonách jazyka C#.

Sada .NET 6 SDK také přidá sadu implicitních global using direktiv pro projekty, které používají následující sady SDK:

  • Microsoft.NET.Sdk
  • Microsoft.NET.Sdk.Web
  • Microsoft.NET.Sdk.Worker

Tyto implicitní global using direktivy zahrnují nejběžnější obory názvů pro typ projektu.

Další informace najdete v článku o direktivách Implicit using

statický modifikátor

Direktiva using static pojmenuje typ, ke kterému mají statické členy a vnořené typy přístup bez zadání názvu typu. Jeho syntaxe je:

using static <fully-qualified-type-name>;

Jedná se <fully-qualified-type-name> o název typu, jehož statické členy a vnořené typy lze odkazovat bez zadání názvu typu. Pokud nezadáte plně kvalifikovaný název typu (úplný název oboru názvů spolu s názvem typu), jazyk C# vygeneruje chybu kompilátoru CS0246: Typ nebo název oboru názvů type nebo obor názvů nebyl nalezen (chybí direktiva using nebo odkaz na sestavení?).

Direktiva using static se vztahuje na jakýkoli typ, který má statické členy (nebo vnořené typy), i když má také členy instance. Členy instance však lze vyvolat pouze prostřednictvím instance typu.

Ke statickým členům typu můžete přistupovat bez nutnosti kvalifikovat přístup pomocí názvu typu:

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

Obvykle při volání statického člena zadáte název typu spolu s názvem člena. Opakované zadání stejného názvu typu pro vyvolání členů typu může vést k podrobnému, nejasného kódu. Například následující definice Circle třídy odkazuje na mnoho členů Math třídy.

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); }
   }
}

Díky vyloučení nutnosti explicitně odkazovat na Math třídu pokaždé, když je na člen odkazován, direktiva using static vytváří čistější kód:

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 importuje pouze přístupné statické členy a vnořené typy deklarované v zadaném typu. Zděděné členy se neimportují. Z libovolného pojmenovaného typu můžete importovat direktivu, včetně modulů jazyka using static Visual Basic. Pokud se funkce nejvyšší úrovně jazyka F# zobrazují v metadatech jako statické členy pojmenovaného typu, jejichž název je platný identifikátor jazyka C#, je možné importovat funkce jazyka F#.

using static zpřístupňuje rozšiřující metody deklarované v zadaném typu pro vyhledávání metody rozšíření. Názvy rozšiřujících metod se ale neimportují do oboru pro nekvalifikovaný odkaz v kódu.

Metody se stejným názvem importovanými z různých typů podle různých using static direktiv ve stejné jednotce kompilace nebo oboru názvů tvoří skupinu metod. Řešení přetížení v rámci těchto skupin metod se řídí normálními pravidly jazyka C#.

Následující příklad používá direktivu using static k tomu, aby statické členy Console, Matha String třídy k dispozici bez nutnosti zadat jejich typ název.

using System;
using static System.Console;
using static System.Math;
using static System.String;

class Program
{
   static void Main()
   {
      Write("Enter a circle's radius: ");
      var input = ReadLine();
      if (!IsNullOrEmpty(input) && double.TryParse(input, out var radius)) {
         var c = new Circle(radius);

         string s = "\nInformation about the circle:\n";
         s = s + Format("   Radius: {0:N2}\n", c.Radius);
         s = s + Format("   Diameter: {0:N2}\n", c.Diameter);
         s = s + Format("   Circumference: {0:N2}\n", c.Circumference);
         s = s + Format("   Area: {0:N2}\n", c.Area);
         WriteLine(s);
      }
      else {
         WriteLine("Invalid input...");
      }
   }
}

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); }
   }
}
// The example displays the following output:
//       Enter a circle's radius: 12.45
//
//       Information about the circle:
//          Radius: 12.45
//          Diameter: 24.90
//          Circumference: 78.23
//          Area: 486.95

V příkladu using static by direktiva mohla být použita i u Double typu. Přidáním této direktivy by bylo možné volat metodu TryParse(String, Double) bez zadání názvu typu. Použití TryParse bez názvu typu však vytváří méně čitelný kód, protože je nutné zkontrolovat direktivy using static určit, která metoda číselného TryParse typu je volána.

using static platí také pro enum typy. using static Přidáním se výčtem už typ nevyžaduje k použití členů výčtu.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

class Program
{
    public static void Main()
    {
        Color color = Green;
    }
}

using alias

Vytvořte direktivu aliasu using , která usnadňuje kvalifikaci identifikátoru na obor názvů nebo typ. V jakékoli using direktivě musí být použit plně kvalifikovaný obor názvů nebo typ bez using ohledu na direktivy, které před ní přicházejí. V deklaraci using direktivy nelze použít žádný using alias. Například následující příklad vygeneruje chybu kompilátoru:

using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.

Následující příklad ukazuje, jak definovat a používat using alias pro obor názvů:

namespace PC
{
    // Define an alias for the nested namespace.
    using Project = PC.MyCompany.Project;
    class A
    {
        void M()
        {
            // Use the alias
            var mc = new Project.MyClass();
        }
    }
    namespace MyCompany
    {
        namespace Project
        {
            public class MyClass { }
        }
    }
}

Direktiva using alias nemůže mít otevřený obecný typ na pravé straně. Například nemůžete vytvořit alias using pro a List<T>, ale můžete ho vytvořit pro .List<int>

Následující příklad ukazuje, jak definovat direktivu using a using alias pro třídu:

using System;

// Using alias directive for a class.
using AliasToMyClass = NameSpace1.MyClass;

// Using alias directive for a generic class.
using UsingAlias = NameSpace2.MyClass<int>;

namespace NameSpace1
{
    public class MyClass
    {
        public override string ToString()
        {
            return "You are in NameSpace1.MyClass.";
        }
    }
}

namespace NameSpace2
{
    class MyClass<T>
    {
        public override string ToString()
        {
            return "You are in NameSpace2.MyClass.";
        }
    }
}

namespace NameSpace3
{
    class MainClass
    {
        static void Main()
        {
            var instance1 = new AliasToMyClass();
            Console.WriteLine(instance1);

            var instance2 = new UsingAlias();
            Console.WriteLine(instance2);
        }
    }
}
// Output:
//    You are in NameSpace1.MyClass.
//    You are in NameSpace2.MyClass.

Počínaje jazykem C# 12 můžete vytvářet aliasy pro typy, které byly dříve omezeny, včetně typů řazené kolekce členů, typů ukazatelů a dalších nebezpečných typů. Další informace o aktualizovaných pravidlech najdete ve specifikaci funkce.

specifikace jazyka C#

Další informace naleznete v tématu Direktivy Using ve specifikaci jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.

Další informace o globálním použití modifikátoru najdete v globální specifikaci funkcí using – C# 10.

Viz také