Usando espaços para nome (guia de programação de C#)

Artigo
08/04/2011

Namespaces são usados intensamente nos programas de C# de duas maneiras. Primeiramente, o.Classes do NET Framework usam espaços para nome para organizar suas muitas classes. Em segundo lugar, declarar sua própria namespaces 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 namespaces 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, por incluindo 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 usando a diretiva (referência de C#) também pode ser usado para criar um alias para um namespace. Por exemplo, se você estiver usando um espaço para nome escrito anteriormente contém namespaces 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 namespaces, 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 em proprietário.

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 no código. No entanto, os nomes totalmente qualificados são exclusivos. A primeira instância de C2 é declarada dentro de C1; Portanto, é o 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, 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 os tipos ou membros.

É um erro usar :: com um alias que faz referência a 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 é 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 um tipo chamado 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 são confundidas para um tipo.

Consulte o tópico How to: Use o Alias de Namespace Global (guia de programação C#) para obter mais informações sobre o global alias.