using directive

Artikel
04/25/2024

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. Deze wijzigingsfunctie is geïntroduceerd in C# 10.
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 te importeren uit een type 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 voor het maken van instructies, waarmee u ervoor kunt zorgen dat IDisposable objecten zoals bestanden en lettertypen correct worden verwerkt. Zie de using-instructie voor meer informatie over de using-instructie.

Het bereik van een using richtlijn zonder de global modifier is het bestand waarin deze wordt weergegeven.

De using richtlijn kan worden weergegeven:

Aan het begin van een broncodebestand, vóór een naamruimte of typedeclaraties.
In elke naamruimte, maar vóór eventuele naamruimten of typen die in die naamruimte zijn gedeclareerd, tenzij de global wijzigingsfunctie wordt gebruikt, moet de instructie worden weergegeven vóór alle naamruimte- en typedeclaraties.

Anders wordt de compilerfout CS1529 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.

globale aanpassing

Het toevoegen van de global modifier aan een using richtlijn betekent dat het gebruik wordt toegepast op alle bestanden in de compilatie (meestal een project). De global using richtlijn is toegevoegd in C# 10. De syntaxis is:

global using <fully-qualified-namespace>;

waarbij volledig gekwalificeerde naamruimte 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 using-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 voor meer informatie.<Using>

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 instructies toe voor projecten die gebruikmaken van 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

statische wijziging

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 op het Double type zijn toegepast. 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;
    }
}

alias gebruiken

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.

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.

Zie de algemene functiespecificatie voor algemene gebruiksfuncties - C# 10 voor meer informatie over de algemene functiespecificatie.

using directive

globale aanpassing

statische wijziging

alias gebruiken

C#-taalspecificatie

Zie ook

Feedback

Aanvullende resources