De using
richtlijn
Met using
de instructie kunt u typen gebruiken die zijn gedefinieerd in een naamruimte zonder de volledig gekwalificeerde naamruimte van dat type op te geven. In de basisvorm importeert de using
richtlijn alle typen uit één naamruimte, zoals wordt weergegeven in het volgende voorbeeld:
using System.Text;
U kunt twee modifiers toepassen op een using
richtlijn:
- De
global
wijziging heeft hetzelfde effect als het toevoegen van dezelfdeusing
instructie aan elk bronbestand in uw project. - De
static
wijzigingsfunctie importeert destatic
leden en geneste typen van één type in plaats van alle typen in een naamruimte te importeren.
U kunt beide modifiers combineren om de statische leden van een type te importeren in alle bronbestanden in uw project.
U kunt ook een alias maken voor een naamruimte of een type met een aliasrichtlijn.
using Project = PC.MyCompany.Project;
U kunt de global
wijzigingsfunctie gebruiken voor een aliasrichtlijn.
Notitie
Het using
trefwoord wordt ook gebruikt om instructiesusing
, zodat IDisposable objecten zoals bestanden en lettertypen correct worden verwerkt. Zie de instructie voor meer informatie over de using
instructieusing
.
Het bereik van een using
richtlijn zonder de global
modifier is het bestand waarin deze wordt weergegeven.
De global using
instructie moet worden weergegeven vóór alle naamruimte- en typedeclaraties. Alle globale gebruiksrichtlijnen moeten worden weergegeven in een bronbestand voor alle niet-globale using
instructies.
Andere using
instructies kunnen worden weergegeven:
- Aan het begin van een broncodebestand, vóór een naamruimte of typedeclaraties.
- In een naamruimte met geblokkeerd bereik, maar vóór eventuele naamruimten of typen die in die naamruimte zijn gedeclareerd.
Anders wordt er een compilerfout gegenereerd.
Maak een using
instructie voor het gebruik van de typen in een naamruimte zonder dat u de naamruimte hoeft op te geven. Een using
instructie geeft u geen toegang tot naamruimten die zijn genest in de naamruimte die u opgeeft. Naamruimten zijn beschikbaar in twee categorieën: door de gebruiker gedefinieerd en door het systeem gedefinieerd. Door de gebruiker gedefinieerde naamruimten zijn naamruimten die zijn gedefinieerd in uw code. Zie .NET API Browser voor een lijst met door het systeem gedefinieerde naamruimten.
De global
wijzigingsfunctie
Als u de global
modifier toevoegt aan een using
-instructie, betekent dit dat het gebruik wordt toegepast op alle bestanden in de compilatie (meestal een project):
global using <fully-qualified-namespace>;
Waar fully-qualified-namespace de volledig gekwalificeerde naam is van de naamruimte waarvan naar de typen kan worden verwezen zonder de naamruimte op te geven.
Aan het begin van een broncodebestand kan een globale using-instructie worden weergegeven. Alle global using
instructies in één bestand moeten eerder worden weergegeven:
- Alle
using
instructies zonder deglobal
wijzigingsfunctie. - Alle naamruimte- en typedeclaraties in het bestand.
U kunt instructies toevoegen global using
aan elk bronbestand. Normaal gesproken wilt u ze op één locatie bewaren. De volgorde van global using
richtlijnen maakt niet uit, in één bestand of tussen bestanden.
De global
modifier kan worden gecombineerd met de static
modifier. De global
wijzigingsfunctie kan worden toegepast op een aliasrichtlijn. In beide gevallen is het toepassingsgebied van de richtlijn alle bestanden in de huidige compilatie. In het volgende voorbeeld kunt u alle methoden gebruiken die zijn gedeclareerd in alle System.Math bestanden in uw project:
global using static System.Math;
U kunt ook globaal een naamruimte opnemen door een <Using>
item toe te voegen aan uw projectbestand, bijvoorbeeld <Using Include="My.Awesome.Namespace" />
. Zie het item<Using>
Analyseproblemen geven diagnostische gegevens als u dubbele global
instructies op verschillende locaties gebruikt. Deze zelfde analyses informeren u ook als u een using
instructie toevoegt voor een naamruimte of type dat een global
using-instructie al verwijst. Het is misschien gemakkelijker om uw global
gebruik te beheren door ze samen te houden in één bestand in het project.
Belangrijk
De C#-sjablonen voor .NET 6 gebruiken instructies op het hoogste niveau. Uw toepassing komt mogelijk niet overeen met de code in dit artikel als u al een upgrade naar .NET 6 hebt uitgevoerd. Zie het artikel over nieuwe C#-sjablonen voor het genereren van instructies op het hoogste niveau
De .NET 6 SDK voegt ook een reeks implicieteglobal using
de volgende SDK's:
- Microsoft.NET.Sdk
- Microsoft.NET.Sdk.Web
- Microsoft.NET.Sdk.Worker
Deze impliciete global using
instructies bevatten de meest voorkomende naamruimten voor het projecttype.
Zie het artikel over impliciete gebruiksrichtlijnen voor meer informatie
De static
wijzigingsfunctie
De using static
instructie noemt een type waarvan de statische leden en geneste typen die u kunt openen zonder een typenaam op te geven. De syntaxis is:
using static <fully-qualified-type-name>;
Dit <fully-qualified-type-name>
is de naam van het type waarvan naar statische leden en geneste typen kan worden verwezen zonder een typenaam op te geven. Als u geen volledig gekwalificeerde typenaam opgeeft (de volledige naamruimtenaam samen met de naam van het type), genereert C# compilerfout CS0246: 'Het type of de naamruimtenaam 'type/naamruimte' is niet gevonden (ontbreekt er een using-instructie of een assembly-verwijzing?)'.
De using static
richtlijn is van toepassing op elk type dat statische leden (of geneste typen) heeft, zelfs als deze ook instantieleden heeft. Exemplaarleden kunnen echter alleen worden aangeroepen via het typeexemplaren.
U kunt statische leden van een type openen zonder dat u de toegang moet kwalificeren met de typenaam:
using static System.Console;
using static System.Math;
class Program
{
static void Main()
{
WriteLine(Sqrt(3*3 + 4*4));
}
}
Normaal gesproken geeft u, wanneer u een statisch lid aanroept, de typenaam op samen met de lidnaam. Als u herhaaldelijk dezelfde typenaam invoert om leden van het type aan te roepen, kan dit leiden tot uitgebreide, verborgen code. De volgende definitie van een Circle
klasse verwijst bijvoorbeeld naar veel leden van de Math klasse.
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); }
}
}
Door de noodzaak om telkens wanneer naar een lid wordt verwezen expliciet naar de Math klasse te verwijzen, produceert de using static
richtlijn schonere code:
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
importeert alleen toegankelijke statische leden en geneste typen die zijn gedeclareerd in het opgegeven type. Overgenomen leden worden niet geïmporteerd. U kunt importeren uit elk benoemd type met een using static
instructie, inclusief Visual Basic-modules. Als F#-functies op het hoogste niveau in metagegevens worden weergegeven als statische leden van een benoemd type waarvan de naam een geldige C#-id is, kunnen de F#-functies worden geïmporteerd.
using static
maakt extensiemethoden die zijn gedeclareerd in het opgegeven type beschikbaar voor het opzoeken van extensiemethoden. De namen van de extensiemethoden worden echter niet geïmporteerd in het bereik voor niet-gekwalificeerde verwijzing in code.
Methoden met dezelfde naam die zijn geïmporteerd uit verschillende typen door verschillende using static
instructies in dezelfde compilatie-eenheid of naamruimte vormen een methodegroep. Overbelastingsresolutie binnen deze methodegroepen volgt normale C#-regels.
In het volgende voorbeeld wordt de using static
instructie gebruikt om de statische leden van de Console, Mathen String klassen beschikbaar te maken zonder hun typenaam op te geven.
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
In het voorbeeld kan de using static
richtlijn ook worden toegepast op het Double type. Door deze instructie toe te voegen, zou het mogelijk zijn om de TryParse(String, Double) methode aan te roepen zonder een typenaam op te geven. Als u echter zonder een typenaam gebruikt, TryParse
wordt er minder leesbare code gemaakt, omdat het nodig is om de using static
instructies te controleren om te bepalen welke methode van TryParse
het numerieke type wordt aangeroepen.
using static
is ook van toepassing op enum
typen. Door het toevoegen using static
met de enum is het type niet meer vereist om de enum-leden te gebruiken.
using static Color;
enum Color
{
Red,
Green,
Blue
}
class Program
{
public static void Main()
{
Color color = Green;
}
}
De using
alias
Maak een using
aliasrichtlijn om het gemakkelijker te maken om een id te kwalificeren voor een naamruimte of type. In elke using
richtlijn moet de volledig gekwalificeerde naamruimte of het type worden gebruikt, ongeacht de using
instructies die daarvoor worden gegeven. Er kan geen using
alias worden gebruikt in de verklaring van een using
richtlijn. In het volgende voorbeeld wordt bijvoorbeeld een compilerfout gegenereerd:
using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.
In het volgende voorbeeld ziet u hoe u een using
alias definieert en gebruikt voor een naamruimte:
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 { }
}
}
}
Een using alias directive kan geen open algemeen type aan de rechterkant hebben. U kunt bijvoorbeeld geen using-alias voor een List<T>
maken, maar u kunt er een voor een List<int>
maken.
In het volgende voorbeeld ziet u hoe u een using
instructie en een using
alias voor een klasse definieert:
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.
Vanaf C# 12 kunt u aliassen maken voor typen die eerder zijn beperkt, waaronder tupletypen, aanwijzertypen en andere onveilige typen. Zie de functiespecificatie voor meer informatie over de bijgewerkte regels.
Lid van gekwalificeerde alias
De aliaskwalificatie van de naamruimte biedt ::
expliciete toegang tot de globale naamruimte of andere met aliassen die mogelijk worden verborgen door andere entiteiten.
Het global::
zorgt ervoor dat de naamruimtezoekactie voor de naamruimte na het ::
token relatief is ten opzichte van de globale naamruimte. Anders moet het token worden omgezet in een using-alias en het token dat volgt ::
, moet worden omgezet in een type in die aliasnaamruimte. In het volgende voorbeeld ziet u beide formulieren:
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#-taalspecificatie
Zie Instructies gebruiken in de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.
Voor meer informatie over de globale met behulp van de-modificator, zie de specificatie van de globale usings-functie .