Direttiva using static (Riferimenti per C#)using static directive (C# Reference)

La direttiva using static consente di definire un tipo i cui membri statici e i tipi nidificati sono accessibili senza specificare un nome di tipo.The using static directive designates a type whose static members and nested types you can access without specifying a type name. La relativa sintassi è la seguente:Its syntax is:

using static <fully-qualified-type-name>;

dove fully-qualified-type-name è il nome del tipo i cui membri statici e i tipi nidificati possono essere usati come riferimento senza specificare un nome di tipo.where fully-qualified-type-name is the name of the type whose static members and nested types can be referenced without specifying a type name. Se non si specifica un nome di tipo completo (il nome completo dello spazio dei nomi con il nome del tipo), C# genera l'errore del compilatore CS0246: "Impossibile trovare il nome del tipo o dello spazio dei nomi 'type/namespace' (probabilmente manca una direttiva using o un riferimento a un assembly)".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 'type/namespace' could not be found (are you missing a using directive or an assembly reference?)".

La direttiva using static si applica a qualsiasi tipo che includa membri statici (o tipi nidificati), anche qualora siano presenti membri di istanza.The using static directive applies to any type that has static members (or nested types), even if it also has instance members. Tuttavia, i membri di istanza possono essere chiamati solo tramite l'istanza del tipo.However, instance members can only be invoked through the type instance.

La direttiva using static è stata introdotta in C# 6.The using static directive was introduced in C# 6.

CommentiRemarks

Quando si chiama un membro statico si fornisce in genere il nome del tipo e il nome del membro.Ordinarily, when you call a static member, you provide the type name along with the member name. Immettere ripetutamente lo stesso nome di tipo per chiamare i membri del tipo può generare codice troppo dettagliato e incomprensibile.Repeatedly entering the same type name to invoke members of the type can result in verbose, obscure code. Ad esempio, la seguente definizione di una classe Circle fa riferimento a un numero di membri della classe 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); }
   }
}

Eliminando la necessità di fare riferimento in modo esplicito alla classe Math ogni volta che si fa riferimento a un membro, la direttiva using static genera un codice più chiaro: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 importa solo i membri statici accessibili e i tipi annidati dichiarati nel tipo specificato.using static imports only accessible static members and nested types declared in the specified type. I membri ereditati non vengono importati.Inherited members are not imported. È possibile eseguire l'importazione da qualsiasi tipo denominato con una direttiva using static, inclusi i moduli Visual Basic.You can import from any named type with a using static directive, including Visual Basic modules. Se nei metadati vengono visualizzate funzioni di primo livello F# come membri statici di un tipo denominato il cui nome è un identificatore C# valido, le funzioni F# possono essere importate.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 crea metodi di estensione dichiarati nel tipo specificato disponibile per la ricerca del metodo di estensione.using static makes extension methods declared in the specified type available for extension method lookup. Tuttavia, i nomi dei metodi di estensione non vengono importati nell'ambito del riferimento non qualificato nel codice.However, the names of the extension methods are not imported into scope for unqualified reference in code.

I metodi con lo stesso nome importati da tipi diversi tramite direttive using static diverse nella stessa unità di compilazione o nello stesso spazio dei nomi costituiscono un gruppo di metodi.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. La risoluzione dell'overload in questi gruppi di metodi segue le normali regole C#.Overload resolution within these method groups follows normal C# rules.

EsempioExample

L'esempio seguente usa la direttiva using static per rendere i membri statici della classe Console, Math e String disponibili senza dover specificare il nome del tipo.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

Nell'esempio la direttiva using static può anche essere stata applicata al tipo Double.In the example, the using static directive could also have been applied to the Double type. In questo caso sarebbe stato possibile chiamare il metodo TryParse(String, Double) senza specificare un nome di tipo.This would have made it possible to call the TryParse(String, Double) method without specifying a type name. Tuttavia, in questo modo viene creato codice meno leggibile, poiché diventa necessario controllare le using static direttive per determinare quale metodo del tipo numerico TryParse viene chiamato.However, this creates less readable code, since it becomes necessary to check the using static directives to determine which numeric type's TryParse method is called.

Vedere ancheSee also