usando a diretiva

A using diretiva permite-lhe utilizar tipos definidos num espaço de nome sem especificar o espaço de nome totalmente qualificado desse tipo. Na sua forma básica, a using diretiva importa todos os tipos de um espaço com um único nome, como se pode ver no seguinte exemplo:

using System.Text;

Pode aplicar dois modificadores a uma using diretiva:

  • O global modificador tem o mesmo efeito que adicionar a mesma using diretiva a todos os ficheiros de origem do seu projeto. Este modificador foi introduzido em C# 10.
  • O static modificador importa os static membros e os tipos aninhados de um único tipo, em vez de importar todos os tipos num espaço de nome. Este modificador foi introduzido em C# 6.0.

Pode combinar ambos os modificadores para importar os membros estáticos de um tipo em todos os ficheiros de origem do seu projeto.

Também pode criar um pseudónimo para um espaço de nome ou um tipo com uma diretiva de uso de pseudónimos.

using Project = PC.MyCompany.Project;

Pode utilizar o global modificador numa diretiva relativa à utilização de pseudónimos.

Nota

A using palavra-chave também é usada para criar declarações, que ajudam a garantir que IDisposable objetos como ficheiros e tipos de letra são manuseados corretamente. Para obter mais informações sobre a declaração de utilização, consulte a utilização da Declaração.

O âmbito de aplicação de uma using diretiva sem o global modificador é o ficheiro em que aparece.

A using diretiva pode parecer:

  • No início de um ficheiro de código fonte, antes de qualquer espaço de nome ou declaração de tipo.
  • Em qualquer espaço de nome, mas antes de quaisquer espaços ou tipos de nomes declarados nesse espaço de nome, a menos que o global modificador seja utilizado, nesse caso a diretiva deve aparecer antes de todas as declarações de espaço de nome e tipo.

Caso contrário, o erro do compilador CS1529 é gerado.

Crie uma using diretiva para utilizar os tipos num espaço de nome sem ter de especificar o espaço de nome. Uma using diretiva não lhe dá acesso a nenhum espaço de nome que esteja aninhado no espaço de nome que especifica. Os espaços de nome vêm em duas categorias: definido pelo utilizador e definido pelo sistema. Os espaços de nome definidos pelo utilizador são espaços de nome definidos no seu código. Para obter uma lista dos espaços de nomes definidos pelo sistema, consulte o Navegador API .NET.

modificador global

A adição do global modificador a uma using diretiva significa que a utilização é aplicada a todos os ficheiros da compilação (normalmente um projeto). A global using diretiva foi acrescentada em C nº 10. A sua sintaxe é:

global using <fully-qualified-namespace>;

onde o espaço de nome totalmente qualificado é o nome totalmente qualificado do espaço de nome cujos tipos podem ser referenciados sem especificar o espaço de nome.

Uma diretiva de utilização global pode aparecer no início de qualquer ficheiro de código fonte. Todas as global using diretivas num único ficheiro devem ser apresentadas antes:

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

Pode adicionar global using diretivas a qualquer ficheiro de origem. Normalmente, vai querer mantê-los num único local. A ordem das global using diretivas não importa, nem num único ficheiro, nem entre ficheiros.

O global modificador pode ser combinado com o static modificador. O global modificador pode ser aplicado a uma diretiva relativa à utilização do pseudónimo. Em ambos os casos, o âmbito de aplicação da diretiva é todos os ficheiros da atual compilação. O exemplo a seguir permite a utilização de todos os métodos declarados em todos os ficheiros do System.Math seu projeto:

global using static System.Math;

Também pode incluir globalmente um espaço de nome adicionando um <Using> item ao seu ficheiro de projeto, por exemplo, <Using Include="My.Awesome.Namespace" />. Para mais informações, consulte <Using> o artigo.

Importante

Os modelos C# para .NET 6 utilizam declarações de nível superior. A sua aplicação pode não corresponder ao código deste artigo, se já tiver atualizado para o .NET 6. Para mais informações consulte o artigo sobre os modelos New C# geram declarações de alto nível

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

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

Estas diretivas implícitas global using incluem os espaços de nome mais comuns para o tipo de projeto.

modificador estático

A using static diretiva designa um tipo cujos membros estáticos e tipos aninhados podem aceder sem especificar um nome do tipo. A using static diretiva foi introduzida em C nº 6. A sua sintaxe é:

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

É <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 não fornecer um nome de tipo totalmente qualificado (o nome completo do espaço de nome juntamente com o nome do tipo), C# gera erro de compilador CS0246: "O tipo ou nome de espaço de nome 'type/namespace' não foi encontrado (está a perder uma diretiva de utilização ou uma referência de montagem?)".

A using static diretiva aplica-se a qualquer tipo de membros estáticos (ou tipos aninhados), mesmo que também tenha membros de instância. No entanto, os membros do caso só podem ser invocados através da instância tipo.

Pode aceder a membros estáticos de um tipo sem ter de 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 se chama um membro estático, fornece-se o nome do tipo juntamente com o nome do membro. Introduzir repetidamente o mesmo nome para invocar membros do tipo pode resultar em código verboso e obscuro. Por exemplo, a seguinte definição de uma Circle classe refere 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); }
   }
}

Eliminando a necessidade de referenciar explicitamente a Math classe sempre que um membro é referenciado, a using static diretiva produz um 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 apenas membros estáticos acessíveis e tipos aninhados declarados no tipo especificado. Membros herdados não são importados. Pode importar de qualquer tipo de nome com uma using static diretiva, incluindo Visual Basic módulos. Se as funções de nível superior F# aparecerem nos metadados como membros estáticos de um tipo nomeado cujo nome é um identificador C# válido, então as funções F# podem ser importadas.

using static torna os métodos de extensão declarados no tipo especificado disponíveis para a procura do método de extensão. No entanto, os nomes dos métodos de extensão não são importados em âmbito para referência não qualificada em código.

Métodos com o mesmo nome importados de diferentes tipos por diferentes using static diretivas na mesma unidade de compilação ou espaço de identificação formam um grupo de métodos. A resolução de sobrecarga dentro destes grupos de métodos segue as regras normais de C#.

O exemplo que se segue utiliza a using static diretiva para disponibilizar os membros estáticos do , Mathe String as classes sem ter de especificar o Consoleseu nome.

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

Por exemplo, a using static diretiva poderia também ter sido aplicada ao Double tipo. A adição desta diretiva permitiria ligar para o TryParse(String, Double) método sem especificar uma denominação-tipo. No entanto, a utilização TryParse sem uma denominação tipo cria um código menos legível, uma vez que se torna necessário verificar as using static diretivas para determinar qual o método do TryParse tipo numérico.

using static também se aplica a enum tipos. Ao adicionar using static com o enum, o tipo já não é necessário para utilizar os membros enum.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

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

usando pseudónimos

using Crie uma diretiva de pseudónimo para facilitar a qualificação de um identificador para um espaço ou tipo de nome. Em qualquer using diretiva, o espaço ou tipo de nome totalmente qualificado deve ser utilizado independentemente das using diretivas que lhe são apresentadas. Não using podem ser utilizados pseudónimos na declaração de uma using diretiva. 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 using pseudónimo para um espaço de nome:

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 usar pseudónimos não pode ter um tipo genérico aberto no lado direito. Por exemplo, não é possível criar um pseudónimo de utilização para um List<T>, mas pode criar um para um List<int>.

O exemplo a seguir mostra como definir uma using diretiva e using um pseudónimo 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 Visual Basic My espaço de nome

O Microsoft.VisualBasic.MyServices espaço de nomes (Myem Visual Basic) proporciona um acesso fácil e intuitivo a uma série de classes .NET, permitindo-lhe escrever código que interage com o computador, aplicação, configurações, recursos, e assim por diante. Embora originalmente projetado para ser usado com Visual Basic, o MyServices espaço de nome pode ser usado em aplicações C#.

Para obter mais informações sobre a MyServices utilização do espaço de nomes de Visual Basic, consulte Development with My.

Tem de adicionar uma referência à montagem Microsoft.VisualBasic.dll no seu projeto. Nem todas as classes no espaço de MyServices nomes podem ser chamadas a partir de uma aplicação C#: por exemplo, a FileSystemProxy classe não é compatível. Neste caso particular, os métodos estáticos que FileSystemfazem parte , que também estão contidos em VisualBasic.dll, podem ser utilizados. Por exemplo, aqui está 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 linguística C#

Para obter mais informações, consulte as diretivas relativas à utilização da especificação linguística C. A especificação linguística é a fonte definitiva para a sintaxe e utilização C#.

Para obter mais informações sobre o modificador de utilização global , consulte a especificação global de características de utilização - C# 10.

Ver também