Using c что это

В прошлой теме, где рассматривалась реализация метода Dispose, говорилось, что для его вызова можно использовать следующую конструкцию try..catch:

Однако синтаксис C# также предлагает синонимичную конструкцию для автоматического вызова метод Dispose — конструкцию using :

Конструкция using оформляет блок кода и создает объект некоторого типа, который реализует интерфейс IDisposable, в частности, его метод Dispose. При завершении блока кода у объекта вызывается метод Dispose.

Важно, что данная конструкция применяется только для типов, которые реализуют интерфейс IDisposable.

Здесь мы видим, что по завершении блока using у объекта Person вызывается метод Dispose. Вне блока кода using объект tom не существует.

Начиная с версии C# 8.0 мы можем задать в качестве области действия всю окружающую область видимости, например, метод:

В данном случае using сообщает компилятору, что объявляемая переменная должна быть удалена в конце области видимости — то есть в конце метода Test. Соответственно мы получим следующий консольный вывод:

Освобождение множества ресурсов

Для освобождения множества ресурсов мы можем применять вложенные конструкции using. Например:

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

Мы можем сократить это определение:

И, как уже было выше сказано, в C# мы можем задать в качестве области действия для объектов, создаваемых в конструкции using, весь метод:

Using или Using?

Заголовок этого сообщения обескураживает, не правда ли? Тем не менее, вы достаточно сообразительны, чтобы догадаться, о чем пойдет речь. На собеседовании по .NET часто задают вопрос: ”Чем отличаются директива using и оператор using?” Иногда перед соискателем ставят дополнительные ловушки, спрашивая, в каких местах программы можно использовать using? Первое, что приходит в голову, это использование директивы using, которая применяется для определения или разрешения использования типов как пространств имен. Например, следующий фрагмент кода демонстрирует включение некоторых пространств имен с помощью директивы using.

Погодите! Это не всё! Есть нечто, называемое “директивой псевдонимов (aliasing directive)” и ее можно использовать, как показано в следующей строке кода. Это может быть промежуточной частью ответа на вопрос.

Теперь вернемся к оператору using, который задает область видимости, вне которой объект недоступен. Рассмотрим следующий пример:

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

Name already in use

docs / docs / csharp / language-reference / keywords / using-directive.md

Go to file T
Go to line L
Copy path
Copy permalink

Open with Desktop
View raw
Copy raw contents Copy raw contents

Copy raw contents

The using directive allows you to use types defined in a namespace without specifying the fully qualified namespace of that type. In its basic form, the using directive imports all the types from a single namespace, as shown in the following example:

You can apply two modifiers to a using directive:

The global modifier has the same effect as adding the same using directive to every source file in your project. This modifier was introduced in C# 10.
The static modifier imports the static members and nested types from a single type rather than importing all the types in a namespace.

You can combine both modifiers to import the static members from a type in all source files in your project.

You can also create an alias for a namespace or a type with a using alias directive.

You can use the global modifier on a using alias directive.

[!NOTE] The using keyword is also used to create using statements, which help ensure that xref:System.IDisposable objects such as files and fonts are handled correctly. For more information about the using statement, see using Statement.

The scope of a using directive without the global modifier is the file in which it appears.

The using directive can appear:

At the beginning of a source code file, before any namespace or type declarations.
In any namespace, but before any namespaces or types declared in that namespace, unless the global modifier is used, in which case the directive must appear before all namespace and type declarations.

Otherwise, compiler error CS1529 is generated.

Create a using directive to use the types in a namespace without having to specify the namespace. A using directive doesn’t give you access to any namespaces that are nested in the namespace you specify. Namespaces come in two categories: user-defined and system-defined. User-defined namespaces are namespaces defined in your code. For a list of the system-defined namespaces, see .NET API Browser.

Adding the global modifier to a using directive means that using is applied to all files in the compilation (typically a project). The global using directive was added in C# 10. Its syntax is:

where fully-qualified-namespace is the fully qualified name of the namespace whose types can be referenced without specifying the namespace.

A global using directive can appear at the beginning of any source code file. All global using directives in a single file must appear before:

All using directives without the global modifier.
All namespace and type declarations in the file.

You may add global using directives to any source file. Typically, you’ll want to keep them in a single location. The order of global using directives doesn’t matter, either in a single file, or between files.

The global modifier may be combined with the static modifier. The global modifier may be applied to a using alias directive. In both cases, the directive’s scope is all files in the current compilation. The following example enables using all the methods declared in the xref:System.Math?displayProperty=fullName in all files in your project:

You can also globally include a namespace by adding a <Using> item to your project file, for example, <Using Include=»My.Awesome.Namespace» /> . For more information, see <Using> item.

The using static directive names a type whose static members and nested types you can access without specifying a type name. Its syntax is:

The <fully-qualified-type-name> is the name of the type whose static members and nested types can be referenced without specifying a type name. If you don’t provide a fully qualified type name (the full namespace name along with the type name), C# generates compiler error CS0246: «The type or namespace name ‘type/namespace’ couldn’t be found (are you missing a using directive or an assembly reference?)».

The using static directive applies to any type that has static members (or nested types), even if it also has instance members. However, instance members can only be invoked through the type instance.

You can access static members of a type without having to qualify the access with the type name:

Ordinarily, when you call a static member, you provide the type name along with the member name. Repeatedly entering the same type name to invoke members of the type can result in verbose, obscure code. For example, the following definition of a Circle class references many members of the xref:System.Math class.

. code language=»csharp» source=»./snippets/using-static1.cs» .

By eliminating the need to explicitly reference the xref:System.Math class each time a member is referenced, the using static directive produces cleaner code:

. code language=»csharp» source=»./snippets/using-static2.cs».

using static imports only accessible static members and nested types declared in the specified type. Inherited members aren’t imported. You can import from any named type with a using static directive, including Visual Basic modules. If F# top-level functions appear in metadata as static members of a named type whose name is a valid C# identifier, then the F# functions can be imported.

using static makes extension methods declared in the specified type available for extension method lookup. However, the names of the extension methods aren’t imported into scope for unqualified reference in code.

Methods with the same name imported from different types by different using static directives in the same compilation unit or namespace form a method group. Overload resolution within these method groups follows normal C# rules.

The following example uses the using static directive to make the static members of the xref:System.Console, xref:System.Math, and xref:System.String classes available without having to specify their type name.

. code language=»csharp» source=»./snippets/using-static3.cs» .

In the example, the using static directive could also have been applied to the xref:System.Double type. Adding that directive would make it possible to call the xref:System.Double.TryParse(System.String,System.Double@) method without specifying a type name. However, using TryParse without a type name creates less readable code, since it becomes necessary to check the using static directives to determine which numeric type’s TryParse method is called.

using static also applies to enum types. By adding using static with the enum, the type is no longer required to use the enum members.

Create a using alias directive to make it easier to qualify an identifier to a namespace or type. In any using directive, the fully qualified namespace or type must be used regardless of the using directives that come before it. No using alias can be used in the declaration of a using directive. For example, the following example generates a compiler error:

The following example shows how to define and use a using alias for a namespace:

. code language=»csharp» source=»./snippets/csrefKeywordsNamespace2.cs» .

A using alias directive can’t have an open generic type on the right-hand side. For example, you can’t create a using alias for a List<T> , but you can create one for a List<int> .

The following example shows how to define a using directive and a using alias for a class:

. code language=»csharp» source=»./snippets/csrefKeywordsNamespace2.cs» .

How to use the Visual Basic My namespace

The xref:Microsoft.VisualBasic.MyServices namespace ( My in Visual Basic) provides easy and intuitive access to a number of .NET classes, enabling you to write code that interacts with the computer, application, settings, resources, and so on. Although originally designed for use with Visual Basic, the MyServices namespace can be used in C# applications.

For more information about using the MyServices namespace from Visual Basic, see Development with My.

You need to add a reference to the Microsoft.VisualBasic.dll assembly in your project. Not all the classes in the MyServices namespace can be called from a C# application: for example, the xref:Microsoft.VisualBasic.MyServices.FileSystemProxy class is not compatible. In this particular case, the static methods that are part of xref:Microsoft.VisualBasic.FileIO.FileSystem, which are also contained in VisualBasic.dll, can be used instead. For example, here is how to use one such method to duplicate a directory:

. code language=»csharp» source=»./snippets/Namespaces3.cs» .

C# language specification

For more information, see Using directives in the C# Language Specification. The language specification is the definitive source for C# syntax and usage.

For more information on the global using modifier, see the global usings feature specification — C# 10.

Пространства имен и директивы в C#

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

Директива – это…

Директива – это указание. Определение соответствующего понятия в программировании напоминает термин «команда». Он используется для описания некоторых конструкций ЯП. Указывает, как компилятор или любой иной транслятор должен обрабатывать вводимые данные.

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

Иногда подобные компоненты отвечают за определение глобального поведения, а в некоторых ситуациях действуют локально. В программах на C не являются обязательными. Они могут быть проигнорированы компилятором. Чаще всего носят предписывающий характер. В самом языке директивы (using и не только) не отвечают за выполнение тех или иных действий ЯП – они лишь корректируют поведение компиляторов.

Пространства имен – что это

Пространства имен (namespace) – это то, что позволяет выделить определенные части приложений в логические блоки. Поддерживается работа с:

классами;
интерфейсами;
прочими элементами программного кода.

Подобная концепция позволяет сделать исходный код более читабельным и понятным. Пространства имен применяются специально для организации классов. Помогают контролировать область применения методов в более крупных проектах.

При помощи упомянутого элемента можно сохранить один набор имен (пример – имена классов) отличным от других наборов имен. Преимуществом такого подхода является то, что имена классов, объявленные в пределах одного пространства, не конфликтуют с аналогичными, но в других пространствах.

Членами могут выступать:

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

Пространства имен можно охарактеризовать как группу классов, обладающих общими признаками.

Свойства

Перед тем как изучить директиву using, требуется запомнить следующие свойства именных пространств:

организация масштабных проектов по созданию программных кодов;
разделение происходит при помощи оператора «.» (точки);
global – корневая область имен.

Using – директива, которая позволяет исключить требование на указание названия области имен для каждого класса. Данный компонент избавляет от полной классификации «названий». Далее соответствующий элемент будет рассмотрен более подробно.

Using – описание

Директивы using – это то, что производит импорт именных областей, избавляя разработчика от полной классификации имен стереотипов. Дает возможность задействовать определенные типы без указания полной области «названий» соответствующего типа. В базовой форме used используется импорт всех типов именных пространств.

Using directive поддерживает применение двух модификаторов:

Модификатор global. Он будет работать точно так, как и добавление одной директивы use к каждому исходному документу в пределах проекта. Первое появление состоялось в C Sharp 10 версии.
Модификатор static. Он производит импорт элементов static, а также вложенных типов из одного типа, а не из всех в пределах области «названий».

Оба модификатора можно использовать вместе для импорта статистических членов из того или иного типа во всех исходных проектных файлах.

Сейчас C# поддерживает создание псевдонимов для namespace. Для этого используется директива псевдонимов using:

using Project = PC.MyCompany.Project;

Модификатор global используется в using alias. Без него область будет ограничиваться файлом, в пределах которого находится директива.

Особенности

Директива using в C# имеет ряд особенностей. Она отображается в нескольких местах – все зависит от ситуации:

Начало документа в исходном коде. Перед тем, как объявлять именные «области», а также типы.
В любом namespace, но до пространственных имен, объявленных в первой «области». Здесь обязательно, чтобы не использовался модификатор global. Если он присутствует, директива using располагается перед всеми объявлениями.

Если не соблюдать данные принципы, при попытке обработки кода появится ошибка компиляции CS1529.

Директива using создается для того, чтобы использовать типы в пространстве имен без необходимости указания его самого. Если использовать using System, больше не придется вводить полный путь. Методы в приложении получится вызывать быстрее и короче.

Using – это ключевое слово, которое в C# имеет широкое применение. Оно используется для создания операторов using. Данные элементы используются для грамотной обработки объектов IDisposable – шрифтов и файлов.

Псевдонимы

Using alias – это директива, позволяющая создавать псевдонимы для namespaces. У нее не может быть открытого универсального типа в правой части. Создать его для List<T> не получится, но можно для List<int>.

Если отсутствует импорт пространств имен System, полные имена базовых типов окажутся недоступными:

Для подключения using alias потребуется:

Добавить в References желаемые сборки.
Открыть соответствующую папку и кликнуть по сборке правой кнопкой мышки.
Выбрать раздел Properties.
Нажать на свойство Aliases.

После этого остается заменить значение global на свое собственное название.

Наглядный пример

Для того, чтобы хорошо разбираться в директивах и их uses, стоит изучить наглядный пример. Ниже приведен фрагмент кода. Он будет взять за «базу» для изучения directive и оператора:

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

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

После обработки блока using в C происходит автоматический вызов метода Dispose(). Он осуществляется для переданного ранее объекта и располагается в интерфейсе System.IDisposable.

При использовании потоков необходимо запомнить – при завершении оперирования ими требуется завершать соответствующие процессы. Аналогичные принципы применяются к базам данных, сокетам, иным источникам. Метод Dispose() будет каждый раз завершать работу с потоком и высвобождать ресурсы.

А вот более простой фрагмент программы:

Using namespace std указывает компилятору на импорт всех имен из пространства std в текущую область видимости. В приведенном примере таковым является main().
После использования неполного идентификатора count происходит преобразование в std::count.

Данный вариант подойдет для того, чтобы упрощать программный код. С ним не придется вручную прописывать и обновлять все неполные имена до полных.

Как лучше освоить

C# – язык, который пользуется спросом у разработчиков. Для того, чтобы хорошенько изучить его директивы, а также пространства имен и иные элементы, можно заняться самообразованием. Это не лучшее решение – обучение может затянуться, а доказать полученные навыки и знания документально окажется невозможно. Именно поэтому рекомендуется отдать предпочтение дистанционным онлайн курсам.

Они рассчитаны на широкую публику и прекрасно совмещаются со всеми делами – уроки можно просматривать в любое время. Курсы рассчитаны на срок до 12 месяцев. Пользователи получают шанс выбрать одновременно одно или несколько инновационных IT-направлений для изучения. Процесс сопровождается домашними заданиями и богатой практикой. В конце обучения выдается электронный сертификат, подтверждающий приобретенный спектр навыков и знаний.

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus!

Using c что это