C # — Пространства имен
Пространство имен предназначено для обеспечения возможности сохранения одного набора имен отдельно от другого. Названия классов, объявленные в одном пространстве имен, не конфликтуют с теми же именами классов, которые были объявлены в другом.
Определение пространства имен
Определение пространства имен начинается с пространства именключевых слов, за которым следует имя пространства имен следующим образом:
namespace namespace_name < // code declarations >Чтобы вызвать версию или функцию, поддерживающую пространство имен, добавьте имя пространства имен следующим образом:
namespace_name.item_name;Следующая программа демонстрирует использование пространств имен:
using System; namespace first_space < class namespace_cl < public void func() < Console.WriteLine("Inside first_space"); >> > namespace second_space < class namespace_cl < public void func() < Console.WriteLine("Inside second_space"); >> > class TestClass < static void Main(string[] args) < first_space.namespace_cl fc = new first_space.namespace_cl(); second_space.namespace_cl sc = new second_space.namespace_cl(); fc.func(); sc.func(); Console.ReadKey(); >>Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
Inside first_space Inside second_spaceИспользование ключевого слова
С помощью ключевых слов говорится о том , что программа использует имена в заданном пространстве имен. Например, мы используем пространство имен System в наших программах. Здесь определен класс Console.
Console.WriteLine ("Hello there");Мы могли бы написать полное имя как:
System.Console.WriteLine("Hello there");Вы также можете избежать добавления пространств имен с помощьюдирективы namespace. Эта директива сообщает компилятору, что последующий код использует имена в указанном пространстве имен. Таким образом, пространство имен подразумевается для следующего кода: Перепишем предыдущий пример, используя директиву:
using System; using first_space; using second_space; namespace first_space < class abc < public void func() < Console.WriteLine("Inside first_space"); >> > namespace second_space < class efg < public void func() < Console.WriteLine("Inside second_space"); >> > class TestClass < static void Main(string[] args) < abc fc = new abc(); efg sc = new efg(); fc.func(); sc.func(); Console.ReadKey(); >>Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
Inside first_space Inside second_spaceВложенные пространства имен
Вы можете определить одно пространство имен внутри другого пространства имен следующим образом:
namespace namespace_name1 < // code declarations namespace namespace_name2 < // code declarations >>Вы можете обращаться к членам вложенного пространства имен с помощью оператора точки (.) Следующим образом:
using System; using first_space; using first_space.second_space; namespace first_space < class abc < public void func() < Console.WriteLine("Inside first_space"); >> namespace second_space < class efg < public void func() < Console.WriteLine("Inside second_space"); >> > > class TestClass < static void Main(string[] args) < abc fc = new abc(); efg sc = new efg(); fc.func(); sc.func(); Console.ReadKey(); >>Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
Inside first_space Inside second_spaceЧто такое пространство имен в си шарп
Обычно определяемые классы и другие типы в .NET не существуют сами по себе, а заключаются в специальные контейнеры — пространства имен . Пространства имен позволяют организовать код программы в логические блоки, поволяют объединить и отделить от остального кода некоторую функциональность, которая связана некоторой общей идеей или которая выполняет определенную задачу.
Для определения пространства имен применяется ключевое слово namespace , после которого идет название название пространства имен:
namespace имя_пространства_имен < // содержимое пространства имен >
Например, определим в файле Program.cs пространство имен, которое будет называться Base
namespace Base < class Person < string name; public Person(string name) =>this.name = name; public void Print() => Console.WriteLine($"Имя: "); > >
Здесь пространство имен содержит класс Person, которой имеет одну переменную — name, конструктор и метод Print.
Теперь попробуем использовать класс Person:
Person tom = new Person("Tom"); // Ошибка - Visual Studio не видит класс Person tom.Print(); namespace Base < class Person < string name; public Person(string name) =>this.name = name; public void Print() => Console.WriteLine($"Имя: "); > >
Здесь на первой строке мы столкнемся с ошибкой, так как Visual Studio не может найти класс Person. Чтобы все-таки обратиться к классу Person, необходимо использовать полное имя этого класса с учетом пространства имен:
Base.Person tom = new("Tom"); tom.Print(); // Имя: Tom namespace Base < class Person < string name; public Person(string name) =>this.name = name; public void Print() => Console.WriteLine($"Имя: "); > >
Поскольку класс Person располагается в пространстве имен Base, то его полное имя — Base.Person . Соответственно, используя это имя, мы можем обращаться к данному классу вне его пространства имен.
Подключение пространства имен
Однако полное имя класса с учетом пространства имен добавляет в код избыточность — особенно, если пространство имен содержит множество классов, которые мы хотим использовать. И чтобы не писать полное имя класса, мы можем просто подключить пространство имен с помощью директивы using :
using Base; // подключение пространства имен Base Person tom = new("Tom"); tom.Print(); // Имя: Tom namespace Base < class Person < string name; public Person(string name) =>this.name = name; public void Print() => Console.WriteLine($"Имя: "); > >
Вложенные пространства имен
Одни пространства имен могут содержать другие. Например:
namespace Base < namespace PersonTypes < class Person < string name; OrganisationTypes.Company company; public Person(string name, OrganisationTypes.Company company) < this.name = name; this.company = company; >public void Print() < Console.WriteLine($"Имя: "); company.Print(); > > > namespace OrganisationTypes < class Company < string title; public Company(string title) =>this.title = title; public void Print() => Console.WriteLine($"Название компании: "); > > >
В данном случае классы Person и Company находятся в разных вложенных пространствах имен, поэтому чтобы в классе Person использовать класс Company, надо прописывать имя класса с учетом его пространства имен: OrganisationTypes.Company (так как оба класса в итоге находятся в общем пространстве — Base, то его имя можно не указывать в названии класса) или подключать пространство имен класса Company с помощью директивы using .
Для обращения к этим классам вне пространства Base необходимо использовать всю цепочку пространств имен:
using Base.PersonTypes; // подключение пространства имен Base.PersonTypes для класса Person Base.OrganisationTypes.Company microsoft = new("Microsoft"); Person tom = new("Tom", microsoft); tom.Print(); // Имя: Tom Название компании: Microsoft namespace Base < namespace PersonTypes < class Person < string name; OrganisationTypes.Company company; public Person(string name, OrganisationTypes.Company company) < this.name = name; this.company = company; >public void Print() < Console.WriteLine($"Имя: "); company.Print(); > > > namespace OrganisationTypes < class Company < string title; public Company(string title) =>this.title = title; public void Print() => Console.WriteLine($"Название компании: "); > > >
Пространства имен уровня файла
Начиная с .NET 6 и C# 10 можно определять пространства имен на уровне файла. Например, добавим в проект новый файл с кодом c#. Для этого в Visual Studio нажмем на название проекта правой кнопкой мыши и в появившемся меню выберем пункт Add -> New Item.
В окне добавления нового элемента выберем пункт Class и поле Name в качестве имени файла укажем Base.cs
После этого в проект будет добавлен файл Base.cs . Удалим из него все содержимое по умолчанию и определим в нем следующий код:
namespace Base; class Person < string name; public Person(string name) =>this.name = name; public void Print() => Console.WriteLine($"Имя: "); >
Директива namespace Base в начале файла указывает, что содержимое файла будет представлять пространство имен Base.
Теперь подключим это пространство имен в файле Program.cs :
using Base; // подключение пространства имен Base Person tom = new("Tom"); tom.Print();
namespace
Ключевое слово namespace используется для объявления области действия, которая содержит набор связанных объектов. Пространство имен можно использовать для организации элементов кода и для создания глобально уникальных типов.
namespace SampleNamespace < class SampleClass < >interface ISampleInterface < >struct SampleStruct < >enum SampleEnum < a, b >delegate void SampleDelegate(int i); namespace Nested < class SampleClass2 < >> > Объявления пространств имен с областью действия файла позволяют объявить, что все типы в файле находятся в одном пространстве имен. Объявления пространств имен с областью действия файла доступны в C# 10. Следующий пример похож на предыдущий, но здесь используется объявление пространства имен с областью действия файла:
using System; namespace SampleFileScopedNamespace; class SampleClass < >interface ISampleInterface < >struct SampleStruct < >enum SampleEnum < a, b >delegate void SampleDelegate(int i); В предыдущем примере не было вложенного пространства имен. Пространства имен с областью действия файла не могут включать дополнительные объявления пространства имен. Вложенное пространство имен или второе пространство имен с областью действия файла объявить нельзя:
namespace SampleNamespace; class AnotherSampleClass < public void AnotherSampleMethod() < System.Console.WriteLine( "SampleMethod inside SampleNamespace"); >> namespace AnotherNamespace; // Not allowed! namespace ANestedNamespace // Not allowed! < // declarations. >В пространстве имен можно объявить ноль или больше следующих типов:
- class
- interface
- struct
- enum
- delegate
- вложенные пространства имен можно объявлять везде, кроме объявлений пространств имен с областью действия файла
Компилятор добавляет пространство имен по умолчанию. Это безымянное пространство имен, иногда называемое глобальным пространством имен, существует в каждом файле. Он содержит объявления, не включенные в объявленное пространство имен. Любой идентификатор в глобальном пространстве имен доступен для использования в именованном пространстве имен.
Об этом не говорится прямо, но пространства имен имеют открытый доступ. Описание модификаторов доступа, которые можно назначить элементам в пространстве имен, см. в разделе Модификаторы доступа.
Пространство имен можно определить в двух или нескольких объявлениях. Например, в следующем примере два класса определяются в качестве части пространства имен MyCompany :
namespace MyCompany.Proj1 < class MyClass < >> namespace MyCompany.Proj1 < class MyClass1 < >> В следующем примере показано, как можно вызвать статический метод вложенного пространства имен.
namespace SomeNameSpace < public class MyClass < static void Main() < Nested.NestedNameSpaceClass.SayHello(); >> // a nested namespace namespace Nested < public class NestedNameSpaceClass < public static void SayHello() < Console.WriteLine("Hello"); >> > > // Output: Hello Спецификация языка C#
Дополнительные сведения см. в статье Пространства имен в разделе Предварительная спецификация C# 6.0. Дополнительные сведения об объявлениях пространств имен с областью действия файла см. в спецификации функций.
См. также раздел
- Параметры объявления пространства имен (IDE0160 и IDE0161)
- справочник по C#
- Ключевые слова C#
- using
- using static
- Квалификатор псевдонима пространства имен ::
- Пространства имен
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
The .NET documentation is open source. Provide feedback here.
Обратная связь
Отправить и просмотреть отзыв по
Что такое пространство имен в си шарп
Пространства имен
В этой статье я хочу рассказать о пространствах имен в C#. Пространство имен (namespace) в C# представляет собой некий контейнер для логического объединения именованных сущностей, таких как классы, интерфейсы, перечисления и тому подобное. Для чего нужны такие контейнеры? Ну во-первых, пространства имен позволяют логически группировать классы и другие сущности, а во-вторых, позволяют использовать одни и те же имена для сущностей в разных пространствах имен. Причем, вторая функция даже больше востребована, так как логическую группировку тех же классов, программист может игнорировать, особенно, если классов не так много, а вот создать два класса с одним именем уже нельзя, не даст компилятор!
Как создаются пространства имен? Да всё просто, мы уже сталкивались с ними. При создании нового проекта в Visual Studio автоматически создавалось пространство имен. Рассмотрим код основного файла только что созданного, консольного приложения:
//Блок подключения других пространств имен using System; using System.Collections.Generic; using System.Linq; using System.Runtime.InteropServices; using System.Text; //Пространство имен с названием "TestProject" namespace TestProject < //Начало пространства имен //Основной класс программы class Program < //Главный метод программы (точка входа) static void Main(string[] args) < >> > //Конец пространства имен
Обратите внимание на выделенную строку, в ней и создается пространство имен, т.е. для этого используется ключевое слово namespace, после которого, через пробел, указывается название пространства имен. И всё, что объявляется внутри фигурных скобок, следующих на за названием, относится к пространству имен.
А теперь, давайте разберемся, как же пространства имен, позволяют использовать одни и те же имена для сущностей. Дело в том, что пространство имен, как бы задает префикс к имени любой сущности, в нем объявленной. Но мы этого не замечаем, если работаем с этой сущностью в том пространстве имен, в котором она объявлена. Таким образом имя сущности, например класса, на сомом деле становится ка бы составным. Сейчас я покажу как это выглядит на практике, для этого представим,что у нас есть класс «SomeClass«, который объявлен в пространстве имен «SomeNamespace«, тогда доступ к этому классу из метода «Main» был бы примерно таким:
//Главный метод программы (точка входа) static void Main(string[] args) < //Создание объекта класса SomeClass из пространства имен SomeNamespace SomeNamespace.SomeClass tmpObj = new SomeNamespace.SomeClass(); >
Т.е. перед указанием имени класса, указывает имя пространства имен, к которому он принадлежит, а уже потом, через точку — имя самого класса. Пространство имен «SomeNamespace«, как бы ограничивает область видимости для класса «SomeClass«, и получить доступ, к этому классу мы можем только через пространство имен, его содержащее.
А теперь представим, что у нас есть еще один класс с именем «SomeClass«, но принадлежащий пространству имен «OtherNamespace«, и тогда создание его объекта в том же методе «Main» будет таким:
//Главный метод программы (точка входа) static void Main(string[] args) < //Создание объекта класса SomeClass из пространства имен OtherNamespace OtherNamespace.SomeClass tmpObj = new OtherNamespace.SomeClass(); >
Как видите, используя пространства имен, мы можем конкретно указать нужный нам класс, если его имя совпадает с каким-либо классом из другого пространства имен. Но мы получаем и побочный эффект — имена сущностей становятся длиннее, и не всегда хочется писать лишний код. К счастью, выход есть и из этой ситуации. Если мы точно уверены, что ни одна сущность из пространства имен «SomeNamespace» не будет создавать конфликты имен с сущностями текущей области видимости, мы можем его подключить («раскрыть») всего одной строкой кода:
using SomeNamespace;
Которую добавляют, как правило, в самом начале файла с исходным кодом (обратите внимание на начало первого из примеров). И тогда, в методе «Main», мы сможем создавать объект класса «SomeClass» так (без явного указания пространства имен, к которому он принадлежит):
//Главный метод программы (точка входа) static void Main(string[] args) < //Создание объекта класса SomeClass из пространства имен SomeNamespace SomeClass tmpObj = new SomeClass(); >
Но подключить оба наших вымышленных пространства имен в одном файле, мы уже не сможем, так как, они содержать две одноименных сущности (в данном случае, два класса «SomeClass»).
Так же, пространства имен могут быть вложенными, т.е. одно пространство имен может находиться внутри другого, например так:
//Какое-то пространство имен namespace SomeNamespace < //Вложенное пространство имен namespace OtherNamespace < //Некий класс class SomeClass < >> >
В приведенном примере, класс «SomeClass» принадлежит пространству имен «OtherNamespace«, а то, в свою очередь, вложено в пространство «SomeNamespace«. А полное имя класса «SomeClass» будет таким:
SomeNamespace.OtherNamespace.SomeClass
Вот, пожалуй, и вся основная информация о пространствах имен в C#, Вы узнали что это такое, как их создавать, как подключать пространства имен.
Добавить комментарий Отменить ответ
Для отправки комментария вам необходимо авторизоваться.