using static-Direktive (C#-Referenz)using static Directive (C# Reference)

Die using static-Direktive legt einen Typ fest, auf dessen statische Member Sie ohne Angabe eines Typnamens zugreifen können.The using static directive designates a type whose static members you can access without specifying a type name. Die Syntax lautet:Its syntax is:

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.where fully-qualified-type-name is the name of the type whose static members can be referenced without specifying a type name. 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.“)If you do not provide a fully qualified type name (the full namespace name along with the type name), C# generates compiler error CS0246: "The type or namespace name '' could not be found."

Die using static-Direktive gilt für jeden Typ, der über statische Member verfügt, auch wenn er ebenfalls über Instanzmember verfügt.The using static directive applies to any type that has static members, even if it also has instance members. Instanzmember können jedoch nur über die Typinstanz aufgerufen werden.However, instance members can only be invoked through the type instance.

Die using static-Direktive wurde in C# 6 eingeführt.The using static directive was introduced in C# 6.

HinweiseRemarks

Wenn Sie einen statischen Member aufrufen, geben Sie normalerweise den Typnamen zusammen mit dem Membernamen an.Ordinarily, when you call a static member, you provide the type name along with the member name. Das wiederholte Eingeben desselben Typnamens zum Aufrufen von Membern dieses Typs kann zu ausführlichem, verwirrendem Code führen.Repeatedly entering the same type name to invoke members of the type can result in verbose, obscure code. Die folgende Definition einer Circle-Klasse verweist z.B. auf mehrere Member der Klasse Math.For example, the following definition of a Circle class references a number of members of the Math class.

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); }
   }
}

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:By eliminating the need to explicitly reference the Math class each time a member is referenced, the using static directive produces much cleaner 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 importiert nur zugängliche statische Member und geschachtelte Typen, die im angegebenen Typ deklariert sind.using static imports only accessible static members and nested types declared in the specified type. Geerbte Member werden nicht importiert.Inherited members are not imported. Sie können aus jedem benannten Typen mit einer statischen using-Anweisung importieren, einschließlich Visual Basic-Module.You can import from any named type with a using static directive, including Visual Basic modules. 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.If F# top-level functions appear in metadata as static members of a named type whose name is a valid C# identifier, then the F# functions can be imported.

using static macht Erweiterungsmethoden, die im angegebenen Typ deklariert sind, für die Erweiterungsmethodensuche verfügbar.using static makes extension methods declared in the specified type available for extension method lookup. Die Namen der Erweiterungsmethoden werden jedoch bei nicht referenzierten Verweisen im Code nicht in den Bereich importiert.However, the names of the extension methods are not imported into scope for unqualified reference in code.

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.Methods with the same name imported from different types by different using static directives in the same compilation unit or namespace form a method group. Die Überladungsauflösung innerhalb dieser Methodengruppen folgt den normalen C#-Regeln.Overload resolution within these method groups follows normal C# rules.

BeispielExample

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.The following example uses the using static directive to make the static members of the Console, Math, and String classes available without having to specify their type name.

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 diesem Beispiel hätte die using static-Direktive auch auf den Typ Double angewendet werden können.In the example, the using static directive could also have been applied to the Double type. Dies gewesen wäre es möglich ist, rufen Sie die TryParse(String, Double) Methode ohne ein Typname.This would have made it possible to call the TryParse(String, Double) method without specifying a type name. 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.However, this creates less readable code, since it becomes necessary to check the using static statements to determine which numeric type's TryParse method is called.

Siehe auchSee also

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