using static-Direktive (C#-Referenz)

Die using static-Direktive legt einen Typ fest, auf dessen statische Member Sie ohne Angabe eines Typnamens zugreifen können. Die Syntax lautet:

using static <fully-qualified-type-name>

Wo vollqualifizierter Typname der Name des Typs ist, auf dessen statische Member verwiesen werden kann, ohne einen Typnamen anzugeben. Wenn Sie keinen vollqualifizierten Typnamen angeben (der vollständige Namespacename mit dem Typnamen), generiert C# den Compilerfehler CS0246: „The type or namespace name '' could not be found“ („Der Typ- oder Namespacename konnte nicht gefunden werden.“)

Die using static-Direktive gilt für jeden Typ, der über statische Member verfügt, auch wenn er ebenfalls über Instanzmember verfügt. Instanzmember können jedoch nur über die Typinstanz aufgerufen werden.

Die using static-Direktive wurde in C# 6 eingeführt.

Hinweise

Wenn Sie einen statischen Member aufrufen, geben Sie normalerweise den Typnamen zusammen mit dem Membernamen an. Das wiederholte Eingeben desselben Typnamens zum Aufrufen von Membern dieses Typs kann zu ausführlichem, verwirrendem Code führen. Die folgende Definition einer Circle-Klasse verweist z.B. auf mehrere Member der Klasse Math.

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 Area
   {
      get { return 2 * Radius * Math.PI; }      
   }

   public double Circumference
   {
      get { return Math.PI * Math.Pow(Radius, 2); }
   }
}

Da nicht mehr jedes Mal explizit auf die Klasse Math verwiesen werden muss, wenn auf einen Member verwiesen wird, erzeugt die using static-Direktive deutlich übersichtlicheren 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 Area
   {
      get { return 2 * Radius * PI; }      
   }

   public double Circumference
   {
      get { return PI * Pow(Radius, 2); }
   }
}

using static importiert nur zugängliche statische Member und geschachtelte Typen, die im angegebenen Typ deklariert sind. Geerbte Member werden nicht importiert. Sie können aus jedem benannten Typen mit einer statischen using-Anweisung importieren, einschließlich Visual Basic-Module. Wenn F#-Funktionen der obersten Ebene in den Metadaten als statische Member eines benannten Typs angezeigt werden, dessen Name ein gültiger C#-Bezeichner ist, können die F#-Funktionen importiert werden.

using static macht Erweiterungsmethoden, die im angegebenen Typ deklariert sind, für die Erweiterungsmethodensuche verfügbar. Die Namen der Erweiterungsmethoden werden jedoch bei nicht referenzierten Verweisen im Code nicht in den Bereich importiert.

Methoden mit dem gleichen Namen, die aus verschiedenen Typen von verschiedenen statischen using static-Direktiven in der gleichen Kompilierungseinheit oder dem gleichen Namespace importiert wurden, bilden eine Methodengruppe. Die Überladungsauflösung innerhalb dieser Methodengruppen folgt den normalen C#-Regeln.

Beispiel

Im folgenden Beispiele wird die using static-Direktive verwendet, um die statischen Member der Klassen Console, Math und String zugänglich zu machen, ohne deren Typnamen angeben zu müssen.

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.Radius);
         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 Area
   {
      get { return 2 * Radius * PI; }      
   }

   public double Circumference
   {
      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: 486.95
//          Area: 12.45
   

In diesem Beispiel hätte die using static-Direktive auch auf den Typ Double angewendet werden können. Dadurch wäre es möglich geworden, die Methode TryParse(String, Double) aufzurufen, ohne einen Typnamen anzugeben. Hierdurch wird allerdings weniger lesbarer Code generiert, da die using static-Anweisungen überprüft werden müssen, um zu bestimmen, welche TryParse-Methode eines numerischen Typs aufgerufen wird.

Siehe auch

using directive (using-Direktive)
C#-Referenz
C#-Schlüsselwörter
Using-Namespaces
Namespace Keywords (Schlüsselwörter des Namespace)
Namespaces