Delen via

De using richtlijn

using Met 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.

De C#-taalreferentiedocumenten beschrijven de meest recent uitgebrachte versie van de C#-taal. Het bevat ook de eerste documentatie voor functies in openbare previews voor de aanstaande taalrelease.

De documentatie identificeert alle functies die voor het eerst zijn geïntroduceerd in de laatste drie versies van de taal of in de huidige openbare previews.

Aanbeveling

Raadpleeg het artikel over de versiegeschiedenis van de C#-taal om te achterhalen wanneer een functie voor het eerst is geïntroduceerd in C#.

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

Wanneer u de global wijzigingsfunctie aan een using instructie toevoegt, past u het gebruik toe 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 u naar de typen kunt verwijzen 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 houdt u ze op één locatie. De volgorde van global using de richtlijnen maakt niet uit, hetzij in één bestand of tussen bestanden.

U kunt de global modifier combineren met de static modifier. U kunt de global wijzigingsfunctie toepassen 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<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 implicietede 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:

// not within a namespace
using static <fully-qualified-type-name>;

Dit <fully-qualified-type-name> is de naam van het type waarvan de statische leden en geneste typen waarnaar u kunt verwijzen 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?)'.

Als u de using static instructie toepast binnen de context van een naamruimte (bestand of genest in een namespace blok), hoeft u het type niet volledig in aanmerking te komen.

De using static richtlijn is van toepassing op elk type dat statische leden (of geneste typen) heeft, zelfs als deze ook instantieleden heeft. U kunt echter alleen exemplaarleden aanroepen 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 functies op het hoogste niveau van F# 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 extensieleden gedeclareerd in het opgegeven type beschikbaar voor het opzoeken van extensieleden. De namen van de extensieleden 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 kunt u de using static instructie ook toepassen 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 toe te voegen using static met de enum hoeft u het enum-type niet meer te gebruiken om toegang te krijgen tot de leden.

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 instructie moet u de volledig gekwalificeerde naamruimte of het type gebruiken, ongeacht de using instructies die ervoor worden gegeven. U kunt geen alias gebruiken using 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 door andere entiteiten kunnen worden verborgen.

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 .

Zie ook

  • Last updated on