Выгода попытки каждая строка кода без отдельных блоков try-catch

Игнорирование всех причин Вы хотели бы постараться не делать это.......

, Если это была просто потребность сохранить # строк вниз, Вы могли бы попробовать что-то как:

int totalMethodCount = xxx;
for(int counter = 0; counter < totalMethodCount; counter++) {
    try {
        if (counter == 0) WidgetMaker.SetAlignment(57);
        if (counter == 1) contactForm["Title"] = txtTitle.Text;
        if (counter == 2) Casserole.Season(true, false);
        if (counter == 3) ((RecordKeeper)Session["CasseroleTracker"]).Seasoned = true;
    } catch (Exception ex) {
        // log here
    }
}

Однако необходимо было бы следить за переменным объемом, при попытке снова использовать какой-либо из результатов вызовов.

Hilite каждая строка, по одному, 'Окружают' попыткой/выгодой. Это избегает, чтобы копирование, вставляющее Вас, упомянуло

Вы могли посмотреть на интеграцию компонента Обработки исключений Библиотеки Предприятия для одной идеи того, как обработать необработанные исключения.

, Если это для приложений ASP.NET, существует функция в названном Global.asax, "Application_Error", который обычно называют в большинстве случаев с катастрофическим отказом, являющимся другим случаем.

К сожалению, Вам, вероятно, не повезло. На Ошибочном Резюме Затем опция прежней версии, которой обычно в большой степени препятствуют и не имеет эквивалента моему знанию в C#.

я рекомендовал бы оставить код в VB (Он кажется, что это было источником, учитывая Ваш определенный запрос на OnError ResumeNext) и взаимодействующий через интерфейс с или от C# dll или exe, который реализует любой новый код, в котором Вы нуждаетесь. Тогда рефакторинг заготовки, чтобы заставить код быть безопасным, и преобразовать этот безопасный код в C#, поскольку Вы делаете это.

Забавный вопрос; очень ужасный.

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

Бездельничание с этим, я пытался маркировать каждую строку и перейти назад от единственной выгоды без большой удачи. Однако Christopher раскрыл корректный способ сделать это . Существуют приблизительно интересное дополнительное обсуждение этого в Точечных Сетевых Мыслях и в РЕДАКТИРОВАНИЕ Блога .

.NET Mike Stall: Конечно. try-catch / switch-goto перечисленное решение на самом деле не скомпилирует, начиная с try маркировки из объема в catch. Кто-либо знает то, что отсутствует, чтобы заставить что-то вроде этого скомпилировать?

Вы могли автоматизировать, это с компилятором предварительно обрабатывает шаг или возможно изрубило инструмент Inline IL Mike Stall для введения некоторого ошибочного незнания.

( ответ Orion Adrian об исследовании Исключения и попытка установить следующую инструкцию интересен также.)

, В целом, это походит на интересное и поучительное осуществление. Конечно, необходимо было бы решить, в какой точке усилие моделировать НА ОШИБОЧНОМ NEXT РЕЗЮМЕ перевешивает усилие зафиксировать код.:-)

Почему бы не использовать отражение в c#? Вы могли создать класс, который размышляет над кодом, и используйте строку #s в качестве подсказки для того, что вставить каждый отдельный блок попытки/выгоды. Это имеет несколько преимуществ:

1. Его немного менее ужасные, поскольку это не делает действительно Вас, требуют, искажают Ваш исходный код, и можно использовать его только во время режимов отладки.
2. Вы узнаете что-то интересное о c# при реализации его.

я однако рекомендовал бы против любого из этого, если, конечно, Вы не занимаете maintance работы someelses, и необходимо разобраться с исключениями, таким образом, можно зафиксировать их. Могла бы быть забава записать все же.

Если можно заставить компилятор давать Вам дерево выражений для этого кода, то Вы могли изменить то дерево выражений путем замены каждого оператора новым блоком try-catch, который обертывает исходный оператор. Это не столь неправдоподобно, как это звучит; для LINQ C# получил способность получить лямбда-выражения как деревья выражений, которыми можно управлять в пользовательском коде во времени выполнения.

Этот подход не возможен сегодня с.NET 3.5 - если ни по какой другой причине, чем отсутствие оператора "попытки" в Системе. Linq. Выражения. Однако это может быть жизнеспособно в будущей версии C#, как только слияние ДОЛЛАРА и деревьев выражений LINQ завершено.

Вы могли использование goto, но это все еще грязно.

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

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

Как кто-то упомянул, VB позволяет это. Как насчет того, чтобы делать его тот же путь в C#? Введите испытанный отражатель:

Это:

Sub Main()
    On Error Resume Next

    Dim i As Integer = 0

    Dim y As Integer = CInt(5 / i)


End Sub

Переводит в это:

public static void Main()
{
    // This item is obfuscated and can not be translated.
    int VB$ResumeTarget;
    try
    {
        int VB$CurrentStatement;
    Label_0001:
        ProjectData.ClearProjectError();
        int VB$ActiveHandler = -2;
    Label_0009:
        VB$CurrentStatement = 2;
        int i = 0;
    Label_000E:
        VB$CurrentStatement = 3;
        int y = (int) Math.Round((double) (5.0 / ((double) i)));
        goto Label_008F;
    Label_0029:
        VB$ResumeTarget = 0;
        switch ((VB$ResumeTarget + 1))
        {
            case 1:
                goto Label_0001;

            case 2:
                goto Label_0009;

            case 3:
                goto Label_000E;

            case 4:
                goto Label_008F;

            default:
                goto Label_0084;
        }
    Label_0049:
        VB$ResumeTarget = VB$CurrentStatement;
        switch (((VB$ActiveHandler > -2) ? VB$ActiveHandler : 1))
        {
            case 0:
                goto Label_0084;

            case 1:
                goto Label_0029;
        }
    }
    catch (object obj1) when (?)
    {
        ProjectData.SetProjectError((Exception) obj1);
        goto Label_0049;
    }
Label_0084:
    throw ProjectData.CreateProjectError(-2146828237);
Label_008F:
    if (VB$ResumeTarget != 0)
    {
        ProjectData.ClearProjectError();
    }
}

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

On Error Resume Next действительно плохая идея в мире C#. Ни был бы, добавляя эквивалент On Error Resume Next на самом деле справка Вы. Все, что это сделало бы, оставить Вас в плохом состоянии, которое могло вызвать более тонкие ошибки, потерю данных и возможно повреждение данных.

, Но дать корреспонденту его должное, Вы могли добавить глобальный обработчик и проверить TargetSite для наблюдения который метод borked. Тогда Вы могли, по крайней мере, знать что строка это borked на. Следующая часть должна была бы попытаться выяснить, как установить "следующий оператор" тот же способ, которым отладчик делает это. Надо надеяться, Ваш стек не будет раскручиваться в этой точке, или можно воссоздать его, но это, конечно, стоит того, чтобы попытаться. Однако, учитывая этот подход код должен был бы работать в Режиме отладки каждый раз так, чтобы Вам включали Ваши отладочные символы.

Это - одна из вещей, для которых наличие препроцессора полезно. Вы могли определить макрос, который глотает исключения, затем с быстрым сценарием добавляют что макрос ко всем строкам.

Так, если это было C++, Вы могли бы сделать что-то вроде этого:

#define ATTEMPT(x) try { x; } catch (...) { }
// ...
ATTEMPT(WidgetMaker.SetAlignment(57));
ATTEMPT(contactForm["Title"] = txtTitle.Text);
ATTEMPT(Casserole.Season(true, false));
ATTEMPT(((RecordKeeper)Session["CasseroleTracker"]).Seasoned = true);

, К сожалению, не много языков, кажется, включают препроцессор как C/C++, сделал.

Вы могли создать свой собственный препроцессор и добавить его как шаг перед сборкой. Если бы Вы испытывали желание полностью автоматизировать его, то Вы могли бы, вероятно, записать препроцессор, который взял бы фактический файл кода и включил бы материал попытки/выгоды самостоятельно (таким образом, Вы не должны добавлять, что они ДЕЛАЮТ ПОПЫТКУ () блоков к коду вручную). Удостоверяясь это только изменило строки, это, как предполагается, могло быть трудным, хотя (должны пропустить объявления переменной, конструкции цикла, и т.д. к этому, Вы не повреждаете сборку).

Однако я думаю, что они - ужасные идеи и никогда не должны делаться, но вопрос задали.:)

Действительно, Вы никогда не должны делать этого. Необходимо найти то, что вызывает ошибку, и зафиксируйте ее. Глотание/игнорирование ошибок является плохой вещью сделать, таким образом, я думаю корректный , ответ здесь, "Исправляют ошибку, не игнорируйте его!".:)

Сбой Быстро

Для разработки, я предполагаю, что подвергаю сомнению вопрос. Если бы исключение выдается, почему Вы хотели бы, чтобы Ваш код просто продолжился, как будто ничего не произошло? Или Вы ожидаете исключения в определенных ситуациях, в этом случае Вы пишете блок try-catch вокруг того кода и обрабатываете их, или существует неожиданная ошибка, в этом случае необходимо предпочесть, чтобы приложение прервало, или повторило, или перестало работать. Не продолжаются как раненый зомби, стонущий 'мозги'.

Осуществите рефакторинг в отдельные, хорошо названные методы:

AdjustFormWidgets();
SetContactTitle(txtTitle.Text);
SeasonCasserole();

Каждый из тех защищен соответственно.

Я сказал бы , ничего не делают .

Да правильно, НИЧЕГО не сделайте.

Вы ясно определили две вещи мне:

1. Вы знаете, что архитектура является borked.
2. существует тонна этого дерьма.

я говорю:

• ничего Не Делают.
• Добавляют глобальный обработчик ошибок для отправки Вам электронного письма каждый раз, когда это идет бум.
• Ожидают, пока что-то не падает (или проваливает тест)
• Корректный, что (Осуществляющий рефакторинг по мере необходимости в рамках страницы ).
• Повторение каждый раз проблема происходит.

Вам разрешат это в мгновение ока, если это будет это плохо. Да я знаю, что это звучит как sucky, и можно вытаскивать волосы с bugfixes для начала, но это позволит, Вы к [1 117] исправляете нуждающийся / содержащий ошибки код прежде (большой) объем [1 118] кода, который может на самом деле работать , неважно, как дрянной это смотрит.