az irányelv használata
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 ugyanaztusing
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 astatic
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 global
használható.
Feljegyzés
A using
kulcsszót utasítások létrehozására using
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
az using
utasítást.
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 implicit global 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.