Usando namespaces (Guia de Programação em C#)

Artigo
06/10/2015

Namespaces são usados intensamente nos programas de C# de duas maneiras. Em primeiro lugar, o.Classes do NET Framework usam espaços para nome para organizar suas muitas classes. Em segundo lugar, declarar seus próprios espaços para nome pode ajudar a controlar o escopo da classe e método nomes em projetos grandes de programação.

Acessar Namespaces

A maioria dos C# aplicativos começam com uma seção de using diretivas. Esta seção lista os espaços para nome que o aplicativo usará com freqüência e evita que o programador especificando toda vez que é usado um método que está contido dentro de um nome totalmente qualificado.

Por exemplo, ao incluir a linha:

using System;

No início de um programa, o programador pode usar o código:

Console.WriteLine("Hello, World!");

Em vez de:

System.Console.WriteLine("Hello, World!");

Alias de namespace

O Diretiva using (Referência de C#) também pode ser usado para criar um alias para um espaço para nome. Por exemplo, se você estiver usando um espaço para nome escrito anteriormente que contém os espaços para nome aninhados, convém declarar um alias para fornecer uma forma abreviada de fizer referência a um em particular, como no exemplo a seguir:

using Co = Company.Proj.Nested;  // define an alias to represent a namespace

Usando espaços para nome para o escopo de controle

O namespace palavra-chave é usada para declarar um escopo. A capacidade de criar escopos dentro de seu projeto ajuda a organizar o código e lhe permite criar tipos exclusivos globalmente. No exemplo a seguir, uma classe denominada SampleClass é definido em dois espaços para nome, uma aninhada na outra. O Operador . (Referência de C#) é usado para diferenciar qual método é chamado.

namespace SampleNamespace
{
    class SampleClass
    {
        public void SampleMethod()
        {
            System.Console.WriteLine(
              "SampleMethod inside SampleNamespace");
        }
    }

    // Create a nested namespace, and define another class. 
    namespace NestedNamespace
    {
        class SampleClass
        {
            public void SampleMethod()
            {
                System.Console.WriteLine(
                  "SampleMethod inside NestedNamespace");
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Displays "SampleMethod inside SampleNamespace."
            SampleClass outer = new SampleClass();
            outer.SampleMethod();

            // Displays "SampleMethod inside SampleNamespace."
            SampleNamespace.SampleClass outer2 = new SampleNamespace.SampleClass();
            outer2.SampleMethod();

            // Displays "SampleMethod inside NestedNamespace."
            NestedNamespace.SampleClass inner = new NestedNamespace.SampleClass();
            inner.SampleMethod();
        }
    }
}

Nomes totalmente qualificados

Namespaces e tipos têm títulos exclusivos descritos por nomes totalmente qualificados que indicam uma hierarquia lógica. Por exemplo, a instrução A.B implica que A é o nome do namespace ou tipo, e B está aninhado dentro dele.

No exemplo a seguir, há namespaces e classes aninhadas. O nome totalmente qualificado é indicado como um comentário que segue a cada entidade.

namespace N1     // N1
{
    class C1      // N1.C1
    {
        class C2   // N1.C1.C2
        {
        }
    }
    namespace N2  // N1.N2
    {
        class C2   // N1.N2.C2
        {
        }
    }
}

No segmento de código anterior:

O namespace N1 é um membro de namespace global. O nome totalmente qualificado é N1.
O namespace N2 é um membro do N1. O nome totalmente qualificado é N1.N2.
A classe C1 é um membro do N1. O nome totalmente qualificado é N1.C1.
O nome da classe C2 é usado duas vezes nesse código. No entanto, os nomes totalmente qualificados são exclusivos. A primeira instância de C2 é declarada dentro de C1; Portanto, seu nome totalmente qualificado é: N1.C1.C2. A segunda instância de C2 é declarada dentro de um espaço para nome N2; Portanto, seu nome totalmente qualificado é N1.N2.C2.

Usando o segmento de código anterior, você pode adicionar um novo membro de classe, C3, para o namespace N1.N2 da seguinte maneira:

namespace N1.N2
{
    class C3   // N1.N2.C3
    {
    }
}

Em geral, use :: para fazer referência a um alias de namespace ou global:: para referenciar o namespace global e . para qualificar tipos ou membros.

É errado usar :: com um alias que referencia um tipo em vez de um espaço para nome. Por exemplo:

using Alias = System.Console;

class TestClass
{
    static void Main()
    {
        // Error 
        //Alias::WriteLine("Hi");

        // OK
        Alias.WriteLine("Hi");
    }
}

Lembre-se de que a palavra global não é um alias predefinido; Portanto, global.X não tem qualquer significado especial. Ele adquire um significado especial somente quando ele é usado com ::.

CS0440 é gerado se você definir um alias de aviso do compilador chamado global porque global:: sempre faz referência o namespace global e não um alias. Por exemplo, a linha a seguir gera o aviso:

using global = System.Collections;   // Warning

Usando :: com aliases é uma boa idéia e protege contra a introdução inesperada de tipos adicionais. Por exemplo, considere este exemplo:

using Alias = System;

namespace Library
{
    public class C : Alias.Exception { }
}

Isso funciona, mas se o nome de um tipo de Alias foram subseqüentemente sejam introduzidas, Alias. deve vincular a esse tipo. Usando Alias::Exception assegura que Alias é tratado como um alias de namespace e não confundidos com um tipo.

Consulte o tópico Como usar o alias de namespace global (Guia de Programação em C#) para obter mais informações sobre o global alias.