Az `using` irányelv

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.
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ába.

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ásokusing is használják, amelyek segítenek biztosítani, hogy IDisposable az objektumok, például a fájlok és a betűtípusok megfelelően legyenek kezelve. Az utasítással kapcsolatos további információkért lásd using

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

Az global using irányelvnek minden névtér- és típusdeklaráció előtt meg kell jelennie. Minden globális használó direktívának meg kell jelennie egy forrásfájlban a nemglobál using irányelvek előtt.

Egyéb using irányelvek is megjelenhetnek:

A forráskódfájl elején, névtér- vagy típusdeklarációk előtt.
Bármely tiltott hatókörű névtérben, de a névtérben deklarált névterek vagy típusok előtt.

Ellenkező esetben fordítóhiba jön létre.

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.

A `global` módosító

A global módosító hozzáadása egy using irányelvhez azt jelenti, hogy a használat a fordításban lévő összes fájlra (általában egy projektre) vonatkozik:

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ármilyen forrásfájlhoz hozzáadhat global using irányelveket. Általában egy helyen szeretné őket tárolni. 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ó alias-direktívára 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.

Az elemzők diagnosztikát adnak, ha eltérő helyeken lévő irányelvek használatával duplikál global . Ugyanezek az elemzők azt is tájékoztatják, ha olyan névtérhez vagy típushoz ad hozzá using direktívát, amelyekre az global irányelv már hivatkozik. Egyszerűbben kezelheti a global használatot úgy, hogy egy fájlban tartja őket a projektben.

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 implicitis 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

A `static` 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:

// not within a namespace
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?)".

Ha az using static irányelvet egy névtér kontextusában alkalmazzák (fájlhatókörrel vagy blokkba namespace ágyazva), nem szükséges teljes mértékben minősíteni a típust.

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énytagokat elérhetővé teszi a bővítménytagok kereséséhez. A bővítménytagok 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 , Consoleés Math osztály Stringstatikus 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 a típusra Double is alkalmazható. 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;
    }
}

Az `using` alias

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.

Minősített aliastag

A névtér alias-minősítője :: explicit hozzáférést biztosít a globális névtérhez vagy más, más entitások által esetleg rejtett aliasok használatával.

Ez global:: biztosítja, hogy a jogkivonatot követő :: névtér keresése a globális névtérhez képest legyen. Ellenkező esetben a jogkivonatot alias használatával kell feloldani, az azt követő :: jogkivonatnak pedig az adott aliasnévtér egy típusára kell feloldania. Az alábbi példa mindkét űrlapot mutatja be:

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

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 direktívák módosítóval való használatával kapcsolatos további információkért tekintse meg a globális direktíva funkcióspecifikációját.

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-26

Megosztás a következőn keresztül:

Az using irányelv

A global módosító

A static módosító

Az using alias