Пространства имен

В одной из первых статей мы кратко обсудили пространства имен. Вы, вероятно, узнаете ключевое слово, потому что оно находится в большинстве файлов, содержащих код C#, обычно почти в верхней части. Пространство имен-это, по сути, способ группировки набора типов, например классов, в собственном именованном пространстве. При создании нового проекта Visual Studio также создает пространство имен по умолчанию, в которое помещается первый файл (по крайней мере, это верно для типа проекта консольного приложения). Это может выглядеть так:

using System;  

namespace MyProject  
{  
    class Program  
    {  
    static void Main(string[] args)  
    {  
        // More code below this....

В этом случае пространство имен "MyProject" теперь является частью приложения и при использовании его классов вне его, вам придется использовать префикс ими класса с именем пространства имен. Вы видите то же самое, когда хотите использовать что-то скрытое глубоко в .NET framework, например:

System.IO.File.ReadAllText("test.txt");

В этом случае, мы используем ReadAllText() метод найденный в классе File, который существует в пространстве имен System.IO. Конечно, было бы утомительно писать такое длинное имя каждый раз, когда вы хотите использовать класс из пространства имен, поэтому C# позволяет "импортировать" все пространство имен в область вашего файла с помощью оператора using. Опять же, вы, возможно, уже знаете их, потому что вы обычно можете найти их в верхней части ваших файлов C#. В приведенном выше примере, если нам потребуется класс File более одного раза, имеет смысл импортировать пространство имен System.IO с помощью оператора using, как это сделано здесь:

using System;
using System.IO;
// More using statements here...

Для чего нужны пространства имен?

Если вы только начали программировать, вы можете задаться вопросом, для чего нам нужны пространства имен. Почему бы просто не поместить все ваши классы в те же пространства имен, чтобы они всегда были доступны? У вас есть действительный пункт, но только если ваш проект очень мал. Как только вы начинаете добавлять все больше и больше классов, имеет смысл разделить их на пространства имен. Это просто упрощает поиск кода, особенно если файлы размещаются в соответствующих папках . фактически, если добавить папку в проект, а затем добавить в него класс, Visual Studio автоматически поместит его в соответствующее пространство имен. Таким образом, если создать папку в MyProject с именем MyFolder, классы, добавленные в эту папку, по умолчанию будут помещены в пространство имен с именем MyProject.MyFolder.

Отличный пример того, зачем нужны пространства имен это сам .NET framework. Только подумайте, если бы все классы в нем просто плавали в глобальном пространстве имен - это был бы беспорядок! Вместо этого, они организовали красиво, с System в качестве корневого пространства имен для большинства классов, а затем суб-пространства имен, например System.IO для материалов ввода/вывода, в System.Net для поиска в сети материалов и System.Net.Mail для вещей, связанных с почтой.

Конфликт имен в Пространстве имен

Как уже упоминалось, пространства имен также предназначены для инкапсуляции типов (обычно классов), чтобы они могли существовать в собственном домене. Это также означает, что вы можете создавать классы с тем же именем, что и в других частях проекта или даже в .NET framework. Например, вы можете решить, что вам нужен собственный класс файлов File. Как мы видели в предыдущих примерах, такой класс уже существует в пространстве имен System.IO, но вы можете создать его в своем собственном пространстве имен, например:

using System;  

namespace MyProject.IO  
{  
    class File  
    {  
    public static void HelloWorld()  
    {  
        Console.WriteLine("Hello, world!");  
    }  
    }  
}

Теперь, когда вы хотите использовать его в своем проекте, например, в своей программе на С# метод Main (если вы работаете с Консольным приложением, как я), Вы можете написать полное имя:

MyProject.IO.File.HelloWorld();

Но вы также можете импортировать пространство имен, как и любое другое пространство имен (встроенное или определяемое пользователем), благодаря оператору using. Вот более полный пример:

using System;
using MyProject.IO;

namespace MyProject
{
    class Program
    {
    static void Main(string[] args)
    {
        File.HelloWorld();
    }
    }
}

Пока все хорошо! Однако, если вы хотите использовать файл класса из пространства имен System.IO? Ну, вот где начинаются проблемы. Потому что если вы импортируете это пространство имен, а также, с помощью оператора using, компилятор больше не знает, какой файловый класс вы имеете в виду - наш собственный или один из System.IO. Это можно решить, импортировав одно из пространств имен (в идеале то, из которого вы используете большинство типов), а затем полностью указав имя другого, как в этом примере:

using System;
using System.IO;

namespace MyProject
{
    class Program
    {
    static void Main(string[] args)
    {
        MyProject.IO.File.HelloWorld();
    }
    }
}

Но это немного громоздко вводить каждый раз, особенно если ваш класс еще глубже вложен в пространства имен, например MyProject.FileStuff.IO.File. К счастью, в C# есть решение для этого.

Использование директивы Alias

Чтобы сократить имя пространства имен, можно импортировать пространство имен под другим именем с помощью директивы Alias. Обратите внимание, как я это делаю в следующем примере:

using System;
using System.IO;
using MyIO = MyProject.IO;

namespace MyProject
{
    class Program
    {
    static void Main(string[] args)
    {
        File.ReadAllText("test.txt");
        MyIO.File.HelloWorld();
    }
    }
}

Волшебство происходит в третьей строке, где я обращаюсь к MyProject.IO и даю ему более короткое имя (MyIO), которые затем может быть использовано, когда мы хотим получить доступ к типам из него. На данный момент мы не экономим много нажатий клавиш, но опять же вы должны представить себе еще более длинные имена и уровни пространств имен, и поверьте мне, они могут быть довольно длинными и вложенными.

Резюме

Пространства имен дают возможность инкапсулировать типы в "именованные пространства", что позволяет получить лучшую структуру в коде, а также иметь несколько классов с одинаковыми именами, если они существуют в отдельных пространствах имен.