Curso de C#: Lição 6: Namespaces

Esta lição introduz-lhe as Namespaces em C#. Nossos objetivos são os seguintes: Entenda o que é Namespace. Saiba como implementar a directiva usando. Aprenda a usar alias directiva. Entenda o que são membros namespace.

Por | @oficinadanet Programação
Esta lição introduz-lhe as Namespaces em C#. Nossos objetivos são os seguintes:

* Entenda o que é Namespace.
* Saiba como implementar a directiva usando.
* Aprenda a usar alias directiva.
* Entenda o que são membros namespace.


Na Aula 1, você viu o uso do sistema; directiva no SimpleHello programa. Esta directiva permitiu-lhe utilizar membros do Sistema namespace. Devido ao estreito foco dessa lição, precisávamos de atraso explicação até agora. Quando você tiver completado esta lição você vai entender o uso directiva e muito mais.

Namespaces são programas C # com elementos concebidos para ajudá-lo a organizar os seus programas. Eles também prestar assistência em nome evitando confrontos entre os dois conjuntos de código. Implementar Namespaces no seu próprio código é um bom hábito, pois é provável que lhe poupar de problemas mais tarde, quando você quiser reutilizar alguns de seus códigos. Por exemplo, se você criar uma classe chamada Console, você precisa colocá-la em seu próprio namespace para garantir que não houve qualquer confusão sobre quando a classe System.Console deve ser usado ou quando a sua classe devem ser utilizados. Geralmente, seria uma má idéia de criar uma classe chamada Console, mas em muitos casos a sua aulas serão nomeadas da mesma forma em ambas as classes. NET Framework Class Library ou de um terceiro biblioteca e namespaces ajudá-lo a evitar os problemas que idênticas Class nomes causaria.

Namespaces não correspondem ao arquivo ou diretório nomes. Se nomear diretórios e arquivos de forma a corresponder aos namespaces ajuda a organizar o seu código e, em seguida, você poderá fazê-lo, mas não é necessária.

Listagem 6-1. C# Namespace: NamespaceCSS.cs
// Namespace Declaration
using System;

// The C# Station Namespace
namespace csharp_station
{
    // Program start class
    class NamespaceCSS
    {
        // Main begins program execution.
        public static void Main()
        {
            // Write to console
            Console.WriteLine("This is the new C# Station Namespace.");
        }
    }
}

Listagem 6-1 mostra como criar um namespace. Nós declaramos o novo namespace colocando a palavra namespace na frente de csharp_station.

Listagem 6-2. Namespace 1: NestedNamespace1.cs
// Namespace Declaration
using System;

// The C# Station Tutorial Namespace
namespace csharp_station
{
    namespace tutorial
    {
        // Program start class
        class NamespaceCSS
        {
            // Main begins program execution.
            public static void Main()
            {
                // Write to console
                Console.WriteLine("This is the new C# Station Tutorial Namespace.");
            }
        }
    }
}


Namespaces permitem-lhe criar um sistema para organizar o seu código. Uma boa maneira de organizar a sua namespaces é através de um sistema hierárquico.Você colocou o mais geral nomes no topo da hierarquia e obter mais específica as you go down. Este sistema hierárquico pode ser representado por nested namespaces.Listagem 6-2 mostra como criar um namespace aninhadas. Ao colocar o código em diversas sub-namespaces, você pode manter o seu código organizado.

Listagem 6-3. Namespace 2:  NestedNamespace2.cs
// Namespace Declaration
using System;

// The C# Station Tutorial Namespace
namespace csharp_station.tutorial
{
    // Program start class
    class NamespaceCSS
    {
        // Main begins program execution.
        public static void Main()
        {
            // Write to console
            Console.WriteLine("This is the new C# Station Tutorial Namespace.");
        }
    }
}

Listagem 6-3 mostra uma outra forma de escrever aninhadas namespaces. Especifica o nested namespace com o operador ponto entre csharp_station e tutorial. O resultado é exatamente o mesmo que Listing 6-2. No entanto, é mais fácil Listing 6-3 para escrever.

Listagem 6-4. Chamando membros da namespace : NamespaceCall.cs
// Namespace Declaration
using System;

namespace csharp_station
{
    // nested namespace
    namespace tutorial
    {
        class myExample1
        {
            public static void myPrint1()
            {
                Console.WriteLine("First Example of calling another namespace member.");
            }
        }
    }

    // Program start class
    class NamespaceCalling
    {
        // Main begins program execution.
        public static void Main()
        {
            // Write to console
            tutorial.myExample1.myPrint1();
            tutorial.myExample2.myPrint2();
        }
    }
}

// same namespace as nested namespace above
namespace csharp_station.tutorial
{
    class myExample2
    {
        public static void myPrint2()
        {
            Console.WriteLine("Second Example of calling another namespace member.");
        }
    }
}


Listagem 6-4 fornece um exemplo de como a chamada nominal membros com nomes totalmente qualificado. Um nome totalmente qualificado contém todas as línguas elemento do namespace nome para baixo para chamar o método. No topo da lista existe um tutorial namespace aninhada dentro da estação namespace csharp-myExample1 com classe e método myPrint1. Main () chama este método totalmente qualificado com o nome de tutorial.myExample1.myPrint (). Desde Main (), o tutorial namespace estão localizados no mesmo namespace, utilizando csharp_station no nome totalmente qualificado é desnecessário.

Na parte inferior da Lista 6-4 é um complemento ao csharp_station.tutorial namespace.As aulas myExample1 e myExample2 ambas pertencem ao mesmo namespace. Além disso, eles poderiam ser escritas em arquivos separados e que ainda pertencem ao mesmo namespace. Em Main (), o método myPrint2 () é chamada com o nome totalmente qualificado tutorial.myExample2.myPrint2 (). Embora a classe myExample2 está fora da delimitadora correias de onde o método myPrint2 é chamado, o namespace csharp_station não precisa de ser uma parte do nome totalmente qualificado. Isso porque ambas as classes pertencem ao mesmo namespace, csharp_station.

Repare que eu usei nomes diferentes para as duas classes myExample1 e myExample2. Isso foi necessário porque cada namespace membro do mesmo tipo deve ter um nome exclusivo. Lembre-se, eles são ambos no mesmo namespace e você não gostaria que qualquer ambiguidade sobre qual classe de usar. Os métodos myPrint1 () e myPrint2 () têm nomes diferentes só porque iria fazer a lição um pouco mais fácil de seguir. Eles poderiam ter tido o mesmo nome, sem efeito, porque as turmas são diferentes, evitando assim qualquer ambiguidade.

Listagem 6-5. Usando uma Directiva: UsingDirective.cs
// Namespace Declaration
using System;
using csharp_station.tutorial;

// Program start class
class UsingDirective
{
    // Main begins program execution.
    public static void Main()
    {
        // Call namespace member
        myExample.myPrint();
    }
}

// C# Station Tutorial Namespace
namespace csharp_station.tutorial
{
    class myExample
    {
        public static void myPrint()
        {
            Console.WriteLine("Example of using a using directive.");
        }
    }
}


Se você gostaria de chamar métodos sem digitar seu nome totalmente qualificado, você pode executar usando a directiva. Em Listing 6-5, que mostram duas directivas usando. O primeiro, usando o sistema, é o mesmo usando directiva que você já viu, em cada programa neste tutorial. Ela permite que você digite o método nomes dos membros do Sistema namespace sem digitar a palavra Sistema de cada vez. Em myPrint (), Console é um membro da classe System namespace com o método WriteLine (). Seu nome é totalmente qualificado System.Console.WriteLine (...).

Do mesmo modo, a directiva usando usando csharp_station.tutorial nos permite chamar membros da csharp_station.tutorial namespace sem digitar o nome totalmente qualificado. Esta é a razão pela qual nós podemos tipo myExample.myPrint (). Sem o uso directiva, teríamos de tipo csharp_station.tutorial.myExample.myPrint () sempre quisemos chamar esse método.

Listagem6-6. A Directiva Alias: AliasDirective.cs
// Namespace Declaration
using System;
using csTut = csharp_station.tutorial.myExample; // alias

// Program start class
class AliasDirective
{
    // Main begins program execution.
    public static void Main()
    {
        // Call namespace member
        csTut.myPrint();
        myPrint();
    }

    // Potentially ambiguous method.
    static void myPrint()
    {
        Console.WriteLine("Not a member of csharp_station.tutorial.myExample.");
    }
}

// C# Station Tutorial Namespace
namespace csharp_station.tutorial
{
    class myExample
    {
        public static void myPrint()
        {
            Console.WriteLine("This is a member of csharp_station.tutorial.myExample.");
        }
    }
}


Às vezes, você pode encontrar uma longa namespace e desejo que ele seja mais curto. Isso poderia melhorar a legibilidade e ainda evitar confrontos com nome semelhante chamado métodos.Listagem 6-6 mostra como criar um alias com o apelido directiva usando csTut = csharp_station.tutorial.myExample. Agora, a expressão csTut pode ser usado em qualquer lugar, neste arquivo, em lugar de csharp_station.tutorial.myExample. Nós usá-lo em Main ().

Também em Main () é uma chamada para o myPrint () AliasDirective método da classe. Este é o mesmo nome que o myPrint () método na classe myExample. O motivo de ambos estes métodos podem ser postas no mesmo método, porque a chamada é myPrint () método na classe myExample é qualificada com o csTut alias. Isto permite que o compilador saber exactamente qual o método está a ser executada. Se tivéssemos erradamente omitidos csTut do método de chamada, o compilador teria criado o myPrint () método da classe AliasDirective a correr duas vezes.

Até agora, todos nós temos os nossos nomes são mostrados em classes. No entanto, namespaces pode realizar outros tipos como segue:
* Classes
* Estruturas
* Interfaces
* Enumerações
* Delegados

Na próxima lição veremos cada um deles.

Resumo


Em resumo, você sabe o que é um namespace e você pode declarar a sua própria namespaces. Se você não quiser digitar um nome completamente qualificado, você sabe como implementar a directiva usando. Quando quiser encurtar uma longa declaração namespace, você pode usar o apelido directiva. Além disso, tem sido introduzida em alguns dos outros membros namespace para além do tipo de turma.

Artigo traduzido automaticamente de: http://www.csharp-station.com/Tutorials/Lesson06.aspx

Mais sobre: curso_c_sharp c sharp
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo
  • ASSINE NOSSA NEWSLETTER

    As melhores publicações no
    seu e-mail

  • Preencha para confirmar