Как узнать лучшее место для использования 'using'?

Question

Я немного новичок в C#, больше привык к скриптовым языкам. Мне нравится идея «использования», вы создаете экземпляр объекта, а затем вы работаете в пределах своего объема, если вам это нужно, тогда вы позволяете ему распоряжаться собой, когда это делается для его цели.

Но, это неестественно для меня. Когда люди показывают мне примеры использования, я признаю это хорошим инструментом для работы, но мне никогда не приходило в голову решать проблемы с ним в моем собственном программировании.

Как я могу узнать хорошие места для использования using и как использовать его в сочетании с блоками try-catch. Они идут внутри блока или обычно вы хотите заключить оператор using в блок try?

Answer 1

Я редко пишу попробовать/уловах блоки - большинство исключений вышвырнут до (около) в верхней части стека. Если у меня есть do, вам нужен блок try/catch, я не уверен, что я особенно согласен с тем, чтобы положить его в оператор using и вне его. Это зависит от того, хотите ли вы, чтобы ресурс был удален до того, как будет запущен ваш код обработки исключений.

Если вы спрашиваете о когда вы должны писать using заявления - в любое время вы «свой» объект, который реализует IDisposable (либо непосредственно, либо косвенно, через наследование) и контролировать его жизнь. Обычно это объект, который использует неуправляемый ресурс, такой как дескриптор файла или сетевое соединение. Это не всегда очень очевидно, но вы учитесь на собственном опыте. Почти что-нибудь сделать с IO будет одноразовым, а дескрипторы Windows (для шрифтов и т. Д.) Похожи.

Answer 2

using может использоваться только с типами, которые реализуют IDisposable; он гарантирует, что метод Dispose() будет вызываться, даже если возникает ошибка.

Этот код:

using (MyDisposableType x = new MyDisposableType()) 
{ 
    // use x 
} 

эквивалентно следующему:

MyDisposableType x = new MyDisposableType(); 
try 
{ 
    // use x 
} 
finally 
{ 
    x.Dispose(); 
} 

Answer 3

КАКИЕ сказал Митч, плюс ..

Вы можете использовать, используя заявление снаружи или внутри блока try..catch это действительно будет зависеть от того, что вы пытаетесь достичь, то ли разумно ожидать, что-то бросаться исключение, в то время как с использованием определенного объекта, который вы планируете восстановить, например.

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

Answer 4

Я использую это как «использовать его каждый раз, когда тип реализует IDisposable, и вы не хотите больше этого конкретного экземпляра».

Answer 5

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

System.IO.FileStream writeStream = new System.IO.FileStream(fileName, System.IO.FileMode.OpenOrCreate)); 
System.IO.BinaryWriter writer = new System.IO.BinaryWriter(writeStream)); 
//do smth 

и исключение происходит во время «делать что-л» вы не знаете, когда объекты, работающие на файле, на самом деле расположены и файл закрывается.С помощью вы знаете наверняка, что как только вы покинули с помощью операторного блока - либо непосредственно, либо через исключение объект в использованияКонтактной заявления расположен по телефону IDisposable :: Dispose:

using(System.IO.FileStream writeStream = new System.IO.FileStream(fileName, System.IO.FileMode.OpenOrCreate)) { 
    using(System.IO.BinaryWriter writer = new System.IO.BinaryWriter(writeStream)) { 
     //do stmth 
    } 
} 

Answer 6

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

Одна из ситуаций, где использование хорошо, когда вы делаете операции с базами данных с использованием DBConnection и DBCommands:

using (SqlConnection conn = new SqlConnection(connectionString)) 
using (SqlCommand command = new SqlCommand(sql, conn)) 
{ 
    // do something here 
} 

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

Answer 7

Что сказал Митч, является правильным. Таким образом, основное использование используется для обеспечения того, чтобы объекты IDisposable были удалены, без, чтобы закодировать команду try/catch или try/finally.

Теперь у вас есть более продвинутое использование, которое может показаться вам интересным. Когда вы используете оператор using, компилятор генерирует try/finally, а также генерирует вызов Dispose() для вас внутри окончательно созданного. Вы можете использовать этот метод Dispose() как «хук», чтобы делать все, что вы хотите ... не обязательно должны быть связаны с выпуском ресурсов.

Например, Джеффри Рихтер использует это в задаче таймера, который он написал. Вы можете сделать что-то подобное с ним (концептуальное только):

using(var x = new Timer()) 
{ 
    // Do the operation you want timed 
} 

// Now, the timer has been stopped, because the 
// compiler-generated call to Dispose() has already 
// occurred, and Jeffrey uses Dispose() to stop 
// the timer. 

Answer 8

Если вы хотите знать, как творчески использовать его в ваших собственных конструкциях, просматривать некоторые из своего собственного кода для ситуаций, когда конкретный бит коды абсолютно необходимо выполнить до выхода закрывающего блока. Это ситуации, когда try/finally или using могут вам помочь.

В частности, если вы попытались достичь этого, воспользовавшись всеми исключениями, вы действительно должны изменить на try/finally или using вместо этого.

Если шаблон возникает несколько раз, вы можете создать класс, который реализует IDisposable, чтобы захватить шаблон и позволить вам вызывать шаблон с помощью оператора using. Но если у вас есть конкретный случай, который кажется одноразовым, просто используйте try/finally.

Два очень похожи, на самом деле - using определяется в терминах try/finally, но даже если мы только имели using, мы могли бы построить try/finally себя:

public class DisposeAnything : IDisposable 
{ 
    public Action Disposer; 

    public void Dispose() 
    { 
     Disposer(); 
    } 
} 

Теперь вы можете сказать:

using (new DisposeAnything 
     { 
      Disposer =() => File.Delete(tempFileName) 
     }) 
{ 
    // blah 
} 

Что такое же, как:

try 
{ 
    // blah 
} 
finally 
{ 
    File.Delete(tempFileName); 
} 

Просто подумайте об этом как о способе выполнения кода, выходящего из области действия.

Answer 9

Если класс реализует IDisposable, это, вероятно, не без оснований. Поэтому любой класс, который реализует IDisposable, должен быть удален.

Answer 10

Учитывая, что это то, что известно как «синтаксический сахар», и будет производить тот же ИЛ, что и конструкция try/finally dispose, это действительно просто хороший способ «короткого раздачи» такого кода.

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

Answer 11

Я заметил, что когда метод Dispose, как известно, замечает, поэтому программисты не утруждают себя называть его, как кажется бессмысленным. Однако, если объект реализует IDisposable, он (надеюсь) по какой-либо причине, и будущие версии этого объекта могут действительно иметь код в методе Dispose, поэтому всегда вызывайте его.