Вызов наблюдаемых синхронно один за другим в Angular
У меня доступны следующие сервисные вызовы:
productService.GetAllProducts ()
productService.DeleteProduct ()
productService.GetCategories ()
productService.DeleteCategory ()
В коде sudo мне нужно сделать следующее в моем компоненте:
Получите список продуктов с помощью productService.GetAllProducts ().
Прокрутите список продуктов и вызовите productService.DeleteProduct () для каждого продукта.
Как только я смогу подтвердить, что все вышеупомянутые удаления завершены (из-за ограничений базы данных), мне нужно затем получить список категорий с помощью productService.GetCategories (). Прокрутите каждую категорию и вызовите productService.DeleteCategory ().
Я понимаю, что моя жизнь была бы намного проще, если бы у меня были более совершенные внутренние вызовы для массового удаления, но в данном случае у меня нет выбора. Мне нужно следовать схеме получения списка, перебора его, индивидуального удаления каждого элемента.
Возможно ли вообще то, что я пытаюсь сделать, используя flatMap и наблюдаемый полный параметр? Моя самая большая проблема - это знать, когда код завершает удаление всех продуктов, прежде чем искать и удалять все категории.
Ссылки в этом посте не решают мою проблему. Вы действительно читаете то, что я пытаюсь сделать, или просто сразу помечаете вещи как дубликаты на основе заголовка? Я понял, что моя проблема немного отличается от сообщения, на которое вы указали ссылку, поэтому создал новое сообщение.
Они действительно решают вашу проблему. Но наблюдаемые сложно, и вам нужно внимательно прочитать статьи, при необходимости несколько раз, и поэкспериментировать, прежде чем просто отклонить решение. Если в статьях / предложениях есть что-то, чего вы не понимаете, попросите разъяснений вместо того, чтобы повторять тот же вопрос.
Понятно, я изучу их более внимательно. В любом случае, вы можете просто дать мне общее представление, глядя на мои 4 шага кода sudo выше того, какие функции мне понадобятся для каждой части?
Сделайте одну наблюдаемую из нескольких, которые должны выполняться параллельно (то есть множество удалений), используя forkJoin. Используйте switchMap для выполнения одного наблюдаемого объекта за другим.
Спасибо, это должно привести меня на правильный путь. Прошу прощения, я не осознавал, что наблюдаемые настолько сложны. Я так привык писать такой код синхронно на C#, просто выполняя прямые вызовы репозиториев.
@JBNizet, это нет, что делает switchMap!
@BJNizet По крайней мере, это неполное вводящее в заблуждение описание switchMap. switchMap поддерживает только одну внутреннюю подписку и отменит все подписки, кроме последней, если подписка еще не завершена. concat подписывается на одну наблюдаемую после завершения другой. switchMap подписывается, как только становится доступным следующее наблюдаемое, и немедленно освобождает свою подписку на предыдущее наблюдаемое.
Ответы 1
Вы можете попробовать что-то в этом роде
productService.GetAllProducts()
.switchMap(
products => forkJoin(products.map(product => productService.DeleteProduct(product)))
)
.switchMap(() => productService.GetCategories())
.switchMap(
categories => forkJoin(categories.map(category => productService.DeleteCategory(category)))
)
.subscribe(() => console.info('done'))
Вся идея в следующем
- GetAllProducts возвращает массив продуктов, который передается как
параметр к первому
switchMap - Массив Products преобразуется через
mapв массив Наблюдаемые объекты, являющиеся результатом DeleteProduct - массива Observable передается первомуforkJoinв качестве параметра forkJoinизлучает, когда все наблюдаемые объекты, полученные как параметр завершен, и, следовательно, будет выдан, когда все продукты были удалены- То же самое рассуждение повторяется для категорий
Я не уверен, что код синтаксически совершенен, но этого должно быть достаточно, чтобы дать вам представление о том, как действовать дальше.
спасибо за отличный ответ. На самом деле я решил разрешить это аналогичным образом, все еще используя forkJoin и map для удалений, поэтому они происходят параллельно, но установил каждый из наблюдаемых удалений в переменную, а затем использовал concat и подписался на него. Примерно так ... Подпишитесь на GetAllProducts, а затем создайте в нем const deleteProducts, который выполняет forkJoin и map. Затем подписался на GetCategories, а затем внутри нее создайте константу deleteCategories, которая выполняет forkJoin и map. Затем, наконец, const deletes = concat (deleteProducts, deleteCategories) .subscribe ().
дайте мне знать, если вы считаете, что техника switchMap лучше по какой-либо причине.
Я не уверен, что понимаю логику, но на первый взгляд у меня возникает вопрос, как вы уверены, что deletes = concat(deleteProducts, deleteCategories).subscribe() работает с deleteProducts, а deleteCategories на самом деле являются переменными, указывающими на результат 2 forkJoin, и они все еще не undefined. Подход, который я предлагаю, представляет собой цепочку операторов, которые шаг за шагом преобразуют первый "исходный" Observable в другие Observable, пока вы не получите последний объект, на который вы подписались, чтобы выполнить работу. Вообще я склонен думать, что чем меньше у вас subscribe, тем он лучше.
С помощью цепочки я предлагаю вам всегда знать, что вы делаете, и каким-то образом вы можете вернуть контроль над потоками асинхронных событий, таких как те, которые вы описываете.
Вы уже задавали такой же вопрос: stackoverflow.com/questions/51047390/…. И вы получили ответ и несколько ссылок.