Где я должен улавливать исключения при использовании ключевого слова "using" в коде?

Какой из них лучше в структуре?

class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (Foo f = new Foo())
            {
                //some commands that potentially produce exceptions.
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

или...

class Program
{
    static void Main(string[] args)
    {

        using (Foo f = new Foo())
        {
            try
            {
                //some commands that potentially produce exceptions.
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

    }
}

Ответы

Ответ 1

Либо все нормально, в зависимости от того, что вы собираетесь делать в catch. Если вам нужно использовать f в вашем catch, то это должно быть в инструкции using. Однако в вашем примере нет разницы.

EDIT: Как указано в другом месте, это также зависит от того, пытаетесь ли вы поймать только исключения, сгенерированные в блоке после использования или включения создания объекта в оператор using. Если он находится в блоке после использования, то это, как я описал. Если вы хотите поймать исключения, сгенерированные с помощью Foo f = new Foo(), вам нужно использовать первый метод.

Ответ 2

Я не думаю, что это имеет большое значение, с точки зрения производительности. Однако есть небольшая разница; во втором примере f по-прежнему доступен внутри обработчика исключений, в то время как в первом он вышел из области видимости. И наоборот, в первом примере исключения в конструкторе Foo, а также его метод Dispose будут пойманы, а во втором - нет.

Либо может или не может быть то, что вы хотите.

Ответ 3

Отметьте этот пост, чтобы лучше понять: http://www.ruchitsurati.net/index.php/2010/07/28/understanding-%E2%80%98using%E2%80%99-block-in-c/

Также читайте ответы на этот вопрос: Улавливание исключений, созданных в конструкторе целевого объекта блока использования

первый из них является бэквертером

class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (Foo f = new Foo())
            {
                //some commands that potentially produce exceptions.
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

потому что если вы видите код IL этой попытки и блок catch, не завершайте инициализацию объекта.

Ответ 4

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

Ответ 5

Первая - лучшая. Если любое исключение приходит, оно будет ловить.

 try
    {
        using (Foo f = new Foo())
        {
            //some commands that potentially produce exceptions.
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

Концепция использования - это уничтожить объект, созданный в use.ie, он автоматически вызывает метод IDispose. Исходя из этого требования, используйте используя.

Ответ 6

Использование просто

Foo f = null;
try
{
   f = new Foo();
}
finally
{
   if (f is IDisposable)
       f.Dispose();
}

Увидев, что вы можете добиться таких исключений:

Foo f = null;
try
{
   f = new Foo();
}
catch (Exception ex)
{
    // handle exception
}
finally
{
   if (f is IDisposable)
       f.Dispose();
}