Neste tutorial, aprenderemos sobre namespaces, como defini-los, acessar seus membros e usá-los em um programa C #.
Os namespaces são usados em C # para organizar e fornecer um nível de separação de códigos. Eles podem ser considerados como um contêiner que consiste em outros namespaces, classes, etc.
Um namespace pode ter os seguintes tipos como membros:
- Namespaces (namespace aninhado)
- Aulas
- Interfaces
- Estruturas
- Delegados
Discutiremos sobre esses tópicos em tutoriais posteriores. Por enquanto, ficaremos com classes e namespaces.
Os namespaces não são obrigatórios em um programa C #, mas desempenham um papel importante na escrita de códigos mais limpos e no gerenciamento de projetos maiores.
Vamos entender o conceito de namespace com um cenário da vida real. Temos um grande número de arquivos e pastas em nosso computador. Imagine como seria difícil gerenciá-los se estivessem em um único diretório. É por isso que colocamos os arquivos e pastas relacionados em um diretório separado. Isso nos ajuda a gerenciar nossos dados adequadamente.
O conceito de namespace é semelhante em C #. Isso nos ajuda a organizar diferentes membros, colocando membros relacionados no mesmo namespace.
O namespace também resolve o problema de conflito de nomes . Duas ou mais classes, quando colocadas em namespaces diferentes, podem ter o mesmo nome.
Definindo namespace em C #
Podemos definir um namespace em C # usando a palavra-chave namespace como:
namespace Namespace-Name (// Corpo do namespace)
Por exemplo:
namespace MyNamespace ( class MyClass ( public void MyMethod() ( System.Console.WriteLine("Creating my namespace"); ) ) )
No exemplo acima, um namespace MyNamespaceé criado. Ele consiste em uma classe MyClasscomo seu membro. MyMethodé um método de classe MyClass.
Acessando membros do namespace em C #
Os membros de um namespace podem ser acessados usando o dot(.)operador. A sintaxe para acessar o membro do namespace é,
Namespace-Name.Member-Name
Por exemplo, se precisarmos criar um objeto de MyClass, isso pode ser feito como,
MyNamespace.MyClass myClass = new MyNamespace.MyClass ();
Discutiremos sobre a criação de objetos em tutoriais posteriores. Por enquanto, concentre-se apenas em como a classe MyClassé acessada.
Exemplo 1: Apresentando o namespace no programa C #
using System; namespace MyNamespace ( public class SampleClass ( public static void myMethod() ( Console.WriteLine("Creating my namespace"); ) ) ) namespace MyProgram ( public class MyClass ( public static void Main() ( MyNamespace.SampleClass.myMethod(); ) ) )
Quando executamos o programa, a saída será:
Criando meu namespace
No programa acima, criamos nosso próprio namespace MyNamespacee acessamos seus membros a partir do Main()método interno MyClass. Como dito anteriormente, o dot (.)operador é usado para acessar o membro do namespace.
No Main()método, o myMethod()método é chamado usando o dot (.)operador.
Usando um namespace em C # (a palavra-chave usando)
Um namespace pode ser incluído em um programa usando a palavra-chave using. A sintaxe é,
using Namespace-Name;
Por exemplo,
using System;
A vantagem dessa abordagem é que não precisamos especificar o nome totalmente qualificado dos membros desse namespace sempre que o acessamos.
Uma vez que a linha
using System;
está incluído na parte superior do programa. Nós podemos escrever
Console.WriteLine ("Olá, mundo!");
Em vez do nome totalmente qualificado, isto é
System.Console.WriteLine ("Olá, mundo!");
Namespace aninhado em C #
Um namespace pode conter outro namespace. É chamado de namespace aninhado. O namespace aninhado e seus membros também podem ser acessados usando o dot (.)operador.
A sintaxe para criar um namespace aninhado é a seguinte:
namespace MyNamespace (namespace NestedNamespace (// Corpo do namespace aninhado))
Exemplo 2: namespace aninhado em C #
using System; // Nested Namespace namespace MyNamespace ( namespace Nested ( public class SampleClass ( public static void myMethod() ( Console.WriteLine("Nested Namespace Example"); ) ) ) ) namespace MyProgram ( public class MyClass ( public static void Main() ( MyNamespace.Nested.SampleClass.myMethod(); ) ) )
Quando executamos o programa, a saída será:
Exemplo de namespace aninhado
Este exemplo ilustra como o namespace aninhado pode ser implementado em C #.
Aqui, agora temos um namespace extra MyNamespacechamado Nested. Então, ao invés de usar MyNamespace.SampleClass.myMethod(), temos que usar MyNamespace.Nested.SampleClass.myMethod().
