A palavra-chave "using" em C# possui três funcionalidades principais:

1. Importar namespaces;
2. Criar aliases para namespaces ou tipos;
3. Implementar instruções using para gerenciamento de recursos.

(1) Importação de Namespaces

Semelhante às diretivas #include em C/C++ e import em Python, a utilização de "using" permite incluir tipos de um namespace sem a necessidade de especificar o caminho completo.

A sintaxe é: using + nome_do_namespace;

(2) Criação de Aliases para Namespaces ou Tipos

A sintaxe para esta funcionalidade é: using + alias = tipo_com_namespace_completo;

using System; // Importação do namespace using ClasseAlpha = Modulo1.MinhaClasse; // Criação de alias using ClasseBeta = Modulo2.MinhaClasse; // Criação de alias

namespace Modulo1 { public class MinhaClasse

{

public override string ToString() { return "Você está em Modulo1.MinhaClasse"; } } }

namepsace Modulo2 { class MinhaClasse { public override string ToString() { return "Você está em Modulo2.MinhaClasse"; } } }

(3) Utilização de Instruções using

A sintaxe de utilização:

// As classes RecursoA e RecursoB devem implementar a interface IDisposable

// Forma básica de using using (RecursoA a = new RecursoA()) { // Código que utiliza o recurso }

// Múltiplos using encadeados using (new RecursoA()) using (new RecursoB()) { // Código que utiliza ambos os recursos }

A palavra-chave "using" requer que o objeto entre parênteses implemente a interface IDisposable ou herde de uma classe que a implemente. Caso contrário, ocorrerá um erro de compilação. Ao final do bloco de código, o objeto é implicitamente convertido para o tipo IDisposable e seu método Dispose é chamado para liberar os recursos.

O mecanismo por trás do using: Durante a compilação, o compilador transforma automaticamente a instrução using em um bloco try-finally, chamando o método Dispose no bloco final. Portanto, using é funcionalmente equivalente a um bloco try-finally.

1. Instruções using para Namespaces ============================

A forma mais comum de using, utilizada por todos os desenvolvedores C#, permite referenciar tipos sem especificar o namespace completo:

using System.Windows.Media; 
using System.Windows.Media.Imaging;

2. Instruções using para Gerenciamento de Recursos ============================

Esta funiconalidade simplifica a liberação de recursos dentro de um escopo específico. Ao sair do escopo, o Dispose é chamado automaticamente. Apenas classes que implementam IDisposable podem ser utilizadas com esta construção.

 using (SqlConnection conexao=new SqlConnection("Data Source=.;Initial Catalog=imageprocess;Integrated Security=True"))
            {
                conexao.Open();
            using(ComandoSQL cmd=conexao.CreateCommand())
                {
                    cmd.CommandText = "select count(*) from [usuario]"; int resultado = (int)cmd.ExecuteScalar();
                    MessageBox.Show(resultado.ToString());
                }// Liberação automática do ComandoSQL }// Liberação automática da SqlConnection
        }  

3. Aliases com using ============================

A sintaxe using + alias = tipo_com_namespace_completo é especialmente útil quando dois namespaces diferentes contêm tipos com nomes idênticos. Em vez de especificar o namespace completo toda vez que o tipo for utilizado, podemos criar aliases.

É importante notar que se dois tipos com nomes idênticos forem utilizados, ambos devem receber aliases.

using System; 
using ClasseX = EspacoNominal1.MinhaClasse; 
using ClasseY = EspacoNominal2.MinhaClasse; 

namespace EspacoNominal1 
{ 
    public class MinhaClasse 
    { 
        public override string ToString() 
        { 
            return <span sty<="" p="" style="margin: 0px; padding: 0px;">"Você está em EspacoNominal1.MinhaClasse";
        }
    }
} 

namespace EspacoNominal2 
{ 
    class MinhaClasse 
    { 
        public override string ToString() 
        { 
            return "Você está em EspacoNominal2.MinhaClasse";
        }
    }
} 

namespace TesteUsing
{ 
    using EspacoNominal1; 
    using EspacoNominal2; 
    
    class ProgramaPrincipal
    { 
        static void Principal(string[] args)
        { 
            ClasseX objeto1 = new ClasseX();
            Console.WriteLine(objeto1);
            
            ClasseY objeto2 = new ClasseY();
            Console.WriteLine(objeto2);
            
            Console.WriteLine("Pressione qualquer tecla");
            Console.Read();
        }
    }
}