az irányelv használata

Cikk
04/25/2024

Az using irányelv lehetővé teszi a névtérben definiált típusok használatát az adott típus teljes névterének megadása nélkül. Az irányelv alapszintű formájában using az összes típust egyetlen névtérből importálja, ahogyan az a következő példában is látható:

using System.Text;

Egy irányelvre using két módosító alkalmazható:

A global módosító hatása megegyezik azzal, hogy ugyanazt using az irányelvet adja hozzá a projekt minden forrásfájljához. Ez a módosító a C# 10-ben lett bevezetve.
A static módosító egyetlen típusból importálja a static tagokat és a beágyazott típusokat ahelyett, hogy egy névtérben lévő összes típust importálja.

Mindkét módosító kombinálásával importálhatja a statikus tagokat egy típusból a projekt összes forrásfájljában.

Aliast is létrehozhat névtérhez vagy olyan típushoz, amely alias-direktívával rendelkezik.

using Project = PC.MyCompany.Project;

A módosító alias-direktíván globalhasználható.

Feljegyzés

A using kulcsszót utasítások használatával is létrehozhatja, így biztosítható, hogy IDisposable az objektumok, például a fájlok és a betűtípusok megfelelően legyenek kezelve. A felhasználói utasítással kapcsolatos további információkért lásd az utasítás használatát ismertető témakört.

A módosító nélküli global irányelv hatóköre using az a fájl, amelyben megjelenik.

Az using irányelv a következő lehet:

A forráskódfájl elején, névtér- vagy típusdeklarációk előtt.
Bármely névtérben, de a névtérben deklarált névterek vagy típusok előtt, kivéve, ha a global módosító van használatban, ebben az esetben az irányelvnek minden névtér- és típusdeklaráció előtt meg kell jelennie.

Ellenkező esetben a rendszer cs1529-ös fordítási hibát generál.

Hozzon létre egy using irányelvet a névtér típusainak használatához anélkül, hogy meg kellene adnia a névteret. Az using irányelv nem biztosít hozzáférést a megadott névtérbe beágyazott névterekhez. A névterek két kategóriába sorolhatók: felhasználó által definiált és rendszer által definiált. A felhasználó által definiált névterek a kódban definiált névterek. A rendszer által definiált névterek listáját a .NET API Browserben találja.

globális módosító

global A módosító irányelvhez való using hozzáadása azt jelenti, hogy a használat a fordításban lévő összes fájlra (általában egy projektre) vonatkozik. Az global using irányelv a C# 10-ben lett hozzáadva. Szintaxisa:

global using <fully-qualified-namespace>;

ahol a teljes névtér annak a névtérnek a teljes neve, amelynek típusai a névtér megadása nélkül hivatkozhatók.

Bármely forráskódfájl elején megjelenhet egy globálisan használt irányelv. Az egyetlen fájlban lévő összes global using direktívának a következő előtt kell megjelennie:

Minden using irányelv módosító global nélkül.
A fájlban található összes névtér- és típusdeklaráció.

Bármely forrásfájlhoz hozzáadhat global using irányelveket. Általában egy helyen kell tartania őket. Az irányelvek sorrendje global using nem számít sem egyetlen fájlban, sem fájlok között.

A global módosító kombinálható a static módosítóval. A global módosító egy alias-irányelvre alkalmazható. Mindkét esetben az irányelv hatóköre az aktuális összeállítás összes fájlja. Az alábbi példa lehetővé teszi a projekt összes fájljában System.Math deklarált összes metódus használatát:

global using static System.Math;

A névteret globálisan is felveheti, ha például hozzáad egy <Using> elemet a projektfájlhoz. <Using Include="My.Awesome.Namespace" /> További információ: <Using> elem.

Fontos

A .NET 6 C#-sablonjai felső szintű utasításokat használnak. Előfordulhat, hogy az alkalmazás nem egyezik a cikkben szereplő kóddal, ha már frissített a .NET 6-ra. További információ: Az új C#- sablonok legfelső szintű utasítások létrehozása

A .NET 6 SDK emellett implicitglobal using irányelveket is hozzáad az alábbi SDK-t használó projektekhez:

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

Ezek az implicit global using irányelvek tartalmazzák a projekttípus leggyakoribb névtereit.

További információkért tekintse meg az implicit eszközökkel kapcsolatos irányelveket ismertető cikket

statikus módosító

Az using static irányelv egy olyan típust nevez el, amelynek statikus tagjai és beágyazott típusai a típusnév megadása nélkül érhetők el. Szintaxisa:

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

Annak <fully-qualified-type-name> a típusnak a neve, amelynek statikus tagjai és beágyazott típusai típusnév megadása nélkül hivatkozhatók. Ha nem ad meg teljes típusnevet (a teljes névtérnevet a típusnévvel együtt), a C# a CS0246 fordítói hibát generálja: "A típus vagy névtér neve nem található (hiányzik a használt irányelv vagy szerelvényhivatkozás?)".

Az using static irányelv minden olyan típusra vonatkozik, amely statikus tagokkal (vagy beágyazott típusokkal) rendelkezik, még akkor is, ha példánytagokkal is rendelkezik. A példánytagok azonban csak a típuspéldányon keresztül hívhatók meg.

A típus statikus tagjait anélkül érheti el, hogy a hozzáférést a típusnévvel kellene minősítenie:

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

Ha statikus tagot hív meg, általában a tag nevével együtt adja meg a típusnevet. Ha ismétlődően ugyanazt a típusnevet adja meg a típus tagjainak meghívásához, az részletes, homályos kódot eredményezhet. Egy osztály alábbi definíciója Circle például az Math osztály számos tagjára hivatkozik.

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

Az irányelv azáltal, hogy szükségtelenné teszi az osztály explicit hivatkozását minden Math alkalommal, amikor egy tagra hivatkoznak, az using static irányelv tisztább kódot hoz létre:

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 csak a megadott típusban deklarált akadálymentes statikus tagokat és beágyazott típusokat importálja. Az örökölt tagok nincsenek importálva. Bármely elnevezett típusból importálhat egy using static direktívát, beleértve a Visual Basic modulokat is. Ha az F# legfelső szintű függvények olyan elnevezett típus statikus tagjaiként jelennek meg a metaadatokban, amelynek a neve érvényes C# azonosító, akkor az F# függvények importálhatók.

using static a megadott típusban deklarált bővítménymetódusokat elérhetővé teszi a bővítménymetódus kereséséhez. A bővítménymetelyek nevei azonban nem importálhatók a kódban való nem minősített hivatkozás hatókörébe.

Az ugyanazon fordítási egységben vagy névtérben lévő különböző using static irányelvek által különböző típusokból importált azonos nevű metódusok metóduscsoportot alkotnak. Az ezekben a metóduscsoportokban a túlterhelés feloldása a normál C# szabályokat követi.

Az alábbi példa az using static irányelv használatával teszi elérhetővé a , Mathés String osztály Consolestatikus tagjait anélkül, hogy meg kellene adnia a típusnevüket.

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

A példában az using static irányelv is alkalmazható lett volna a Double típusra. Az irányelv hozzáadása lehetővé tenné a metódus meghívását típusnév TryParse(String, Double) megadása nélkül. A típusnév nélküli használat TryParse azonban kevésbé olvasható kódot hoz létre, mivel szükség lesz az irányelvek ellenőrzésére annak using static meghatározásához, hogy melyik numerikus típus metódusát TryParse hívják meg.

using static típusokra enum is vonatkozik. Az enumerálással történő hozzáadással using static a típus már nem szükséges a számtagok használatához.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

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

alias használata

Hozzon létre egy using alias-direktívát, amely megkönnyíti az azonosítók névtérre vagy típusba való minősítését. Bármely using irányelvben a teljes névteret vagy -típust az előtte lévő irányelvektől függetlenül using kell használni. Az irányelv deklarációjában using nem using használható alias. Az alábbi példa például fordítóhibát okoz:

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

Az alábbi példa bemutatja, hogyan definiálhat és használhat aliast using egy névtérhez:

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

Egy alias-direktíva nem rendelkezhet nyílt általános típussal a jobb oldalon. Például nem hozhat létre aliast egy adotthozList<T>, de létrehozhat egyet.List<int>

Az alábbi példa bemutatja, hogyan definiálhat egy irányelvet using és egy using aliast egy osztályhoz:

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.

A C# 12-től kezdve létrehozhat aliasokat a korábban korlátozott típusokhoz, beleértve a rekordtípusokat, a mutatótípusokat és az egyéb nem biztonságos típusokat. A frissített szabályokkal kapcsolatos további információkért tekintse meg a funkció specifikációját.

C# nyelvspecifikáció

További információ: Irányelvek használata a C# nyelvspecifikációjában. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.

A globális módosító használatával kapcsolatos további információkért tekintse meg a globális usings funkció specifikációját – C# 10.

Share via

az irányelv használata

globális módosító

statikus módosító

alias használata

C# nyelvspecifikáció

Lásd még

Visszajelzés

További források