Есть ли способ отменить дротик Future?

Question

Есть ли способ отменить дротик Future?

В пользовательском интерфейсе Dart у меня есть кнопка [submit] для запуска длинного асинхронного запроса. Обработчик [submit] возвращает Future. Далее кнопка [отправить] заменяется кнопкой [отменить], чтобы разрешить отмену всей операции. В обработчике [отмена] я хотел бы отменить длительную операцию. Как я могу отменить будущее, возвращенное обработчиком отправки? Я не нашел никакого способа сделать это.

85

dart dart-async

Источник

user2554328 09 июл '13 в 15:53

13 ответов

Решение

Вы можете использовать CancelableOperation или CancelableCompleter, чтобы отменить будущее.

С помощью CancelableOperation (включен в тест, так что вы можете попробовать сами):

test("CancelableOperation with future", () async {
  var cancellableOperation = CancelableOperation.fromFuture(
    Future.value('future result'),
    onCancel: () => {debugPrint('onCancel')},
  );

  // cancellableOperation.cancel();

  cancellableOperation.value.then((value) => {
        debugPrint('then: $value'),
      });
  cancellableOperation.value.whenComplete(() => {
        debugPrint('onDone'),
      });
});

test("CancelableOperation with stream", () async {
  var cancellableOperation = CancelableOperation.fromFuture(
    Future.value('future result'),
    onCancel: () => {debugPrint('onCancel')},
  );

  //  cancellableOperation.cancel();

  cancellableOperation.asStream().listen(
        (value) => { debugPrint('value: $value') },
        onDone: () => { debugPrint('onDone') },
      );
});

Оба вышеуказанных теста будут выводить:

then: future result
whenComplete

Теперь, если мы раскомментируем cancellableOperation.cancel(); тогда оба вышеуказанных теста будут выводить:

onCancel

С помощью CancelableCompleter если вам нужно больше контроля:

test("CancelableCompleter is cancelled", () async {
  CancelableCompleter completer = CancelableCompleter(onCancel: () {
    print('onCancel');
  });

  // completer.operation.cancel();

  completer.complete(Future.value('future result'));
  print('isCanceled: ${completer.isCanceled}');
  print('isCompleted: ${completer.isCompleted}');
  completer.operation.value.then((value) => {
    print('then: $value'),
  });
  completer.operation.value.whenComplete(() => {
    print('onDone'),
  });
});

Выход:

isCanceled: false
isCompleted: true
then: future result
onDone

Теперь, если мы раскомментируем cancellableOperation.cancel(); мы получаем вывод:

onCancel
isCanceled: true
isCompleted: true

Помните, что если вы используете await cancellableOperation.value или же await completer.operation тогда он никогда не вернет результат и будет ждать бесконечно, если операция была отменена. Это потому что await cancellableOperation.value так же, как писать cancellableOperation.value.then(...) но then() никогда не вызывается, если операция была отменена.

Не забудьте добавить асинхронный пакет Dart.

Суть кода

131

Источник

user1502079 27 фев '19 в 12:48

Как отменить `Future.delayed`

Простой способ - использовать Timer вместо этого:)

Timer _timer;

void _schedule() {
  _timer = Timer(Duration(seconds: 2), () { 
    print('Do something after delay');
  });
}

@override
void dispose() {
  super.dispose();
  _timer?.cancel();
}

47

Источник

user1321917 23 апр '20 в 13:36

Одним из способов, которым я смог "отменить" запланированное выполнение, было использование Timer, В этом случае я фактически откладывал это.:)

Timer _runJustOnceAtTheEnd;

void runMultipleTimes() {
  if (_runJustOnceAtTheEnd != null) {
    _runJustOnceAtTheEnd.cancel();
    _runJustOnceAtTheEnd = null;
  }

  // do your processing

  _runJustOnceAtTheEnd = Timer(Duration(seconds: 1), onceAtTheEndOfTheBatch);
}

void onceAtTheEndOfTheBatch() {
  print("just once at the end of a batch!");
}


runMultipleTimes();
runMultipleTimes();
runMultipleTimes();
runMultipleTimes();

// will print 'just once at the end of a batch' one second after last execution

runMultipleTimes() метод будет вызываться несколько раз подряд, но только через 1 секунду после onceAtTheEndOfTheBatch будет выполнен.

9

Источник

user796963 06 дек '18 в 18:34

Для тех, кто пытается достичь этого во Флаттере, вот простой пример того же.

class MyPage extends StatelessWidget {
  final CancelableCompleter<bool> _completer = CancelableCompleter(onCancel: () => false);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("Future")),
      body: Column(
        children: <Widget>[
          RaisedButton(
            child: Text("Submit"),
            onPressed: () async {
              // it is true only if the future got completed
              bool _isFutureCompleted = await _submit();
            },
          ),
          RaisedButton(child: Text("Cancel"), onPressed: _cancel),
        ],
      ),
    );
  }

  Future<bool> _submit() async {
    _completer.complete(Future.value(_solve()));
    return _completer.operation.value;
  }

  // This is just a simple method that will finish the future in 5 seconds
  Future<bool> _solve() async {
    return await Future.delayed(Duration(seconds: 5), () => true);
  }

  void _cancel() async {
    var value = await _completer.operation.cancel();
    // if we stopped the future, we get false
    assert(value == false);
  }
}

9

Источник

user6618622 29 май '19 в 13:22

Мои 2 цента стоят...

class CancelableFuture {
  bool cancelled = false;
  CancelableFuture(Duration duration, void Function() callback) {
    Future<void>.delayed(duration, () {
      if (!cancelled) {
        callback();
      }
    });
  }

  void cancel() {
    cancelled = true;
  }
}

6

Источник

user1995341 15 авг '19 в 02:26

Существует CancelableOperation в пакете асинхронного на pub.dev, которые вы можете использовать, чтобы сделать это сейчас. Этот пакет не следует путать со встроенной базовой библиотекой dart. dart:async, у которого нет этого класса.

4

Источник

user2880055 18 ноя '20 в 02:30

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

import 'dart:async';

class API {
  Completer<bool> _completer;
  Timer _timer;

  // This function returns 'true' only if timeout >= 5 and
  // when cancelOperation() function is not called after this function call.
  //
  // Returns false otherwise
  Future<bool> apiFunctionWithTimeout() async {
    _completer = Completer<bool>();
    // timeout > time taken to complete _timeConsumingOperation() (5 seconds)
    const timeout = 6;

    // timeout < time taken to complete _timeConsumingOperation() (5 seconds)
    // const timeout = 4;

    _timeConsumingOperation().then((response) {
      if (_completer.isCompleted == false) {
        _timer?.cancel();
        _completer.complete(response);
      }
    });

    _timer = Timer(Duration(seconds: timeout), () {
      if (_completer.isCompleted == false) {
        _completer.complete(false);
      }
    });

    return _completer.future;
  }

  void cancelOperation() {
    _timer?.cancel();
    if (_completer.isCompleted == false) {
      _completer.complete(false);
    }
  }

  // this can be an HTTP call.
  Future<bool> _timeConsumingOperation() async {
    return await Future.delayed(Duration(seconds: 5), () => true);
  }
}

void main() async {
  API api = API();
  api.apiFunctionWithTimeout().then((response) {
    // prints 'true' if the function is not timed out or canceled, otherwise it prints false
    print(response);
  });
  // manual cancellation. Uncomment the below line to cancel the operation.
  //api.cancelOperation();
}

Тип возврата можно изменить с bool к вашему собственному типу данных. Completer объект также следует изменить соответственно.

2

Источник

user2369932 21 авг '20 в 14:01

Измените задачу на будущее с "сделать что-то" на "сделать что-то, если оно не было отменено". Очевидным способом реализации этого было бы установить логический флаг и проверить его в будущем закрытии перед началом обработки, и, возможно, в нескольких точках во время обработки.

Кроме того, это похоже на хак, но установка времени ожидания в будущем на ноль, по-видимому, эффективно отменит будущее.

1

Источник

user652220 04 авг '14 в 22:16

Вы можете использовать метод timeout()

Создайте фиктивное будущее:

      Future<String?> _myFuture() async {
    await Future.delayed(const Duration(seconds: 10));
    return 'Future completed';
}

Установка тайм-аута в 3 секунды для ранней остановки с 10 секунд:

      _myFuture().timeout(
      const Duration(seconds: 3),
      onTimeout: () =>
          'The process took too much time to finish. Please try again later',
);

и вот вы отменяете свое БУДУЩЕЕ.

1

Источник

user5813279 19 окт '22 в 01:59

Вот решение, чтобы отменить ожидаемое отложенное будущее

Это решение , как awaitable или отменяемый Future.delayed: это отменяется как Timer И ждут, как Future.

Он основан на очень простом классе, CancelableCompleter, вот демонстрация:

      import 'dart:async';

void main() async {  
  print('start');
  
  // Create a completer that completes after 2 seconds…
  final completer = CancelableCompleter.auto(Duration(seconds: 2));
  
  // … but schedule the cancelation after 1 second
  Future.delayed(Duration(seconds: 1), completer.cancel);
  
  // We want to await the result
  final result = await completer.future;

  print(result ? 'completed' : 'canceled');
  print('done');
  // OUTPUT:
  //  start
  //  canceled
  //  done
}

Теперь код класса:

      class CancelableCompleter {
  CancelableCompleter.auto(Duration delay) : _completer = Completer() {
    _timer = Timer(delay, _complete);
  }

  final Completer<bool> _completer;
  late final Timer? _timer;

  bool _isCompleted = false;
  bool _isCanceled = false;

  Future<bool> get future => _completer.future;

  void cancel() {
    if (!_isCompleted && !_isCanceled) {
      _timer?.cancel();
      _isCanceled = true;
      _completer.complete(false);
    }
  }

  void _complete() {
    if (!_isCompleted && !_isCanceled) {
      _isCompleted = true;
      _completer.complete(true);
    }
  }
}

пример с более полным классом доступен в Действующийэтом DartPad .

1

Источник

user2083587 23 сен '21 в 19:18

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

      class CancelableFuture<T> {
  Function(Object) onErrorCallback;
  Function(T) onSuccessCallback;
  bool _wasCancelled = false;

  CancelableFuture(Future<T> future,
      {this.onSuccessCallback, this.onErrorCallback}) {
    assert(onSuccessCallback != null || onErrorCallback != null);
    future.then((value) {
      if (!_wasCancelled && onSuccessCallback != null) {
        onSuccessCallback(value);
      }
    }, onError: (e) {
      if (!_wasCancelled && onErrorCallback != null) {
        onErrorCallback(e);
      }
    });
  }

  cancel() {
    _wasCancelled = true;
  }
}

А вот и пример использования. PS Я использую в своем проекте провайдера:

      _fetchPlannedLists() async {
    if (_plannedListsResponse?.status != Status.LOADING) {
      _plannedListsResponse = ApiResponse.loading();
      notifyListeners();
    }

    _plannedListCancellable?.cancel();

    _plannedListCancellable = CancelableFuture<List<PlannedList>>(
        _plannedListRepository.fetchPlannedLists(),
        onSuccessCallback: (plannedLists) {
      _plannedListsResponse = ApiResponse.completed(plannedLists);
      notifyListeners();
    }, onErrorCallback: (e) {
      print('Planned list provider error: $e');
      _plannedListsResponse = ApiResponse.error(e);
      notifyListeners();
    });
  }

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

0

Источник

user10084055 08 июл '21 в 20:40

нет возможности к сожалению, посмотрите:

      import 'dart:async';

import 'package:async/async.dart';

void main(List<String> args) async {
  final object = SomeTimer();
  await Future.delayed(Duration(seconds: 1));
  object.dispose();
  print('finish program');
}

class SomeTimer {
  SomeTimer() {
    init();
  }

  Future<void> init() async {
    completer
        .complete(Future.delayed(Duration(seconds: 10), () => someState = 1));
    print('before wait');
    await completer.operation.valueOrCancellation();
    print('after wait');
    if (completer.isCanceled) {
      print('isCanceled');
      return;
    }
    print('timer');
    timer = Timer(Duration(seconds: 5), (() => print('finish timer')));
  }

  Timer? timer;
  int _someState = 0;
  set someState(int value) {
    print('someState set to $value');
    _someState = value;
  }

  CancelableCompleter completer = CancelableCompleter(onCancel: () {
    print('onCancel');
  });

  void dispose() {
    completer.operation.cancel();
    timer?.cancel();
  }
}

через десять секунд вы увидитеsomeState set to 1не важно что

-1

Источник

user5797755 19 авг '22 в 17:23

Другие вопросы по тегам dart dart-async

user638061 11 июл '13 в 21:33 2013-07-11 21:33 · Accepted Answer · 2013-07-11 21:33

Насколько я знаю, нет способа отменить будущее. Но есть способ отменить подписку на Stream, и, возможно, это поможет вам.

призвание onSubmit на кнопку возвращает StreamSubscription объект. Вы можете явно сохранить этот объект, а затем вызвать cancel() на нем для отмены потоковой подписки:

StreamSubscription subscription = someDOMElement.onSubmit.listen((data) {

   // you code here

   if (someCondition == true) {
     subscription.cancel();
   }
});

Позже, в ответ на какое-либо действие пользователя, возможно, вы можете отменить подписку:

Есть ли способ отменить дротик Future?

13 ответов

Не забудьте добавить асинхронный пакет Dart.

Как отменить Future.delayed

Вот решение, чтобы отменить ожидаемое отложенное будущее

Как отменить `Future.delayed`