Как сделать метод отменяемым, чтобы он не стал уродливым?

Если шаги каким-то образом независимы от потока данных внутри метода, но не могут выполняться параллельно, следующий подход может быть более читаемым:

void Run()
{
    // list of actions, defines the order of execution
    var actions = new List<Action<CancellationToken>>() {
       ct => Step1(ct),
       ct => Step2(ct),
       ct => Step3(ct) 
    };

    // execute actions and check for cancellation token
    foreach(var action in actions)
    {
        action(cancellationToken);

        if (cancellationToken.IsCancellationRequested)
            return false;
    }

    return true;
}

Если шагам не нужен токен отмены, потому что вы можете разделить их на крошечные единицы, вы можете даже написать определение меньшего списка:

var actions = new List<Action>() {
    Step1, Step2, Step3
};

как насчет продолжения?

var t = Task.Factory.StartNew(() => Step1(cancellationToken), cancellationToken)
   .ContinueWith(task => Step2(cancellationToken), cancellationToken, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current)
   .ContinueWith(task => Step3(cancellationToken), cancellationToken, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current);

Я признаю, что это некрасиво, но руководство состоит в том, чтобы сделать то, что вы сделали:

if (cancellationToken.IsCancellationRequested) { /* Stop */ }

...или немного короче:

cancellationToken.ThrowIfCancellationRequested()

Как правило, если вы можете передать токен отмены отдельным шагам, вы можете распределить проверки таким образом, чтобы они не переполняли код. Вы также можете не проверять отмену постоянно; если операции, которые вы выполняете, являются идемпотентными и нетребовательными к ресурсам, вам не обязательно проверять отмену на каждом этапе. Самое важное время для проверки — перед возвратом результата.

Если вы передаете токен на все свои шаги, вы можете сделать что-то вроде этого:

public static CancellationToken VerifyNotCancelled(this CancellationToken t) {
    t.ThrowIfCancellationRequested();
    return t;
}

...

Step1(token.VerifyNotCancelled());
Step2(token.VerifyNotCancelled());
Step3(token.VerifyNotCancelled());

Когда мне нужно было сделать что-то подобное, я создал для этого делегата:

bool Run(CancellationToken cancellationToken)
{
    var DoIt = new Func<Action<CancellationToken>,bool>((f) =>
    {
        f(cancellationToken);
        return cancellationToken.IsCancellationRequested;
    });

    if (!DoIt(Step1)) return false;
    if (!DoIt(Step2)) return false;
    if (!DoIt(Step3)) return false;

    return true;
}

Или, если между шагами никогда нет кода, вы можете написать:

return DoIt(Step1) && DoIt(Step2) && DoIt(Step3);

Укороченная версия:

Используйте lock() для синхронизации вызова Thread.Abort() с критическими секциями.

Поясню версию:

Как правило, при прерывании потока вам придется учитывать два типа кода:

• Длинный код, вам все равно, завершится ли он
• Код, который обязательно должен идти своим чередом

Первый тип — это тип, который нас не волнует, если пользователь запросил прерывание. Может быть, мы считали до ста миллиардов, и ему уже все равно?

Если бы мы использовали часовых, таких как CancellationToken, мы вряд ли стали бы тестировать их в каждой итерации неважного кода, не так ли?

for(long i = 0; i < bajillion; i++){
    if(cancellationToken.IsCancellationRequested)
        return false;
    counter++;
}

Такой страшный. Так что для этих случаев Thread.Abort() - находка.

К сожалению, как говорят некоторые, вы не можете использовать Thread.Abort() из-за атомарного кода, который обязательно должен работать! Код уже снял деньги с вашего счета, теперь он должен завершить транзакцию и перевести деньги на целевой счет. Никто не любит исчезновение денег.

К счастью, у нас есть взаимное исключение, чтобы помочь нам с такими вещами. И C# делает это красиво:

//unimportant long task code
lock(_lock)
{
    //atomic task code
}

И в другом месте

lock(_lock) //same lock
{
    _thatThread.Abort();
}

Количество блокировок всегда будет равно <= числу дозорных, потому что вам также нужны дозорные для неважного кода (чтобы ускорить его прерывание). Это делает код немного красивее, чем в версии Sentinel, но также улучшает прерывание, потому что ему не нужно ждать неважных вещей.

Также следует отметить, что ThreadAbortException можно поднять где угодно, даже в finally блоках. Эта непредсказуемость делает Thread.Abort() таким противоречивым.

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

Это делает Thread.Abort(), как вы говорите, немного менее злым. Однако вы можете не захотеть вызывать его в потоке пользовательского интерфейса, поскольку теперь вы его блокируете.

Я немного удивлен, что никто не предложил стандартный, встроенный способ справиться с этим:

bool Run(CancellationToken cancellationToken)
{        
    //cancellationToke.ThrowIfCancellationRequested();

    try
    {
        Step1(cancellationToken);
        Step2(cancellationToken);
        Step3(cancellationToken);
    }
    catch(OperationCanceledException ex)
    {
        return false;
    }

    return true;
}

void Step1(CancellationToken cancellationToken)
{
    cancellationToken.ThrowIfCancellationRequested();
    ...
}

Хотя обычно вы не хотите полагаться на отправку проверок на более глубокие уровни, в этом случае шаги уже принимают CancellationToken и должны иметь проверку в любом случае (как и любой нетривиальный метод, принимающий CancellationToken).

Это также позволяет вам быть гранулированными или негранулярными с проверками по мере необходимости, то есть перед длительными/интенсивными операциями.

Если рефакторинг допустим, вы можете реорганизовать методы Step таким образом, чтобы был один метод Step(int number).

Затем вы можете перейти от 1 к N и проверить, запрашивается ли токен отмены только один раз.

bool Run(CancellationToken cancellationToken) {
    for (int i = 1; i < 3 && !cancellationToken.IsCancellationRequested; i++) 
        Step(i, cancellationToken);

    return !cancellationToken.IsCancellationRequested;
}

Или, что то же самое: (Как вы предпочитаете)

bool Run(CancellationToken cancellationToken) {
    for (int i = 1; i < 3; i++) {
        Step(i, cancellationToken);
        if (cancellationToken.IsCancellationRequested)
            return false;
    }
    return true;
}

Возможно, вы захотите взглянуть на шаблон Apple NSOperation. в качестве примера. Это сложнее, чем просто сделать один метод отменяемым, но это довольно надежно.