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 mesmausing
diretiva a cada arquivo de origem em seu projeto. Este modificador foi introduzido no C# 10. - O
static
modificador importa osstatic
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 oglobal
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.