Lição 6 - Namespaces
Esta lição lhe apresenta para C # Namespaces. Os nossos objectivos 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 Lição 1, você viu a utilização do sistema; SimpleHello directiva no programa. Esta directiva permitiu-lhe utilizar os 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 a directiva usar e muito mais.
Namespaces são elementos C # programa concebido para o ajudar 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 você salve a partir de problemas mais tarde quando quiser reutilizar alguns de seus códigos. Por exemplo, se você criar uma classe chamado Console, você precisa colocá-la em seu próprio espaço de nome para garantir que não houve qualquer confusão sobre quando a classe System.Console deverão ser utilizados ou quando a sua classe devem ser usadas. Geralmente, isso seria uma má idéia de criar uma classe chamado Console, mas, em muitos casos, suas aulas serão nomeadas da mesma forma que as aulas em qualquer uma delas. NET Framework Class Library ou de um terceiro biblioteca e namespaces ajudá-lo a evitar os problemas que idênticas class nomes poderiam causar.
Namespaces não correspondem ao arquivo ou diretório nomes. Se nomear diretórios e arquivos para corresponder a namespaces ajuda a organizar o seu código e, em seguida, você poderá fazê-lo, mas ela não é necessária.
Listing 6-1. A estação 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. Chavetas circundam os membros dentro do csharp_station namespace.
Listing 6-2. Nested 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 que você crie 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 os nomes mais geral no topo da hierarquia e obter mais específicas como você ir para baixo. Este sistema hierárquico pode ser representado por nested namespaces. Listagem 6-2 mostra como criar um nicho namespace. Ao colocar código em diferentes sub-namespaces, você pode manter o seu código organizado.
Listing 6-3. Nested 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 aninhadas namespace com o operador ponto entre csharp_station e tutorial. O resultado é exatamente o mesmo que Listing 6-2. No entanto, é mais fácil de Listagem 6-3 escrever.
Listing 6-4. Chamando namespace membros: 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.");
}
}
}
Listing 6-4 fornece um exemplo de como a chamada namespace membros com nomes totalmente qualificado. Um nome totalmente qualificado contém todas as línguas a partir do elemento 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 () e do tutorial namespace estão localizados no mesmo namespace, utilizando csharp_station totalmente qualificado no nome é desnecessário.
Na parte inferior da Listagem 6-4 é um aditamento 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 ainda pertencem ao mesmo namespace. Em Main (), o myPrint2 () é chamado método totalmente qualificado com o nome tutorial.myExample2.myPrint2 (). Embora a classe myExample2 está fora do delimitem suspensórios de onde o método myPrint2 é chamado, o namespace csharp_station não precisa de ser uma parte do nome totalmente qualificado. Isto porque ambas as classes pertencem ao mesmo namespace, csharp_station.
Note que eu usei nomes diferentes para as duas classes myExample1 e myExample2. Isso foi necessário porque namespace cada membro do mesmo tipo deve ter um nome único. Lembre-se, ambos estão no mesmo namespace e você não gostaria que toda e 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 nenhum efeito, pois as turmas são diferentes, evitando assim qualquer ambiguidade.
Listing 6-5. A utilização 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. Na listagem 6-5, mostramos duas directivas usando. O primeiro, usando o sistema, está usando a mesma 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 (). O seu nome é totalmente qualificado System.Console.WriteLine (...).
Do mesmo modo, usando a directiva usando csharp_station.tutorial nos permite chamar os 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 usar a directiva, teríamos de tipo csharp_station.tutorial.myExample.myPrint () sempre quisemos chamar esse método.
Listing 6-6. O apelido directiva: 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 de tê-lo mais curto. Isto poderia aumentar legibilidade e ainda evitar confrontos com nome similarmente chamado métodos. Listagem 6-6 mostra como criar um alias com a directiva alias 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 utilizamos na Main ().
Também em Main () é uma chamada para o myPrint () AliasDirective o método da classe. Este é o mesmo nome que o myPrint () myExample método na classe. O motivo de ambos estes métodos podem ser chamados, no mesmo método, porque a chamada é myPrint () myExample método na classe é qualificada com o csTut apelido. Isso permite que o compilador saber exactamente qual o método está a ser executada. Se tivéssemos erradamente omitidos csTut o método de chamada, o compilador teria criado o myPrint () AliasDirective o método da classe de 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
Em resumo, você sabe o que é um namespace e você pode declarar a sua própria namespaces. Se você não quiser um tipo totalmente qualificado nome, você sabe como usar a implementar a directiva. Quando você quiser encurtar uma longa declaração namespace, você pode usar o apelido directiva. Além disso, você ter sido introduzida a alguns dos outros membros namespace, para além do tipo de turma.
OBscomo sempre:
[aliasdirective] pode ser compilado, digitando a seguinte linha de comando:
CSC aliasdirective.cs
Pode executar o programa executável, digitando a seguinte linha de comando:
aliasdirective.exe
[namespacecall] pode ser compilado, digitando a seguinte linha de comando:
CSC namespacecall.cs
Pode executar o programa executável, digitando a seguinte linha de comando:
namespacecall.exe
[namespacecss] pode ser compilado bytyping na seguinte linha de comando:
CSC namespacecss.cs
Pode executar o programa executável, digitando o seguinte camm-line:
namespacecss.exe
[nestednamespace1] pode ser compilado, digitando a seguinte linha de comando:
CSC nestednamespace1.cs
Prgram pode executar o executável, digitando a seguinte linha de comando:
nestednamespace1.exe
[nestednamespace2] pode ser compilado, digitando a seguinte linha de comando:
CSC nestednamespace2.cs
Prgram pode executar o executável, digitando a seguinte linha de comando:
nestednamespace2.exe
[usingdirective] pode ser compilado, digitando a seguinte linha de comando:
CSC usingdirective.cs
Pode executar o programa executável, digitando a seguinte linha de comando:
usingdirective.exe
"inté" a proxima...
Ae Winner Gostou do nome agora?? rsrsrss
O namespace seria tipo um package do java?