Dyrektywa `using`

Artykuł
11/24/2024

Dyrektywa using umożliwia używanie typów zdefiniowanych w przestrzeni nazw bez określania w pełni kwalifikowanej przestrzeni nazw tego typu. W jej podstawowej formie using dyrektywa importuje wszystkie typy z jednej przestrzeni nazw, jak pokazano w poniższym przykładzie:

using System.Text;

Do dyrektywy można zastosować dwa modyfikatory using :

Modyfikator global ma taki sam efekt jak dodanie tej samej using dyrektywy do każdego pliku źródłowego w projekcie.
Modyfikator static importuje static elementy członkowskie i typy zagnieżdżone z pojedynczego typu zamiast importować wszystkie typy w przestrzeni nazw.

Oba modyfikatory można połączyć, aby zaimportować statyczne elementy członkowskie z typu do wszystkich plików źródłowych w projekcie.

Możesz również utworzyć alias dla przestrzeni nazw lub typu z dyrektywą aliasu.

using Project = PC.MyCompany.Project;

Modyfikator można użyć global w dyrektywie aliasu.

Uwaga

Słowo using kluczowe jest również używane do tworzenia using instrukcji, co pomaga zapewnić IDisposable prawidłowe obsługę obiektów, takich jak pliki i czcionki. Aby uzyskać więcej informacji na temat instrukcjiusing, zobacz using instrukcję.

Zakres using dyrektywy bez global modyfikatora to plik, w którym się pojawia.

Dyrektywa global using musi pojawić się przed wszystkimi przestrzeniami nazw i deklaracjami typów. Wszystkie globalne dyrektywy dotyczące używania muszą znajdować się w pliku źródłowym przed wszelkimi dyrektywami nieglobali using .

Inne using dyrektywy mogą być wyświetlane:

Na początku pliku kodu źródłowego przed wszelkimi deklaracjami przestrzeni nazw lub typów.
W dowolnej przestrzeni nazw o zablokowanym zakresie, ale przed wszelkimi przestrzeniami nazw lub typami zadeklarowanym w tej przestrzeni nazw.

W przeciwnym razie jest generowany błąd kompilatora.

Utwórz dyrektywę using , aby używać typów w przestrzeni nazw bez konieczności określania przestrzeni nazw. using Dyrektywa nie zapewnia dostępu do żadnych przestrzeni nazw, które są zagnieżdżone w określonej przestrzeni nazw. Przestrzenie nazw są dostępne w dwóch kategoriach: zdefiniowanych przez użytkownika i zdefiniowanych przez system. Przestrzenie nazw zdefiniowane przez użytkownika to przestrzenie nazw zdefiniowane w kodzie. Aby uzyskać listę przestrzeni nazw zdefiniowanych przez system, zobacz Przeglądarka interfejsów API platformy .NET.

`global` Modyfikator

Dodanie modyfikatora global do dyrektywy using oznacza, że użycie jest stosowane do wszystkich plików w kompilacji (zazwyczaj projekt):

global using <fully-qualified-namespace>;

Gdzie w pełni kwalifikowana przestrzeń nazw jest w pełni kwalifikowaną nazwą przestrzeni nazw, do której można się odwoływać bez określania przestrzeni nazw.

Globalna dyrektywa using może pojawić się na początku dowolnego pliku kodu źródłowego. Wszystkie global using dyrektywy w jednym pliku muszą występować przed:

Wszystkie using dyrektywy bez global modyfikatora.
Wszystkie deklaracje przestrzeni nazw i typów w pliku.

Można dodawać global using dyrektywy do dowolnego pliku źródłowego. Zazwyczaj chcesz zachować je w jednej lokalizacji. Kolejność global using dyrektyw nie ma znaczenia, ani w jednym pliku, ani między plikami.

global Modyfikator można połączyć z modyfikatoremstatic. Modyfikator global można zastosować do dyrektywy aliasu. W obu przypadkach zakres dyrektywy to wszystkie pliki w bieżącej kompilacji. Poniższy przykład umożliwia używanie wszystkich metod zadeklarowanych we System.Math wszystkich plikach w projekcie:

global using static System.Math;

Możesz również globalnie uwzględnić przestrzeń nazw, dodając <Using> element do pliku projektu, na przykład <Using Include="My.Awesome.Namespace" />. Aby uzyskać więcej informacji, zobacz <Using> element.

Analizatory wystawiają diagnostykę, jeśli zduplikujesz global dyrektywy w różnych lokalizacjach. Te same analizatory informują również o dodaniu using dyrektywy dla przestrzeni nazw lub typu, do której global już odwołuje się dyrektywa using. Zarządzanie przy użyciu może być łatwiejsze global dzięki przechowywaniu ich razem w jednym pliku w projekcie.

Ważne

Szablony języka C# dla platformy .NET 6 używają instrukcji najwyższego poziomu. Aplikacja może nie być zgodna z kodem w tym artykule, jeśli został już uaktualniony do platformy .NET 6. Aby uzyskać więcej informacji, zobacz artykuł dotyczący nowych szablonów języka C# generowania instrukcji najwyższego poziomu

Zestaw SDK platformy .NET 6 dodaje również zestaw niejawnych global using dyrektyw dla projektów korzystających z następujących zestawów SDK:

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

Te niejawne global using dyrektywy obejmują najbardziej typowe przestrzenie nazw dla typu projektu.

Aby uzyskać więcej informacji, zobacz artykuł dotyczący niejawnych dyrektyw using

`static` Modyfikator

Dyrektywa using static nazywa typ, do którego statyczne elementy członkowskie i typy zagnieżdżone można uzyskać dostęp bez określania nazwy typu. Jego składnia to:

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

Jest <fully-qualified-type-name> to nazwa typu, do którego można odwoływać się statyczne elementy członkowskie i typy zagnieżdżone bez określania nazwy typu. Jeśli nie podasz w pełni kwalifikowanej nazwy typu (pełnej nazwy przestrzeni nazw wraz z nazwą typu), język C# generuje błąd kompilatora CS0246: "Nie można odnaleźć nazwy typu lub przestrzeni nazw "type/namespace" (czy brakuje dyrektywy using lub odwołania do zestawu?)".

Dyrektywa using static ma zastosowanie do dowolnego typu, który ma statyczne elementy członkowskie (lub typy zagnieżdżone), nawet jeśli ma również elementy członkowskie wystąpienia. Jednak elementy członkowskie wystąpień mogą być wywoływane tylko za pośrednictwem wystąpienia typu.

Dostęp do statycznych elementów członkowskich typu można uzyskać bez konieczności kwalifikowania dostępu przy użyciu nazwy typu:

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

Zazwyczaj podczas wywoływania statycznego elementu członkowskiego należy podać nazwę typu wraz z nazwą elementu członkowskiego. Wielokrotne wprowadzanie tej samej nazwy typu w celu wywołania elementów członkowskich typu może spowodować pełne, niejasne kod. Na przykład poniższa definicja Circle klasy odwołuje się do wielu elementów członkowskich Math klasy.

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

Eliminując konieczność jawnego Math odwołowania się do klasy za każdym razem, gdy element członkowski jest przywoływał, using static dyrektywa tworzy czystszy kod:

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 tylko dostępne statyczne elementy członkowskie i zagnieżdżone typy zadeklarowane w określonym typie. Dziedziczone elementy członkowskie nie są importowane. Można importować z dowolnego nazwanego typu z dyrektywą using static , w tym modułami języka Visual Basic. Jeśli funkcje najwyższego poziomu języka F# są wyświetlane w metadanych jako statyczne elementy członkowskie nazwanego typu, którego nazwa jest prawidłowym identyfikatorem języka C#, można zaimportować funkcje języka F#.

using static udostępnia metody rozszerzenia zadeklarowane w określonym typie dla wyszukiwania metody rozszerzenia. Jednak nazwy metod rozszerzenia nie są importowane do zakresu niekwalifikowanego odwołania w kodzie.

Metody o tej samej nazwie importowane z różnych typów przez różne using static dyrektywy w tej samej jednostce kompilacji lub przestrzeni nazw tworzą grupę metod. Rozpoznawanie przeciążenia w tych grupach metod jest zgodne z normalnymi regułami języka C#.

W poniższym przykładzie użyto using static dyrektywy , aby statyczne elementy członkowskie Consoleklas , Mathi String bez konieczności określania ich nazwy 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

W tym przykładzie using static można również zastosować dyrektywę Double do typu. Dodanie tej dyrektywy umożliwi wywołanie TryParse(String, Double) metody bez określenia nazwy typu. Jednak użycie TryParse bez nazwy typu powoduje utworzenie mniej czytelnego kodu, ponieważ konieczne jest sprawdzenie using static dyrektyw w celu określenia, która metoda typu liczbowego jest wywoływana TryParse .

using static dotyczy enum również typów. using static Dodając przy użyciu wyliczenia, typ nie jest już wymagany do używania składowych wyliczenia.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

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

Alias `using`

Utwórz dyrektywę using aliasu, aby ułatwić kwalifikację identyfikatora do przestrzeni nazw lub typu. W każdej using dyrektywie należy używać w pełni kwalifikowanej przestrzeni nazw lub typu niezależnie od using dyrektyw, które są przed nią dostępne. W deklaracji dyrektywy nie using można używać aliasu using . Na przykład poniższy przykład generuje błąd kompilatora:

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

W poniższym przykładzie pokazano, jak zdefiniować i użyć using aliasu dla przestrzeni nazw:

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 { }
        }
    }
}

Dyrektywa using alias nie może mieć otwartego typu ogólnego po prawej stronie. Na przykład nie można utworzyć aliasu dla elementu List<T>, ale można go utworzyć dla elementu List<int>.

W poniższym przykładzie pokazano, jak zdefiniować dyrektywę using i using alias dla klasy:

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.

Począwszy od języka C# 12, można tworzyć aliasy dla typów, które były wcześniej ograniczone, w tym typy krotki, typy wskaźników i inne niebezpieczne typy. Aby uzyskać więcej informacji na temat zaktualizowanych reguł, zobacz specyfikację funkcji.

Kwalifikowany element członkowski aliasu

Kwalifikator :: aliasu przestrzeni nazw zapewnia jawny dostęp do globalnej przestrzeni nazw lub innego przy użyciu aliasów potencjalnie ukrytych przez inne jednostki.

Zapewnia global:: , że wyszukiwanie przestrzeni nazw dla przestrzeni nazw po :: tokenie jest względem globalnej przestrzeni nazw. W przeciwnym razie token musi zostać rozpoznany jako używający aliasu, a następujący token :: musi zostać rozpoznany jako typ w tej aliasowanej przestrzeni nazw. W poniższym przykładzie przedstawiono obie formy:

using S = System.Net.Sockets;

class A
{
    public static int x;
}

class C
{
    public void F(int A, object S)
    {
        // Use global::A.x instead of A.x
        global::A.x += A;

        // Using ::, S must resolve to a namespace alias:
        S::Socket s = S as S::Socket;

        // In this form, if S were a class, it would be a compile-time error:
        S.Socket s1 = S as S.Socket;
    }
}

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Using directives in the C# Language Specification (Używanie dyrektyw w specyfikacji języka C#). Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.

Aby uzyskać więcej informacji na temat globalnego używania z modyfikatorem, zobacz specyfikację funkcji globalnych użyć .

Udostępnij za pośrednictwem

Dyrektywa `using`

`global` Modyfikator

`static` Modyfikator

Alias `using`

Kwalifikowany element członkowski aliasu

specyfikacja języka C#

Zobacz też

Dodatkowe zasoby

Udostępnij za pośrednictwem

Dyrektywa using

global Modyfikator

static Modyfikator

Alias using

Kwalifikowany element członkowski aliasu

specyfikacja języka C#

Zobacz też

Dodatkowe zasoby

Dyrektywa `using`

`global` Modyfikator

`static` Modyfikator

Alias `using`