using, dyrektywa

Artykuł
04/25/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. Ten modyfikator został wprowadzony w języku C# 10.
Modyfikator static importuje static elementy członkowskie i typy zagnieżdżone z pojedynczego typu zamiast importować wszystkie typy w przestrzeni nazw.

Można połączyć obie modyfikatory, aby zaimportować statyczne elementy członkowskie z typu we wszystkich plikach ź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 instrukcji using, co pomaga zapewnić IDisposable prawidłowe obsługę obiektów, takich jak pliki i czcionki. Aby uzyskać więcej informacji na temat instrukcji using, zobacz using, instrukcja.

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

Dyrektywa using może pojawić się:

Na początku pliku kodu źródłowego przed wszelkimi deklaracjami przestrzeni nazw lub typów.
W dowolnej przestrzeni nazw, ale przed wszelkimi przestrzeniami nazw lub typami zadeklarowanych w tej przestrzeni nazw, chyba że global modyfikator jest używany, w takim przypadku dyrektywa musi pojawić się przed wszystkimi przestrzeniami nazw i deklaracjami typów.

W przeciwnym razie jest generowany błąd kompilatora CS1529 .

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.

modyfikator globalny

global Dodanie modyfikatora do using dyrektywy oznacza, że użycie jest stosowane do wszystkich plików w kompilacji (zazwyczaj projekt). Dyrektywa global using została dodana w języku C# 10. Jego składnia to:

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żesz dodać global using dyrektywy do dowolnego pliku źródłowego. Zazwyczaj należy zachować je w jednej lokalizacji. Kolejność global using dyrektyw nie ma znaczenia, ani w jednym pliku, ani między plikami.

global Modyfikator może być połączony z modyfikatoremstatic. Modyfikator global może być stosowany do dyrektywy aliasu using. 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.

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

modyfikator statyczny

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 dyrektywa mogła zostać również zastosowana do Double 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;
    }
}

używanie aliasu

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.

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 modyfikatora globalnego , zobacz globalną specyfikację funkcji usings — C# 10.

using, dyrektywa

modyfikator globalny

modyfikator statyczny

używanie aliasu

specyfikacja języka C#

Zobacz też

Opinia

Dodatkowe zasoby