usando diretiva

A using diretiva permite que você use tipos definidos em um namespace sem especificar o namespace totalmente qualificado desse tipo. Em sua forma básica, a using diretiva importa todos os tipos de um único namespace, conforme mostrado no exemplo a seguir:

using System.Text;

Você pode aplicar dois modificadores a uma using diretiva:

  • O global modificador tem o mesmo efeito que adicionar a mesma using diretiva a cada arquivo de origem em seu projeto. Este modificador foi introduzido no C# 10.
  • O static modificador importa os static membros e tipos aninhados de um único tipo em vez de importar todos os tipos em um namespace. Esse modificador foi introduzido no C# 6.0.

Você pode combinar ambos os modificadores para importar os membros estáticos de um tipo em todos os arquivos de origem em seu projeto.

Você também pode criar um alias para um namespace ou um tipo com uma diretiva de alias usando.

using Project = PC.MyCompany.Project;

Você pode usar o global modificador em uma diretiva usando alias.

Observação

A palavra-chave using também é usada para criar instruções using, o que ajuda a garantir que objetos IDisposable, tais como arquivos e fontes, sejam tratados corretamente. Para obter mais informações sobre a instrução using, consulte using Statement.

O escopo de uma using diretiva sem o global modificador é o arquivo no qual ele aparece.

A diretiva using pode aparecer:

  • No início de um arquivo de código-fonte, antes de qualquer namespace ou declarações de tipo.
  • Em qualquer namespace, mas antes de qualquer namespace ou tipos declarados nesse namespace, a menos que o global modificador seja usado, nesse caso, a diretiva deve aparecer antes de todas as declarações de namespace e tipo.

Caso contrário, serão gerados erros do compilador CS1529.

Crie uma diretiva using para usar os tipos em um namespace sem precisar especificar o namespace. Uma using diretiva não fornece acesso a namespaces aninhados no namespace especificado. Os namespaces vêm em duas categorias: definidos pelo usuário e definidos pelo sistema. Os namespaces definidos pelo usuário são namespaces definidos em seu código. Para obter uma lista dos namespaces definidos pelo sistema, consulte Navegador de API do .NET.

modificador global

Adicionar o global modificador a uma using diretiva significa que o uso é aplicado a todos os arquivos na compilação (normalmente um projeto). A global using diretiva foi adicionada no C# 10. Sua sintaxe é:

global using <fully-qualified-namespace>;

em que o namespace totalmente qualificado é o nome totalmente qualificado do namespace cujos tipos podem ser referenciados sem especificar o namespace.

Uma diretiva de uso global pode aparecer no início de qualquer arquivo de código-fonte. Todas as global using diretivas em um único arquivo devem aparecer antes:

  • Todas as using diretivas sem o global modificador.
  • Todos os namespaces e declarações de tipo no arquivo.

Você pode adicionar global using diretivas a qualquer arquivo de origem. Normalmente, você deseja mantê-los em um único local. A ordem das global using diretivas não importa, seja em um único arquivo ou entre arquivos.

O global modificador pode ser combinado com o static modificador. O global modificador pode ser aplicado a uma diretiva de alias usando. Em ambos os casos, o escopo da diretiva é todos os arquivos na compilação atual. O exemplo a seguir permite o uso de todos os métodos declarados em System.Math todos os arquivos em seu projeto:

global using static System.Math;

Você também pode incluir globalmente um namespace adicionando um <Using> item ao arquivo de projeto, por exemplo, <Using Include="My.Awesome.Namespace" />. Para obter mais informações, consulte <Using> o item.

Importante

Os modelos C# para .NET 6 usam instruções de nível superior. Seu aplicativo pode não corresponder ao código neste artigo, se você já tiver atualizado para o .NET 6. Para obter mais informações, consulte o artigo sobre novos modelos de C# que geram instruções de nível superior

O SDK do .NET 6 também adiciona um conjunto de diretivas implícitasglobal using para projetos que usam os seguintes SDKs:

  • Microsoft.NET.Sdk
  • Microsoft.NET.Sdk.Web
  • Microsoft.NET.Sdk.Worker

Essas diretivas implícitas global using incluem os namespaces mais comuns para o tipo de projeto.

modificador estático

A using static diretiva nomeia um tipo cujos membros estáticos e tipos aninhados você pode acessar sem especificar um nome de tipo. A diretiva using static foi introduzida no C# 6. Sua sintaxe é:

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

O <fully-qualified-type-name> é o nome do tipo cujos membros estáticos e tipos aninhados podem ser referenciados sem especificar um nome de tipo. Se você não fornecer um nome de tipo totalmente qualificado (o nome completo do namespace junto com o nome do tipo), o C# gerará o erro do compilador CS0246: "O nome do namespace ou tipo 'tipo/namespace' não foi encontrado (você está perdendo uma diretiva de uso ou uma referência de assembly?)".

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. No entanto, os membros da instância podem ser invocados apenas por meio de instância de tipo.

Você pode acessar os membros estáticos de um tipo sem precisar qualificar o acesso com o nome do tipo:

using static System.Console;
using static System.Math;
class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4));
    }
}

Normalmente, quando você chamar um membro estático, fornece o nome do tipo juntamente com o nome do membro. Inserir repetidamente o mesmo nome de tipo para invocar os membros do tipo pode resultar em código obscuro detalhado. Por exemplo, a definição a seguir de uma Circle classe faz referência a muitos membros da Math classe.

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

Ao eliminar a necessidade de referenciar explicitamente a Math classe sempre que um membro é referenciado, a using static diretiva produz código mais limpo:

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. Os membros herdados não são importados. Você pode importar de qualquer tipo nomeado com uma using static diretiva, incluindo módulos Visual Basic. 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.

using static torna os métodos de extensão declarados no tipo especificado disponível para pesquisa de método de extensão. No entanto, os nomes dos métodos de extensão não são importados no escopo para referência não qualificada no código.

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. A resolução de sobrecarga nesses grupos de métodos segue as regras normais de C#.

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.

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. Adicionar essa diretiva possibilitaria chamar o TryParse(String, Double) método sem especificar um nome de tipo. No entanto, usar TryParse sem um nome de tipo cria um código menos legível, pois torna-se necessário verificar as using static diretivas para determinar qual método de TryParse tipo numérico é chamado.

using static também se aplica a enum tipos. Ao adicionar using static com a enumeração, o tipo não é mais necessário para usar os membros de enumeração.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

class Program
{
    public static void Main()
    {
        Color color = Green;
    }
}

usando alias

Crie uma diretiva de alias using para tornar mais fácil a qualificação de um identificador para um namespace ou tipo. Em qualquer using diretiva, o namespace ou tipo totalmente qualificado deve ser usado independentemente das using diretivas que vêm antes dele. Nenhum alias using pode ser usado na declaração de uma diretiva using. Por exemplo, o exemplo a seguir gera um erro do compilador:

using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.

O exemplo a seguir mostra como definir e usar um alias de using para um namespace:

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 { }
        }
    }
}

Uma diretiva de alias de uso não pode ter um tipo genérico aberto no lado direito. Por exemplo, você não pode criar um alias usando para um List<T>, mas pode criar um para um List<int>.

O exemplo a seguir mostra como definir uma diretiva using e um alias using para uma classe:

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.

Como usar o namespace Visual Basic My

O Microsoft.VisualBasic.MyServices namespace (My em Visual Basic) fornece acesso fácil e intuitivo a várias classes .NET, permitindo que você escreva código que interage com o computador, aplicativo, configurações, recursos e assim por diante. Embora tenha sido projetado originalmente para ser usado com o Visual Basic, o namespace MyServices pode ser usado em aplicativos C#.

Para obter mais informações sobre como usar o namespace MyServices no Visual Basic, consulte Desenvolvimento com My.

Você precisa adicionar uma referência ao assemblyMicrosoft.VisualBasic.dll em seu projeto. Nem todas as classes no namespace MyServices podem ser chamadas em um aplicativo C#: por exemplo, a classe FileSystemProxy não é compatível. Em vez disso, nesse caso específico, podem ser usados os métodos estáticos que fazem parte da FileSystem, que também estão contidos na VisualBasic.dll. Por exemplo, veja como usar um desses métodos para duplicar um diretório:

// Duplicate a directory
Microsoft.VisualBasic.FileIO.FileSystem.CopyDirectory(
    @"C:\original_directory",
    @"C:\copy_of_original_directory");

Especificação da linguagem C#

Para obter mais informações, consulte Diretivas using na Especificação da Linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Para obter mais informações sobre o modificador de uso global , consulte a especificação de recurso de usos globais – C# 10.

Confira também