Что такое using namespace System?
При созданиии windows формы, там в началаа сразу уже написано вот это:
1 2 3 4 5 6
using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing;
Я знаю только, что namespace — это пространство имён и using namespace нужно для того, чтобы не укказывать пространство имён перд каждым идентификатором. А вот в конкретно этом примере какую роль играют эти нэймспэйсы?
Namespace system c что это
Пространства имен
В этой статье я хочу рассказать о пространствах имен в 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#, Вы узнали что это такое, как их создавать, как подключать пространства имен.
Добавить комментарий Отменить ответ
Для отправки комментария вам необходимо авторизоваться.
Namespace system c что это
Обычно определяемые классы и другие типы в .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) в C#
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
Пространства имен (namespace) позволяют выделять определенные части ваших приложений (классы, интерфейсы и т.д.) в логические блоки. Такой подход позволяет сделать код приложения более читабельным и понятным. Сама платформа .NET активно использует пространства имен для создания стройной и логичной структуры своих классов и объектов. Например, в пространстве имен System расположены все основные классы и объекты для работы (тот же класс Console ), а в пространстве имен System.Text.Json — классы для работы с JSON и так далее.
Чтобы определить пространство имен используется следующая конструкция:
namespace [название_пространства_имен]
С пространствами имен мы сталкиваемся уже на этапе знакомства с C#. Например, шаблонное консольное приложение для .NET 5 и более ранних версий выглядит следующим образом:
using System; namespace ConsoleApp1 < internal class Program < static void Main(string[] args) < Console.WriteLine("Hello World!"); >> >
Здесь уже создано пространство имен для нашего приложения — ConsoleApp1 .
Использование пространств имен в проектах C#
Чтобы ваше приложение имело возможность использовать какие-либо классы платформы .NET необходимо подключить требуемое пространство имен в ваш проект. Для подключения пространства имен в проект используется ключевое слово using . Например, подключим к нашему проекту пространство имен, которое позволит работать с текстом:
using System; using System.Text; //подключаем пространство имен namespace ConsoleApp1 < internal class Program < static void Main(string[] args) < StringBuilder stringBuilder = new(); //для .NET Core 3.1 и более ранних версий: StringBuilder stringBuilder = new StringBuilder(); stringBuilder.AppendLine("Hello World"); stringBuilder.AppendLine("Учимся подключать пространства имен"); Console.WriteLine(stringBuilder.ToString()); >> >
Вложенные пространства имен
Пространства имен в C# могут быть вложенными. Например, мы можем организовать вот такую логическую структуру нашего проекта:
using System; using System.Text; //подключаем пространство имен namespace ConsoleApp1 < //вложенное пространство имен namespace MyNamespace < public class Data < public string Name < get; set; >public string Value < get; set; >> > internal class Program < static void Main(string[] args) < >> >
Здесь мы определили вложенное пространство имен (namespace) MyNamespace . Теперь, чтобы использовать класс Data мы должны сделать так:
internal class Program < static void Main(string[] args) < MyNamespace.Data data = new() < Name = "Привет", Value = "Мир!" >; > >
то есть, перед именем класса ( Data ) мы указываем название пространства имен ( MyNamespace ).
Хоть .NET C# и позволяет создавать вложенные пространства имен, но увлекаться таким подходом к организации проекта лучше не стоит, так как в итоге можно получить такую «логическую» структуру с которой и сам разработчик через год не разберется
Более предпочтительным с точки зрения читабельности и поддержки проекта является организация пространства имен непосредственно через обозреватель решений Visual Studio. По умолчанию Visual Studio создает новое пространство имен в проекте на каждую папку в проекте. Например, создадим в нашем проекте попку с именем Base:
Теперь кликнем по папке правой кнопкой мыши, выберем в меню пункт «Добавить» и «Создать элемент»:
Создадим новый класс с названием BaseClass :
Обратите внимание на то, какое имя пространству имен присвоила Visual Studio:
По умолчанию, Visual Studio создала новый класс в пространстве имен составленному по шаблону: [Имя_проекта].[Папка_с_файлом]
Аналогичным образом мы можем создать поддиректорию в папке Base и пространство имен снова будет соответствовать физическому пути на диске, например:
namespace ConsoleApp1.Base.Interfaces < internal interface IView < >>
Физически этот интерфейс располагается по пути /Base/Interfaces/IView.cs
Таким образом, мы, с одной стороны можем логически разделять отдельные классы и объекты по пространствам имен, а, с другой стороны — подобное разделение (с использованием папок) будет наглядно видно в «Обозревателе решений»:
Глобальные пространства имен и пространства имен уровня файла
Начиная с версии .NET 6 и C# 10 мы можем задавать глобальные пространства имен и пространства имен уровня файла.
Глобальные пространства имен
Глобальные пространства имен удобно использовать в том случае, если вам необходимо использовать это пространство имен во всем (или в большинстве файлов) проекте. Например, уже используемое нами пространство имен System можно определить как глобальное. Чтобы определить глобальное пространство имен необходимо перед его объявлением использовать ключевое слово global .
global using System; //глобальное пространство имен namespace ConsoleApp1 < internal class Program < static void Main(string[] args) < Console.WriteLine("Привет Мир!"); >> >
Теперь нам нет необходимости в каждом файле проекта для которого необходимо использование пространства имен System использовать конструкцию using System; .
namespace ConsoleApp1.Base < internal class BaseClass < public BaseClass() < Console.WriteLine("Привет, Мир!");//класс Console взят из глобального пространства имен >> >
Глобальные пространства имен можно определять в любом месте проекта, однако при этом, пространство имен с параметром global всегда должно находиться в коде выше, чем пространство имен без global :
Как можно видеть на скриншоте, Visual Studio указывает нам на то, что пространство имен с global необходимо перенести ВЫШЕ. И хоть мы имеем право определить глобальное пространство в любом удобном для нас месте, все же стоит придерживаться элементарных правил хорошего тона и постараться обеспечить поддержку нашего проекта в любом обозримом будущем. Поэтому все глобальные пространства имен лучше вынести в отдельный файл и назвать этот файл наиболее подходящим образом, например, GlobalUsings.cs или GlobalNamespaces.cs :
//Файл с глобальными пространствами имен global using System; global using System.Data; global using System.Data.Common;
В обозревателе решений этот файл находится на самом верхнем уровне в проекте:
Пространства имен уровня файла
Пространство имен уровня файла указывает на то, что всё, что содержится в файле относится к этому пространству имен. Чтобы определить пространство имен уровня файла в C# необходимо использовать конструкцию namespace без фигурных скобок, например:
//всё содержимое файла относится к этому пространству имен namespace ConsoleApp1.Base; internal class BaseClass < public BaseClass() < //класс Console взят из глобального пространства имен Console.WriteLine("Привет, Мир!"); >>
Итого
Пространства имен в C# ( namespace ) — это, в первую очередь, логические структуры, которые позволяют разделить используемые в проекте классы и объекты по определенным признакам и сделать проект полее комфортным с точки зрения его поддержки. Начиная с .NET 6 C# 10, пространства имен могут быть глобальными (обозначаются ключевым словом global ) и пространствами имен уровня файла.
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.