Урок 16. Пространства имен .NET

Шестнадцатая часть учебника по объектно-ориентированному программированию на языке C# описывает использование пространств имен. Пространства имен позволяют группировать и организовывать классы, структуры и другие элементы, а также устраняют возможность конфликтов именования классов.

Что такое пространство имен?

По мере развития языков программирования фреймворки вокруг них значительно увеличились в размерах. .Net предоставляет огромное количество базовых классов, типов данных, алгоритмов и т. д. Если бы каждый из этих элементов должен был быть объявлен с уникальным именем, задача именования была бы довольно сложной и оставила бы очень мало хороших имен, доступных для разработчика .NET.

Чтобы гарантировать, что конфликты имен не возникнут ни в рамках .NET framework, ни в ваших собственных программах, используются пространства имен. Пространство имен просто предоставляет именованную группу классов, структур, перечислений, делегатов, интерфейсов и других пространств имен. В пространстве имен все объявленные элементы должны иметь уникальные имена. Однако одно и то же имя может дублироваться в разных пространствах имен. Это означает, что если вы решите создать математическую библиотеку, вы сможете назвать ее "Math", хотя Microsoft также предоставила математическую библиотеку.

Все определения создаются в пространстве имен, даже если оно явно не объявлено. Платформа .NET framework предоставляет пространство имен по умолчанию, которое автоматически используется для любого кода, написанного вне любого объявления пространства имен. Это может быть полезно для коротких программ, но имеет тот недостаток, что все преимущества, которые пространства имен приносят для организации вашего кода, теряются.

Объявление пространства имен

Пространства имен объявляются с помощью ключевого слова namespace. Основной синтаксис для создания пространства имен очень прост, требуется только имя для новой группировки и блок кода, окруженный фигурными скобками:

namespace namespace-name {}

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

Чтобы продемонстрировать создание пространства имен, мы создадим некоторый код. Для начала создайте новое консольное приложение с именем NamespaceDemo. Если вы создаете проект с помощью Visual Studio, вы заметите, что автоматически созданный класс программы существует в пространстве имен, которое также называется "NamespaceDemo".

В одном файле кода можно определить несколько пространств имен. В этом случае мы добавим наше новое пространство имен в тот же файл, что и автоматически созданное. Добавьте следующее пространство имен и содержащий его класс в качестве основания кода, вне блока кода существующего пространства имен:

namespace FirstNamespace
{
    class Test
    {
        public void ShowMessage()
        {
            Console.WriteLine("This is the first namespace!");
        }
    }
}

Этот код создает новое пространство имен с именем FirstNamespace и определяет класс "Test", содержащий один метод, который выводит строку в консоль. Теперь мы можем добавить второе пространство имен, опять же в конце кода:

namespace SecondNamespace
{
    class Test
    {
        public void ShowMessage()
        {
            Console.WriteLine("This is the second namespace!");
        }
    }
}

Второе пространство имен также включает класс с именем "Test". Это не приводит к конфликту именования, поскольку два класса логически разделены пространствами имен. Это означает, что программа будет компилироваться без ошибок.

Аддитивные объявления пространств имен

Объявления пространства имен являются аддитивными. Это означает, что одно и то же определение пространства имен может быть включено в код в нескольких местах. Если сделано два или более соответствующих объявления, содержимое двух пространств имен объединяется в одно. Это особенно полезно, когда приложение может быть развернуто в разных версиях, поскольку дополнительный код может быть помещен в отдельные файлы кода. Затем файлы можно "поменять местами" для создания различных конфигураций сборки.

Добавление следующего кода расширит пространство имен FirstNamespace, добавив второй класс:

namespace FirstNamespace
{
    class ShortTest
    {
        public void ShowShortMessage()
        {
            Console.WriteLine("First namespace!");
        }
    }
}

Ссылка на класс в другом пространстве имен

Полное имя

Пространства имен предотвращают конфликты между именами классов, изолируя содержимое каждого пространства имен. В приведенном выше примере код, созданный в классе "Program", не может получить доступ к классам в пространствах имен" FirstNamespace "и" SecondNamespace", просто ссылаясь на тестовый класс. Если основной метод программы будет обновлен следующим образом, код не будет компилироваться, так как не будет найден класс Test:

static void Main(string[] args)
{
Test t = new Test();// не компилируется
}

Для решения этой проблемы можно использовать полное имя класса. Полное имя - это имя, уникальное для всего приложения, включая классы самой платформы .NET framework. Имя создается путем простого префикса имени класса с пространством имен, в котором он существует. Эти два имени разделены символом полной остановки (или точки). Следующий обновленный код добавляет пространство имен и успешно компилируется.

static void Main(string[] args)
{
    FirstNamespace.Test t = new FirstNamespace.Test();
}

Директива using

Если бы Вы были обязаны префиксировать каждое использование каждого класса, структуры, перечисления и т. д. с именем пространства имен, содержащего его, ваш код станет громоздким. Чтобы избежать этого, можно использовать директиву using. Вы уже видели эту директиву в действии в начале почти каждого созданного вами файла кода.

Директива using сообщает компилятору, что пространство имен используется кодом. Когда компилятор находит имя класса, которое не распознается в текущем пространстве имен, он вместо этого проверяет каждое пространство имен, определенное в директиве using, чтобы увидеть, существует ли там элемент. Это означает, что полное имя элементов в таком ссылочном пространстве имен использоваться не требуется.

Чтобы добавить директиву using в код, ключевое слово using и имя пространства имен добавляются в начале файла кода. Например, чтобы добавить ссылку на пространство имен FirstNamespace, добавьте следующую строку в начале кода:

using FirstNamespace;

Теперь, когда компилятор знает, что это разрешено, чтобы проверить внутри "FirstNamespace", чтобы соответствовать имена классов, основной метод может быть обновлен, чтобы сделать его более удобным для чтения:

static void Main(string[] args)
{
    Test t = new Test();
}

Создание псевдонимов

Директива using, как показано выше, может обеспечить гораздо более аккуратный код. Однако если включены две директивы using и каждое ссылочное пространство имен содержит соответствующее имя класса, создается конфликт имен. Чтобы показать эту проблему, добавьте вторую директиву using в код, ссылающийся на пространство имен SecondNamespace:

using SecondNamespace;

Теперь, когда оба дополнительных пространства имен ссылаются, компилятор не знает, какой тестовый класс использовать при создании объекта в основном методе. Попытка скомпилировать программу приводит к ошибке, которая объясняет, что "тTest" теперь является неоднозначной ссылкой.

Эта проблема может быть решена простым предоставлением полного имени при использовании тестовых классов. Однако имена пространств имен могут быть очень длинными, и это создает оригинальную проблему, затрудняющую чтение кода. Вместо этого директиву using можно использовать для создания псевдонима. Это позволяет связать более короткое имя с пространством имен и использовать его вместо пространства имен для квалификации класса.

Для создания псевдонима используется следующий синтаксис:

using alias-name = namespace;

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

using First = FirstNamespace;
using Second = SecondNamespace;

Добавление псевдонимов удаляет возможность ссылаться на классы без предоставления псевдонима полного имени. Чтобы сделать возможным повторную компиляцию программы, измените объявление тестового объекта в методе Main для добавления псевдонима:

First.Test t = new First.Test();

Вложенное пространство

Мы видели, как классы и другие элементы могут быть объявлены в пространстве имен, чтобы обеспечить группировку элементов кода и изоляцию имен для предотвращения конфликтов. Кроме того, пространства имен могут быть созданы в других пространствах имен для создания вложенной классификации. Это позволяет создавать глубокие древовидные структуры и осуществлять большой контроль над организацией модулей кода.

Рассмотрим следующие объявления вложенных пространств имен:

namespace Parent
{
    namespace Child
    {
        namespace Grandchild
        {
            class Test
            {
                public void ShowMessage()
                {
                    Console.WriteLine("This is a nested namespace!");
                }
            }
        }
    }
}

В этом случае существует три уровня пространства имен, каждый из которых объявлен внутри своего родителя. Класс "Test" объявляется в пределах третьего уровня вложенности. Чтобы получить доступ к этому классу, используя его полное имя, все три пространства имен должны быть указаны с каждым префиксом его дочернего элемента и разделены с помощью полной остановки. Таким образом, полное имя тестового класса - "Parent.Ребенок.Внук.Испытание".

Как и в случае однослойных пространств имен, директива using может быть добавлена для удаления требования использовать полное имя. В этом случае директива using будет иметь вид:

using Parent.Child.Grandchild;

Более короткая нотация существует для объявления вложенного пространства имен, когда классы и другие объявления существуют только на самом глубоком уровне иерархии. Вместо того, чтобы определять каждое пространство имен по отдельности, пространства имен могут быть созданы в одном операторе, опять же с каждым пространством имен, разделенным полной остановкой. Следующий код функционально эквивалентен предыдущему образцу вложенных пространств имен:

namespace Parent.Child.Grandchild
{
    class Test
    {
        public void ShowMessage()
        {
            Console.WriteLine("This is a nested namespace!");
        }
    }
}

Соглашение об именовании пространств имен

Чтобы избежать конфликтов с пространствами имен .NET framework и многими сторонними поставщиками компонентов, Корпорация Майкрософт предложила соглашение об именовании. Соглашение должно использоваться для всех создаваемых пространств имен.

Предлагаемое пространство имен должно иметь следующий формат:

CompanyName.TechnologyName.Feature.Design

В этом соглашении об именовании CompanyName - это имя компании или бренда, которому принадлежит код. Для длинных названий компаний это должно быть уменьшено в размере, но стандартизировано по всей организации. TechnologyName относится к высокоуровневой технологии, к которой относятся классы в пространстве имен. Например, "Xml" для функций XML.

Feature - это необязательный элемент, который дает имя объекту в пространстве имен технологии. Наконец, пространство имен "Design" предлагается для пространств имен, содержащих функциональные возможности времени разработки. Примером пространства имен, содержащего элементы времени разработки пользовательских элементов управления мультимедиа для DVD-фильмов, может быть:

Upread.Ru.Media.Dvd.Design