c# - 无法从标记为异步的方法返回IObservable <T>

这个人为设计的示例大致是我的代码的结构:

public abstract class SuperHeroBase
{
    protected SuperHeroBase() { }

    public async Task<CrimeFightingResult> FightCrimeAsync()
    {
        var result = new CrimeFightingResult();

        result.State = CrimeFightingStates.Fighting;

        try
        {
            await FightCrimeOverride(results);
        }
        catch
        {
            SetError(results);
        }

        if (result.State == CrimeFightingStates.Fighting)
            result.State = CrimeFightingStates.GoodGuyWon;

        return result;
    }

    protected SetError(CrimeFightingResult results)
    {
        result.State = CrimeFightingStates.BadGuyWon;
    }

    protected abstract Task FightCrimeOverride(CrimeFightingResult results);
}

public enum CrimeFightingStates
{
    NotStarted,
    Fighting,
    GoodGuyWon, // success state
    BadGuyWon // error state
}

public class CrimeFightingResult
{
    internal class CrimeFightingResult() { }

    public CrimeFightingStates State { get; internal set; }
}

现在，我正在尝试构建一个包含多个SuperHero对象并提供AllHerosFightCrime方法的集合。英雄的英雄不应该一次全部战斗(下一场战斗在第一个完成时开始)。

public class SuperHeroCollection : ObservableCollection<SuperHeroBase>
{
    public SuperHeroCollection() { }

    // I mark the method async...
    public async IObservable<CrimeFightingResult> AllHerosFightCrime()
    {
        var heros = new List<SuperHeroBase>(this);

        var results = new ReplaySubject<CrimeFightingResult>();

        foreach (var hero in heros)
        {
            // ... so I can await on FightCrimeAsync and push
            // the result to the subject when done
            var result = await hero.FightCrimeAsync();
            results.OnNext(result);
        }

        results.OnCompleted();

        // I can't return the IObservable here because the method is marked Async.
        // It expects a return type of CrimeFightingResult
        return results;
    }
}

如何返回IObservable<CrimeFightingResults>并仍在等待FightCrimeAsync的调用？

最佳答案

您可以将您的任务变成可观察的任务，并使用Merge将它们组合起来:

public IObservable<CrimeFightingResult> AllHerosFightCrime()
{
    var heros = new List<SuperHeroBase>(this);
    return heros.Select(h => h.FightCrimeAsync().ToObservable())
        .Merge();
}

如果要保持接收事件的顺序，可以使用Concat而不是Merge。

关于c# - 无法从标记为异步的方法返回IObservable <T>，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/20361542/