如何在Coroutine范围中返回价值？

Question

是否可以在coroutine范围中返回值，而无需运行阻塞？ 目前，我在存储库中的代码看起来像这样：

    suspend fun getWorkItem(workItemId: Int): WorkItemRoom? {
        runBlocking {
            return@runBlocking
            CoroutineScope(Dispatchers.Main).launch {
                getWorkItemByIdUseCase.build(workItemId)
            }
        }
        return null
    }

这是我的用户录取

class GetWorkItemByIdUseCase(private val workItemDao: WorkItemDao) :
    BaseUseCase<Int, WorkItemRoom>() {
    override suspend fun create(id: Int): WorkItemRoom {
        return workItemDao.getWorkItemById(id)
    }

}

碱基cassecase

abstract class BaseUseCase<P, R> {
    protected abstract suspend fun create(params: P): R
    open suspend fun build(params: P): R = create(params)
}

dao

@Dao
abstract class WorkItemDao {

    @Query("SELECT * FROM workitem WHERE id=:id")
    abstract suspend fun getWorkItemById(id: Int): WorkItemRoom
}

...但是我当然知道这不是一个正确的解决方案。您将如何实现这一目标？在viewModels'或片段中，我可以直接使用 lifecyclescope“，但是在其他情况下，必须直接从下面的方法调用USECase。一直致电调度员是否有效？

CoroutineScope(Dispatchers.Main).launch { }

Answer 1

您可以将值从Coroutine传递给Livedata，然后使用观察者

private val observableMutableLiveData = MutableLiveData<Type>()
val observableLiveData: LiveData<Type> = observableMutableLiveData

，然后在Coroutine中进行：

CoroutineScope(Dispatchers.Main).launch {
    observableMutableLiveData.postValue(value)
}

然后在活动中：

viewModel.observableLiveData.observe(this) { Type ->
   Log.i("result", Type)
}

Answer 2

在悬挂功能中使用Runblocking是没有意义的。 （在一个项目中部分转换为使用Coroutines的项目中，除了作为Coroutines和非coroutine代码之间的桥梁之外，完全使用它几乎没有任何意义，但仍然需要支持遗留代码或库。

）你需要。

suspend fun getWorkItem(workItemId: Int): WorkItemRoom? { //may not need nullable return value
    return getWorkItemByIdUseCase.build(workItemId)
}

如果您需要指定调度程序，请使用 使用：

suspend fun getWorkItem(workItemId: Int): WorkItemRoom? = withContext(Dispatchers.Main) { 
    getWorkItemByIdUseCase.build(workItemId)
}

但是，如果构建是暂停功能，则无需在调用时指定调度程序。暂停功能负责内部调用其在适当的线程/调度器上的功能。

如果您需要在Coroutine或悬挂功能内部的coroutine范围，请使用小写coroutinescope函数，该功能会创建一个范围，如果取消Coroutine，该范围将自动取消。这个示例没有多大意义，因为通常您不需要新的范围，除非您在其中运行并行作业：

suspend fun getWorkItem(workItemId: Int): WorkItemRoom? = coroutineScope(Dispatchers.Main) { 
    getWorkItemByIdUseCase.build(workItemId)
}

Answer 3

您是否曾经听过 lambda ？
它看起来像呼叫：（ myResult） - ＆gt;单位
我不时使用它

fun someToDo(call: (MyResult) -> Unit) {
    scope.launch(Dispatchers.IO) {
        val result = getFromSomeWere()
        launch(Dispatchers.Main){call(result)}
    }
}