Используя оператор и выгоду попытки () - наконец повторение?
Мой совет Вашему случаю состоит в том, чтобы Вы установили Ubuntu с установщиком Windows. Вы видите свои разделы диска и говорите установщик, сколько должно он красть из раздела окон для создания раздела Ubuntu.
Загрузка установщик Windows для Рабочего стола Ubuntu .
ревом экрана печати, Вы видите, что можно сказать в установщике, в котором диск установки будет Ubuntu быть установленным, и сколько места должно быть свободным для нового раздела Ubuntu:
посмотрите , чиновник шаг за шагом ведет для подробных инструкций.
Для ответа на вопрос, связанный с загрузчиком после того, как, установка завершена, у Вас будет диспетчер начальной загрузки, который позволяет Вам выбирать ОС для начальной загрузки в:
5 ответов
Вы можете реализовать шаблон самостоятельно, если вам нужно обработать некоторые исключения, если вы действительно этого хотите. Лично я все еще считаю, что проще (и, что более важно, понятнее) просто заключить using в блок try / catch.
Но если вы делаете это сами, убедитесь, что у вас все получается правильно. Блок Использование также создает блок анонимной области видимости, так что ваша переменная быстрее становится доступной для сбора. Метод .Dispose () , который вызывается в конце блока Использование , очищает только неуправляемых ресурсов, поэтому любая память, содержащаяся в вашем объекте, может зависать немного дольше. Вряд ли это серьезная проблема, но на всякий случай стоит вспомнить.
Итак, чтобы выполнить прямую адаптацию шаблона, ваш код должен выглядеть примерно так:
{
FileStream fs;
try
{
fs = File.Open(path);
}
catch (FileNotFoundException e) { /* ... */ }
catch (IOException e) { /* ... */ }
catch (Exception e) {/* ... */}
finally
{
if (fs != null) fs.Dispose();
}
}
Лично я ' Я хотел бы увидеть Использование расширено для поддержки блоков Catch и Наконец . Поскольку они уже выполняют преобразование кода, не похоже, что это добавит дополнительных сложностей.
Самая большая разница между using и try-finally заключается в том, что using вызывает только метод Dispose () . Если вы реализуете свой собственный блок finally, он может выполнять другую логику, например регистрацию, которая не будет включена в использование.
Я бы предпочел оставить оператор using и заключить его в try / catch. Внешний метод try / catch перехватит любые исключения, за которыми вам нужно следить, игнорируя Dispose (). Это имеет дополнительное преимущество, так как защищает вас от самого себя, если вы позже проведете рефакторинг, чтобы переместить try / catch в другое место (например, в вызывающую функцию).
Что касается вашего вопроса об IDisposable: любой может реализовать это по любой причине, которая ему нравится . Нет никаких технических причин для его ограничения неуправляемыми ресурсами. (Следует ли ограничивать неуправляемыми ресурсами в вашем коде - другой вопрос).
Конструкция using является сокращением для блока try / finally . То есть компилятор генерирует:
FileStream fs = null;
try
{
fs = File.Open(path);
// ...
}
finally
{
if (fs != null)
fs.Dispose();
}
Так что правильно использовать , используя , если вам не нужна ловушка , но если вы это сделаете, вы должны просто использовать обычный ] try / catch / finally .
Если вам нужно явно обработать различные исключительные случаи, которые могут произойти во время выполнения оператора, вы можете заменить с помощью на try / catch / finally и вызвать Dispose () явно в файле finally. Или вы можете поместить try / catch вокруг , используя блок , чтобы отделить исключительные обстоятельства от обеспечения удаления.
Единственная вещь , использующая , - это обеспечение вызова Dispose (), даже если внутри блока возникло исключение. Это очень ограниченная, узкоспециализированная реализация общей структуры try / [catch] / finally .
Важно то, что ни один из этих параметров не имеет реального влияния - пока он делает то, что нужно, читабельно и понятно, кого это волнует? Это' Не похоже, что дополнительная попытка будет узким местом или чем-то еще!
Чтобы ответить на ваш последний вопрос - нет, IDisposable определенно не означает, что у разработчика есть дескрипторы для неуправляемых ресурсов. Это гораздо более простой и общий шаблон, чем этот. Вот один полезный пример:
public class Timer : IDisposable
{
internal Stopwatch _stopwatch;
public Timer()
{
this._stopwatch = new Stopwatch();
this._stopwatch.Start();
}
public void Dispose()
{
this._stopwatch.Stop();
}
}
Мы можем использовать это для измерения времени без необходимости явно полагаться на запуск и остановку вызова, используя:
using(Timer timer = new Timer())
{
//do stuff
}