Namespaces – O que é? – [C#]

Quando desenvolvemos um software maior e mais complexo, mais classes e mais métodos teremos dentro do código fonte.

Nestas situações, como fica a organização do nosso código?

Como fazer para não nos confundirmos? Afinal, somos humanos, né?

E se tivermos mais de um desenvolvedor mexendo neste código?

É aí que entra o conceito de namespaces.

Vamos ver neste artigo como os namespaces podem nos auxiliar a organizar nosso código fonte.

Namespaces – Conceito

Um namespace serve para fornecer uma maneira de manter um conjunto de nomes separado de outro.

Os nomes de classe declarados em um namespace não entram em conflito com os mesmos nomes de classe declarados em outro.

Os namespaces foram criados principalmente por dois motivos:

1 – para organizar as inúmeras classes do .NET Framework, como por exemplo:

System.Console.WriteLine("Olá!");

System é um namespace e Console é uma classe dentro deste namespace. Podemos utilizar a palavra chave using para não precisar ficar repetindo o nome completo, como no exemplo:

using System;

public main()
{
    Console.WriteLine("Olá");
}

2 – declarar seu próprio namespace nos ajuda a controlar o escopo da classe e métodos em grandes projetos de software.

Use a palavra chave namespace para declarar um namespace, como no exemplo abaixo:

namespace NamespaceExemplo
{
    class ClasseExemplo
    {
        public void MetodoExemplo()
        {
            System.Console.WriteLine("MetodoExemplo dentro do NamespaceExemplo");
        }
    }
}

Definindo um Namespace

A definição de um namespace começa com a palavra chave namespace seguido do seu nome, como segue:

namespace NomeDoNamespace
{
    // código
}

Para chamar a versão habilitada do namespace de qualquer função ou variável, substitua o nome do namespace da seguinte maneira:

Nome_namespace.nome_item;

O código seguinte demonstra o uso de namespaces:

using System;

namespace primeiro
{
    class classe_namespace
    {
        public void func()
        {
            Console.WriteLine("Dentro do primeiro");
        }
    }
}

namespace segundo
{
    class classe_namespace
    {
        public void func()
        {
            Console.WriteLine("Dentro do segundo");
        }
    }
}

class ClasseTeste
{
    static void Main(string[] args)
    {
        primeiro.classe_namespace fc = new primeiro.classe_namespace();
        segundo.classe_namespace sc = new segundo.classe_namespace();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

Ao executar o código abaixo, temos:

Dentro do primeiro
Dentro do Segundo

A palavra chave using

A palavra chave using indica que o programa está utilizando os nomes de determinado namespace.

Por exemplo, estamos utilizando o namespace System em nosso programa, pois a classe Console está definido nele.

Utilizando a diretiva using System, podemos escrever somente

Console.WriteLine ("Olá");

Ao invés de escrevermos

System.Console.WriteLine("Olá");

Podemos também evitar ficar repetindo o nome dos namespaces com a diretiva using.

Esta diretiva diz ao compilador que o código subsequente está fazendo uso de determinados namespaces.

O namespace está, portanto, implícito no seguinte código:

Vamos reescrever o código acima com a diretiva using:

using System;
using primeiro;
using sgundo;

namespace primeiro
{
    class teste1
    {
        public void func()
        {
            Console.WriteLine("Dentro do primeiro");
        }
    }
}

namespace segundo
{
    class teste2
    {
        public void func()
        {
            Console.WriteLine("Dentro do segundo");
        }
    }
}

class ClasseTeste
{
    static void Main(string[] args)
    {
        teste1 fc = new teste1();
        teste2 sc = new teste2();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

O código acima produz o seguinte resultado:

Dentro do primeiro
Dentro do Segundo

Namespaces aninhados

Podemos definir um namespace dentro do outro como segue:

namespace namespace_nome1
{
    // código
    namespace namespace_nome2
    {
        // código
    }
}

Acessamos os membros do namespace aninhados usando o operador ponto (.) como abaixo:

using System;
using primeiro;
using primeiro.segundo;

namespace primeiro
{
    class teste
    {
        public void func()
        {
            Console.WriteLine("Dentro do primeiro");
        }
    }

    namespace segundo
    {
        class teste2
        {
            public void func()
            {
                Console.WriteLine("Dentro do segundo");
            }
        }
    }
}

class ClasseTeste
{
    static void Main(string[] args)
    {
        teste1 fc = new teste1();
        teste2 sc = new teste2();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

O código acima produz o resultado seguinte:

Dentro do primeiro
Dentro do segundo

Utilizando Alias

E quando estamos utilizando dois métodos de mesmo nome mas namespaces diferentes?

Neste caso, temos 2 soluções:

Utilizar o namespace completo ao utilizar uma classe/método.

Veja o exemplo abaixo:

using System;
using primeiro;
using sgundo;

namespace primeiro
{
    class teste
    {
        public void func()
        {
            Console.WriteLine("Dentro do primeiro");
        }
    }
}

namespace segundo
{
    class teste
    {
        public void func()
        {
            Console.WriteLine("Dentro do segundo");
        }
    }
}

class ClasseTeste
{
    static void Main(string[] args)
    {
        primeiro.teste fc = new primeiro.teste();
        segundo.teste sc = new Segundo.teste();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

Utilizar Alias (ou apelidos), como no exemplo abaixo:

using System;
using pr = primeiro.teste;
using se = segundo.teste;

namespace primeiro
{
    class teste
    {
        public void func()
        {
            Console.WriteLine("Dentro do primeiro");
        }
    }
}

namespace segundo
{
    class teste
    {
        public void func()
        {
            Console.WriteLine("Dentro do segundo");
        }
    }
}

class ClasseTeste
{
    static void Main(string[] args)
    {
        pr fc = new pr();
        se sc = new se();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

Palavras finais

Utilizar namespaces é uma maneira de organizarmos melhor nosso código.

Servem também para distinguir classes de mesmo nome.

Pense em namespaces como se fossem sobrenomes utilizados para dar nomes únicos a nossas classes. Neste contexto, homônimos são proibidos. Ou seja, não podemos ter duas classes com o mesmo nome e sobrenome.

Namespaces possuem as seguintes propriedades:

• Organizam grandes projetos de software.
• São delimitados utilizando o operador . (ponto)
• Com a diretiva using evitamos ter que declarar todo o namespace sempre que vamos utilizar alguma classe.
• O namespace global é o namespace raiz: global::System sempre fará referência para o namespace System do .NET Framework.

Meu e-book Como Aprender a Programar do Absoluto Zero está GRATUITO por tempo limitado!

Olha o link: 👉🏼 http://celsokitamura.com.br/como-aprender-a-programar

Bora aprender a programar!