Diretiva using static (Referência de C#)using static directive (C# Reference)

A diretiva using static designa um tipo cujos membros estáticos e tipos aninhados você pode acessar sem especificar um nome de tipo.The using static directive designates a type whose static members and nested types you can access without specifying a type name. Sua sintaxe é:Its syntax is:

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

em que fully-qualified-type-name é o nome do tipo cujos membros estáticos e tipos aninhados podem ser referenciados sem especificar um nome de 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 você não fornecer um nome de tipo totalmente qualificado (o nome do namespace completo juntamente com o nome do tipo), o C# gerará o erro de compilador CS0246: “O tipo ou o nome do namespace 'type/namespace' não pôde ser encontrado (uma diretiva using ou uma referência de assembly está ausente?)”.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?)".

A diretiva using static aplica-se a qualquer tipo que tenha membros estático (ou tipos aninhados), mesmo que ele também tenha membros de instância.The using static directive applies to any type that has static members (or nested types), even if it also has instance members. No entanto, os membros da instância podem ser invocados apenas por meio de instância de tipo.However, instance members can only be invoked through the type instance.

A diretiva using static foi introduzida no C# 6.The using static directive was introduced in C# 6.

ComentáriosRemarks

Normalmente, quando você chamar um membro estático, fornece o nome do tipo juntamente com o nome do membro.Ordinarily, when you call a static member, you provide the type name along with the member name. Inserir repetidamente o mesmo nome de tipo para invocar os membros do tipo pode resultar em código obscuro detalhado.Repeatedly entering the same type name to invoke members of the type can result in verbose, obscure code. Por exemplo, a seguinte definição de uma classe Circle faz referência a um número de membros da 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 a necessidade de fazer referência explícita à classe Math sempre que um membro é referenciado, a diretiva using static produz um código muito mais limpo: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 somente os membros estáticos acessíveis e os tipos aninhados declarados no tipo especificado.using static imports only accessible static members and nested types declared in the specified type. Os membros herdados não são importados.Inherited members are not imported. Você pode importar de qualquer tipo nomeado com uma diretiva using static, incluindo módulos do Visual Basic.You can import from any named type with a using static directive, including Visual Basic modules. Se funções de nível superior do F# aparecerem nos metadados como membros estáticos de um tipo nomeado cujo nome é um identificador válido do C#, as funções do F# poderão ser importadas.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 torna os métodos de extensão declarados no tipo especificado disponível para pesquisa de método de extensão.using static makes extension methods declared in the specified type available for extension method lookup. No entanto, os nomes dos métodos de extensão não são importados no escopo para a referência não qualificada no código.However, the names of the extension methods are not imported into scope for unqualified reference in code.

Métodos com o mesmo nome importados de diferentes tipos por diferentes diretivas using static na mesma unidade de compilação ou namespace formam um grupo de métodos.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. A resolução de sobrecarga nesses grupos de métodos segue as regras normais de C#.Overload resolution within these method groups follows normal C# rules.

ExemploExample

O exemplo a seguir usa a diretiva using static para tornar os membros estáticos das classes Console, Math e String disponíveis sem a necessidade de especificar seu nome de 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

No exemplo, a diretiva using static também poderia ter sido aplicada ao tipo Double.In the example, the using static directive could also have been applied to the Double type. Isso tornaria possível chamar o método TryParse(String, Double) sem especificar um nome de tipo.This would have made it possible to call the TryParse(String, Double) method without specifying a type name. No entanto, isso cria um código menos legível, pois torna-se necessário verificar as using static diretivas para determinar qual método de tipo numérico TryParse é chamado.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.

Veja tambémSee also