De `using` richtlijn

Artikel
01/27/2025

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 dezelfde using instructie aan elk bronbestand in uw project.
De static wijzigingsfunctie importeert de static 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 de global 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 usingde 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 .

Delen via

De `using` richtlijn

De `global` wijzigingsfunctie

De `static` wijzigingsfunctie

De `using` alias

Lid van gekwalificeerde alias

C#-taalspecificatie

Zie ook

Aanvullende resources

Delen via

De using richtlijn

De global wijzigingsfunctie

De static wijzigingsfunctie

De using alias

Lid van gekwalificeerde alias

C#-taalspecificatie

Zie ook

Aanvullende resources

De `using` richtlijn

De `global` wijzigingsfunctie

De `static` wijzigingsfunctie

De `using` alias