using – direktiva

usingDirektiva umožňuje používat typy definované v oboru názvů bez určení plně kvalifikovaného oboru názvů tohoto typu. V základním formuláři using direktiva 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 :

• globalModifikátor má stejný účinek jako přidání stejné using direktivy do každého zdrojového souboru v projektu. Tento modifikátor byl představen v C# 10.
• staticModifikátor importuje static členy a vnořené typy z jednoho typu namísto importu všech typů v oboru názvů. Tento modifikátor byl představen v C# 6,0.

Oba modifikátory lze kombinovat 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;

Můžete použít global Modifikátor na direktivu using alias.

Rozsah using direktivy bez global modifikátoru je soubor, ve kterém se zobrazí.

Tato using direktiva se může zobrazit:

• Na začátku souboru zdrojového kódu před libovolným oborem názvů nebo deklarací typu.
• V jakémkoli oboru názvů, ale před všemi obory názvů nebo typy deklarovanými v tomto oboru názvů, pokud se global nepoužívá modifikátor, v takovém případě musí být direktiva uvedena před všemi deklaracemi oboru názvů a typu.

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

Vytvořte using direktivu pro použití typů v oboru názvů bez nutnosti zadat obor názvů. usingDirektiva neposkytuje přístup k žádným oborům názvů, které jsou vnořené v oboru názvů, který zadáte. Obory názvů přicházejí ve dvou kategoriích: definované uživatelem a systémem. Uživatelsky definované obory názvů jsou obory názvů definované ve vašem kódu. Seznam oborů názvů definovaných systémem naleznete v tématu .NET API Browser.

globální modifikátor

Přidání global modifikátoru do using direktivy znamená, že použití je použito na všechny soubory v kompilaci (obvykle projekt). global usingDirektiva byla přidána v 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 určení 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 se musí vyskytovat před:

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

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

globalModifikátor může být kombinován s static modifikátorem. globalModifikátor může být použit na direktivu using alias. V obou případech je rozsahem direktivy všechny soubory v aktuální kompilaci. Následující příklad umožňuje použití všech metod deklarovaných ve System.Math všech souborech v projektu:

global using static System.Math;

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

statický modifikátor

using staticDirektiva pojmenovává typ, jehož statické členy a vnořené typy mají přístup bez zadání názvu typu. using staticDirektiva byla představena v C# 6. Jeho syntaxe je:

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

<fully-qualified-type-name>Je název typu, jehož statické členy a vnořené typy mohou být odkazovány 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), C# generuje chybu kompilátoru CS0246: "typ nebo obor názvů ' Type/namespace ' se nepodařilo najít (nechybí Direktiva using nebo odkaz na sestavení?)".

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

Můžete přistupovat ke statickým členům typu bez nutnosti kvalifikovat přístup s názvem 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 členu zadáte název typu společně s názvem člena. Opakované zadání stejného názvu typu pro vyvolání členů typu může mít za následek verbose, zakrytí 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); }
   }
}

Odstraněním nutnosti explicitního odkazování na Math třídu pokaždé, když na člena odkazuje, using static direktiva vytvoří čisticí 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 dostupné statické členy a vnořené typy deklarované v zadaném typu. Zděděné členy se neimportují. můžete importovat z libovolného pojmenovaného typu pomocí using static direktivy, včetně Visual Basicch modulů. Pokud jsou funkce nejvyšší úrovně F # zobrazeny v metadatech jako statické členy pojmenovaného typu, jehož název je platný identifikátor jazyka C#, mohou být importovány funkce jazyka F #.

using static Zpřístupňuje metody rozšíření deklarované v zadaném typu k dispozici pro vyhledávání rozšiřující metody. Názvy metod rozšíření však nejsou importovány do oboru pro nekvalifikované odkazy v kódu.

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

V následujícím příkladu je použita using static direktiva k tomu, aby byly statické Console členy Math tříd, a String dostupné bez nutnosti zadat jejich název typu.

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 tomto příkladu using static byla direktiva také použita pro Double typ. Přidáním této direktivy by bylo možné volat TryParse(String, Double) metodu bez zadání názvu typu. Nicméně použití TryParse bez názvu typu vytvoří méně čitelný kód, protože je nutné ověřit using static direktivy, abyste zjistili, která metoda číselného typu TryParse je volána.

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

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

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

alias using

Vytvořte using direktivu alias pro snadnější zařazení identifikátoru do oboru názvů nebo typu. V jakékoli using direktivě musí být plně kvalifikovaný obor názvů nebo typ použit bez ohledu na using direktivy, které jsou před ním. usingV deklaraci direktivy nelze použít žádný alias using . 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žít 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 na pravé straně otevřený obecný typ. Například nemůžete vytvořit alias s aliasem pro List<T> , ale můžete ho vytvořit pro List<int> .

Následující příklad ukazuje, jak definovat using direktivu 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.

jak používat Visual Basic My obor názvů

Microsoft.VisualBasic.MyServicesobor názvů ( My v Visual Basic) poskytuje snadný a intuitivní přístup k několika třídám .net a umožňuje psát kód, který komunikuje s počítačem, aplikací, nastavením, prostředky a tak dále. i když je původně určený pro použití s Visual Basic, MyServices obor názvů lze použít v aplikacích C#.

další informace o používání MyServices oboru názvů z Visual Basic naleznete v tématu vývoj s My.

Musíte přidat odkaz na Microsoft.VisualBasic.dll sestavení v projektu. Ne všechny třídy v MyServices oboru názvů mohou být volány z aplikace jazyka C#: například FileSystemProxy třída není kompatibilní. V tomto konkrétním případě lze místo toho použít statické metody, které jsou součástí FileSystem , které jsou také obsaženy v VisualBasic.dll. Tady je příklad, jak použít jednu takovou metodu pro duplikaci adresáře:

// Duplicate a directory
Microsoft.VisualBasic.FileIO.FileSystem.CopyDirectory(
    @"C:\original_directory",
    @"C:\copy_of_original_directory");

specifikace jazyka C#

Další informace naleznete v tématu direktivy using v jazyce C# Specification. 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 naleznete v tématu specifikace funkcí Global using-C# 10.

Viz také

• Reference jazyka C#
• Průvodce programováním v C#
• Klíčová slova jazyka C#
• Obory názvů
• using – příkaz