Когда я должен использовать блоки “использования” в C#? [дубликат]

Я также добавил бы, что используют using() оператор, если что-то реализует IDispose и также если это что-то, от чего Вы хотите избавиться, держится за Неуправляемые ресурсы как соединения с базой данных и дескрипторы файлов.

, Если это - обычный объект с, говорят List<T>, где T похож Customer объект, который содержит имена и адрес, затем Вы не должны. Сборщик "мусора" достаточно умен для управления этим для Вас. Но сборщик "мусора" НЕ возвратит соединения с пулом соединения или закроет дескрипторы файлов.

Другие люди уже упомянули о "IDisposable".

, Но один из протестов при использовании "использования" оператора то, что, любые исключения, выданные в рамках "использования", не будут пойманы, даже мысль "SomeType" будет расположена независимо.

Так в следующем отрывке,

using (SomeType t = new SomeType()){
    throw new Exception("thrown within using");
}

throw new Exception("thrown within using"); не должен быть игнорирован.

Одна ситуация состоит в том, когда Вы хотите сделать что-то в начале блока кода и затем отменить его в конце блока, безусловно (даже если существует бросок).

ctor для доступного класса, который Вы создаете (и называете в рамках использования) выполнил бы действие, и затем Расположить метод отменит то действие. Это обычно, как я использую его.

Возможно, стоит упомянуть, что базовая причина добавления “using” lo C# languge следует: некоторые ресурсы могут быть достаточно дефицитными, что doesn’t имеет смысл ожидать GC для вызова IDisposable. Например, соединения с БД. Если Вы используете, судить/ловить/наконец Вас, won’t заканчиваются с повисшим соединением, но соединение оставят, зависая, пока GC doesn’t не умрет, и это может требовать времени (если Вы не закрываете его явно). При использовании "использования" (извините игру слов), Вы сразу выпустите соединение, даже если Вы забыли закрывать его и даже если некоторое исключение произошло в блоке использования.
Другая причина, как предыдущее сообщение упоминает, состоит в том, что программисты не всегда используют наконец для чистки. Не используя наконец в случае исключения Вы заканчиваете с утечкой resources†¦

Основное правило: * Оператор Use USING, когда объекты реализует интерфейс IDisposable.

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

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

Для получения дополнительной информации об этом просто посещают эту ссылку: microsoft

Один определенный экземпляр, в котором необходимо быть тщательным использованием using блок, с Сервисным Клиентом WCF .

, Как отмечено в эта статья MSDN, перенося клиент WCF (который действительно реализует IDisposable) в using блок мог замаскировать любые ошибки, которые приводят к клиенту, оставляемому в неработающем состоянии (как тайм-аут или проблема связи). Короче говоря, когда Dispose() назван, клиент Close() огни метода, но броски и ошибка, потому что это находится в неработающем состоянии. Исходное исключение затем маскируется вторым исключением. Не хороший.

существуют различные обходные решения там, включая одно в самой статье MSDN. Другие могут быть найдены в IServiceOriented и blog.davidbarret.net .

я предпочитаю последний метод, сам.

Если Вы хотите сводное правило. В любое время объект с помощью IDisposable, где у Вас не было бы выгоды, используйте использование. Используя, по существу, этот шаблон:

try
{
  //instantiate and use object
}
finally
{
  //dispose object
}

, Если Вам не нужна выгода, использование может сохранить Вас ввод, который является хорошей вещью.

Пример:

        using(SqlConnection MyConnection = new SqlConnection("Connection string"))
        {
            MyConnection.Open();

            //...

            // 1. SQLConnection is a type that implements IDisposable
            // 2. So you can use MyConnection in a using statement
            // 3. When using block finishes, it calls Dispose method of 
            // SqlConnection class
            // 4. In this case, it will probably close the connection to 
            // the database and dispose MyConnection object

        }

можно создать собственные объекты, который реализует IDisposable:

public class MyOwnObjectThatImplementsIDisposable : IDisposable
{

    //... some code

    public void Dispose()
    {
        // Put here the code you want to be executed when the
        // using statement finish.
    }
}

, Таким образом, Вы могли использовать объект типа MyOwnObjectThanImplementsIDisposable в операторе использования:

        using(MyOwnObjectThatImplementsIDisposable MyObject = new MyOwnObjectThatImplementsIDisposable)
        {

            // When the statement finishes, it calls the 
            // code you´ve writed in Dispose method
            // of MyOwnObjectThatImplementsIDisposable class
        }

Hope это помогает

Когда SomeType реализует IDisposable.

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

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

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

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

Используйте using каждый раз, когда тип реализует IDisposable , если Вы не собираетесь перенести его в try / catch блок так или иначе, затем Вы могли бы также (в зависимости от того, какой взгляд Вы предпочитаете), используют finally блок.

Некоторым объектам нужно некоторое действие, которое будет взято, когда Вы закончили с ними. Обычно это вызвано тем, что объект использует некоторый ресурс, от которого нужно избавиться. Например, если у Вас будет объект файла класса Файл, и этот объект открывает файл от файловой системы, то файл в файловой системе должен будет быть закрыт снова.

, Если Вы просто оставили объект файла и забыли называть файл. Близко () это не было бы убрано вплоть до Сборщика "мусора" (GC), работал и решил, что ничто все еще не использовало объект файла. Когда выполнения Сборщика "мусора" нужно оставить Общеязыковой среде выполнения (CLR) решить. Если GC не работает долгое время после окончания с файлом файл мог остаться открытым потенциально в течение долгого времени. Это может создать большую проблему, если существует много объектов файла, или если что-то хочет открыть файл, но не можете, потому что файл возражает, что Вы уехали, все еще бродит вокруг.

Для решения этой проблемы C# имеет интерфейс IDisposable. Этому назвали один метод, Располагают. Классы, которые требуют некоторой очистки, реализуют, это Располагает метод. Это дает Вам стандартный путь к чистке любых объектов то использование ресурсы. Существует много классов, которые должны иметь, Располагают названный. Проблема с этим состоит в том, что код покрыт вызовами для Расположения, и они хитры для следования, потому что место, где Вы new'ed объект и вызов Располагаете для чистки его, отличается. Так, необходимо было осмотреть код много и стараться очень для проверки были вызовы для Расположения в правильном месте.

Для решения этой проблемы C# представил ключевое слово 'использования'. Можно поместить ключевое слово 'использования' вокруг, где Вы новый объект, и это удостоверяется, Располагают, будет назван на нем для Вас. Это гарантирует, что Располагают, будет назван что бы ни случилось..., даже если будет исключение, выданное в теле оператора использования.

Так, необходимо использовать 'использование', когда Вы хотите быть уверенными объект, который выделяет ресурсы, будет очищен.

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

Общие объекты, которым нужно использование, обратились к ним: Файлы, Соединения с базой данных, Графические объекты, такие как Pen и Brush.

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

using( Log log = new Log("Doing stuff") )
{
    // Stuff
}

конструктор для класса журнала мог быть заставлен выписать сообщение, и Расположить метод мог также выписать его. Реализуйте финализатор (~Log), чтобы утверждать, не становится ли Расположить метод названным, чтобы гарантировать, что 'использование' помнят вокруг 'нового Журнала'.

В этом контексте using оператор удобен для типов та реализация IDisposable. Когда блок кода выходит из объема using, оператор, Dispose() называют неявно. Это - хорошая привычка при работе с объектами, которые Вы хотите расположить сразу после использования.