如何在不等待结果的情况下在另一个内部运行挂起功能？

Question

我有一个场景，我的代码必须发送一个 api 调用并继续其工作（其中包含另一个 api 调用），而无需等待第一次调用的结果。

现在我在我的视图模型中这样做

fun showItem(id:Int) {
   launch{
       repo.markItemRead(id)
   }
   launch {
       try {
           val item = repo.getItemById(id).getOrThrow
           commands.postValue(ShowItemCommand(item))
       } catch (t:Throwable) {
           commands.postValue(ShowError(R.string.error_retrieve_item))
           repo.logError(t)
       }
   }
}

这会调用具有这两个功能的存储库

suspend fun markItemRead(id) {
    try {
        service.markItemAsRead(id)
    } catch(ignored:Throwable) {
    }
}

suspend fun getItemById(id) : Result<ItemData> {
    return try {
       val response : ItemEntity = service.getItemById(id)
       val item  = response.toData()
       Result.Success(item)
    } catch (t:Throwable) {
        Result.Failure(t)
    }
}

如果存储库完成所有这些工作，我会更喜欢它，因为每次都必须跟随另一个。

不幸的是，当我尝试在我的存储库中做这样的事情时：

suspend fun getItemById(id:Int) : Result<ItemData> {
    try {
        service.markItemAsRead(id)
    } catch(ignored:Throwable) {
    }
    return try {
       val response : ItemEntity = service.getItemById(id)
       val item  = response.toData()
       Result.Success(item)
    } catch (t:Throwable) {
        Result.Failure(t)
    }
}

它会等待markItemAsRead 函数完成后再继续

除了定义存储库的范围并将markItemAsRead 调用放在launch 中（我已经读过在挂起函数中执行此操作是不正确的）之外，还有其他方法可以在存储库中执行此操作吗？

Answer 1

查看coroutineScope 函数是否符合您的要求：

创建一个 CoroutineScope 并使用此范围调用指定的挂起块。提供的作用域从外部作用域继承其 coroutineContext，但会覆盖上下文的 Job。

suspend fun getItemById(id:Int) : Result<ItemData> {
    coroutineScope {
        launch {
            try {
                service.markItemAsRead(id)
            } catch(ignored:Throwable) { }
        }
    }

    return try {
       val response : ItemEntity = service.getItemById(id)
       val item  = response.toData()
       Result.Success(item)
    } catch (t:Throwable) {
        Result.Failure(t)
    }
}

Answer 2

在存储库中还有其他方法吗？

没有

（我已经读过在挂起函数中执行的操作是不正确的）

完全可以在挂起函数中使用launch 来完成“一劳永逸”任务

Answer 3

您希望并行执行多个任务，但在所有任务完成后返回函数。如果我是对的。

您可以使用异步/等待。内部挂起函数

val d1 = async { t1() }
val d2 = async { t2() }
d1.await()
d2.await()
// all tasks done

t1 和 t2 将并行运行。当 t1.await() 调用它会等待结果，但 t2 仍在运行。

在你的函数中你可以这样改变它：

suspend fun getItemById(id:Int) : Result<ItemData> = coroutineScope {
    val t1 = async {
        try {
            service.markItemAsRead(id)
        } catch(ignored:Throwable) {
            null
        }
    }
    val t2 = async {
        try {
            val response : ItemEntity = service.getItemById(id)
            val item = response.toData()
            Result.Success(item)
        } catch (t:Throwable) {
            Result.Failure(t)
        }
    }
    t1.await()
    return@coroutineScope t2.await()
}