спробувати / catch + за допомогою правого синтаксису

Який:

using (var myObject = new MyClass())
{
   try
   {
      // something here...
   }
   catch(Exception ex)
   {
      // Handle exception
   }
}

АБО

try
{
   using (var myObject = new MyClass())
   {
      // something here...
   }
}
catch(Exception ex)
{
   // Handle exception
}

Я віддаю перевагу другому. Може також потрапляти помилки, пов'язані зі створенням об'єкта.

Оскільки блок використання - це просто спрощення синтаксису спроби / нарешті ( MSDN ), особисто я б пішов із наступним, хоча я сумніваюся, що він значно відрізняється від вашого другого варіанту:

MyClass myObject = null;
try {
  myObject = new MyClass();
  //important stuff
} catch (Exception ex) {
  //handle exception
} finally {
  if(myObject is IDisposable) myObject.Dispose();
}

Це залежить. Якщо ви використовуєте Windows Communication Foundation (WCF), using(...) { try... }він не буде працювати належним чином, якщо проксі-сервер у usingвикладі знаходиться у стані винятку, тобто розміщення цього проксі-сервера спричинить інший виняток.

Особисто я вірю в мінімальний підхід до обробки, тобто обробляти єдиний виняток, про який ви знаєте в момент виконання. Іншим словом, якщо ви знаєте, що ініціалізація змінної в usingможе кинути певний виняток, я завершу її try-catch. Так само, якщо всередині usingтіла може статися щось, що не пов'язане безпосередньо зі змінною в using, я обертаю її іншою tryдля цього конкретного винятку. Я рідко використовую Exceptionв своїх catchес.

Але мені це подобається IDisposableі usingхоча я, можливо, упереджений.

Якщо у вашій заяві вилову потрібно отримати доступ до змінної, оголошеної у використовуваному операторі, то всередині це ваш єдиний варіант.

Якщо у вашій заяві про вилов потрібен об'єкт, на який посилається у використанні, перед тим, як він буде утилізований, то всередині це ваш єдиний варіант.

Якщо у вашій заяві про улов трапляються дії невідомої тривалості, як-от показ повідомлення користувачеві, і ви хочете розпоряджатися своїми ресурсами до того, як це станеться, тоді зовні - ваш найкращий варіант.

Кожен раз, коли у мене є сценарій, подібний до цього, блок пробного лову зазвичай є іншим способом, що надалі збільшує стек виклику від використання. Для методу не типово знати, як поводитися з винятками, що трапляються всередині нього.

Тож мої загальні рекомендації знаходяться назовні - шлях зовні.

private void saveButton_Click(object sender, EventArgs args)
{
    try
    {
        SaveFile(myFile); // The using statement will appear somewhere in here.
    }
    catch (IOException ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Обидва є дійсним синтаксисом. Це дійсно зводиться до того, що ви хочете зробити: якщо ви хочете виявити помилки, пов’язані зі створенням / розпорядженням об'єктом, використовуйте друге. Якщо ні, використовуйте перший.

Існує одна важлива річ , яку я буду називати тут: Перший з них буде НЕ зловити будь-виключення , що виникає з - за виклику MyClassконструктора.

З C # 8.0 я вважаю за краще використовувати другий такий же, як і цей

public class Person : IDisposable
{
    public Person()
    {
        int a = 0;
        int b = Id / a;
    }
    public int Id { get; set; }

    public void Dispose()
    {
    }
}

і потім

static void Main(string[] args)
    {

        try
        {
            using var person = new Person();
        }
        catch (Exception ex) when
        (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
        ex.TargetSite.MemberType == System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Constructor Person");
        }
        catch (Exception ex) when
       (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
       ex.TargetSite.MemberType != System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Person");
        }
        catch (Exception ex)
        {
            Debug.Write(ex.Message);
        }
        finally
        {
            Debug.Write("finally");
        }
    }

Якщо об’єкт, який ви ініціалізуєте в блоці Using (), може викинути будь-який виняток, тоді вам слід перейти до другого синтаксису, інакше обидва однаково дійсні.

У моєму сценарії я повинен був відкрити файл, і я передав filePath в конструкторі об'єкта, який я ініціалізував у блоці Using (), і він може викинути виняток, якщо filePath неправильний / порожній. Тож у цьому випадку другий синтаксис має сенс.

Мій зразок коду: -

try
{
    using (var obj= new MyClass("fileName.extension"))
    {

    }
}
catch(Exception ex)
{
     //Take actions according to the exception.
}

Починаючи з C # 8.0 , ви можете спростити usingоператори за певних умов, щоб позбутися від вкладеного блоку, а потім він просто застосовується до блоку, що додається.

Тож ваші два приклади можна звести до:

using var myObject = new MyClass();
try
{
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

І:

try
{
   using var myObject = new MyClass();
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

Обидва вони досить чіткі; і тоді це зводить вибір між цими двома питаннями того, яким ви хочете бути сферою дії об'єкта, де ви хочете обробляти помилки інстанції та коли ви хочете їх утилізувати.