C# 使用IObservable.GetAwaiter处理错误

我试着查看了可用的文档，但没能走远。

---

我不熟悉将异步/任务与IObservable相结合，因此我认为存在一个概念性错误，请务必让我知道

处理异常的一种可能方法是使用

ContinueWith

方法，如下面的代码示例中所示（我使用了一些虚拟类和枚举来使代码正常工作，您可以用自己已经存在的类和枚举来替换它们）

使用系统；
使用System.Collections.Generic；
使用系统集合；
使用System.Reactive.Threading；
使用System.Reactive.Linq；
使用System.Threading.Tasks；
班级计划
{
公共静态void Main（）
{
var packets=getMyPacket（）。ContinueWith（（a）=>
{
数据包=空；
if（a.Exception！=null&&a.Exception.InnerException.GetType（）==typeof（TimeoutException））
{
数据包=新的错误数据包（错误。超时）；
}
其他的
{
数据包=a.结果；
}
返回包；
});
Console.ReadLine（）；
WriteLine（packets.Result.GetType（））；
}
静态异步任务getMyPacket（）
{
var list=新列表（）；
添加（新数据包（FrameType.CMD_ID_0））；
IObservable packets=list.ToObservable（）；
var aw=等待数据包
.Where（x=>x.FrameType==FrameType.CMD\u ID\u 0）
.FirstAsync（）
//.超时（时间跨度从秒（0））
.GetAwaiter（）；
返回aw；
}
类包
{
公共框架类型框架类型{get；set；}
公共数据包（）
{
}
公共数据包（FrameType FrameType）
{
FrameType=FrameType；
}
}
类ErrorPacket:Packet
{
公共错误包（错误）
{
}
}
枚举帧类型
{
CMD_ID_0，
CMD_ID_1
}
枚举错误
{
超时
}
}

IObservable有一个“Catch”扩展方法来完成此任务

using System;
using System.Collections.Generic;
using System.Collections;

using System.Reactive.Threading;
using System.Reactive.Linq;
using System.Threading.Tasks;

class Program
{
    public static void Main()
    {
        var packets = getMyPacket().ContinueWith((a) =>
        {
            Packet packet = null;
            if (a.Exception != null && a.Exception.InnerException.GetType() == typeof(TimeoutException))
            {
                packet = new ErrorPacket(Error.TIMEOUT);
            }
            else
            {
                packet = a.Result;
            }
            return packet;
        });

        Console.ReadLine();
        Console.WriteLine(packets.Result.GetType());
    }

    static async Task<Packet> getMyPacket()
    {
        var list = new List<Packet>();
        list.Add(new Packet(FrameType.CMD_ID_0));

        IObservable<Packet> packets = list.ToObservable();
        var aw = await packets
                 .Where(x => x.FrameType == FrameType.CMD_ID_0)
                 .FirstAsync()
                 //.Timeout(TimeSpan.FromSeconds(0))
                 .GetAwaiter();

        return aw;

    }
    class Packet
    {
        public FrameType FrameType { get; set; }
        public Packet() 
        {
        }
        public Packet(FrameType frameType)
        {
            FrameType = frameType;
        }
    }
    class ErrorPacket : Packet
    {
        public ErrorPacket(Error error)
        {
        }
    }

    enum FrameType
    {
        CMD_ID_0,
        CMD_ID_1
    }

    enum Error
    {
        TIMEOUT
    }
}

等待数据包
.Where（x=>x.frameType==CMD\u ID\u 0）
.超时（时间跨度从秒（5））
.Catch（Observable.Empty（））
.LastOrDefaultAsync（）；

上面的操作将等待适当的响应数据包或超时。wait使用GetAwaiter在空序列上抛出异常，因此LastOrDefaultAsync（）有助于避免这种情况。或者，在try-catch之间封装也会起作用

await packets
         .Where(x => x.frameType == CMD_ID_0 )
         .FirstAsync()
         .TimeOut( TimeSpan.FromSeconds(5))
         .GetAwaiter (   , ,OnError: return newErrorPacket(TIMEOUT) ) 
         ;

using System;
using System.Collections.Generic;
using System.Collections;

using System.Reactive.Threading;
using System.Reactive.Linq;
using System.Threading.Tasks;

class Program
{
    public static void Main()
    {
        var packets = getMyPacket().ContinueWith((a) =>
        {
            Packet packet = null;
            if (a.Exception != null && a.Exception.InnerException.GetType() == typeof(TimeoutException))
            {
                packet = new ErrorPacket(Error.TIMEOUT);
            }
            else
            {
                packet = a.Result;
            }
            return packet;
        });

        Console.ReadLine();
        Console.WriteLine(packets.Result.GetType());
    }

    static async Task<Packet> getMyPacket()
    {
        var list = new List<Packet>();
        list.Add(new Packet(FrameType.CMD_ID_0));

        IObservable<Packet> packets = list.ToObservable();
        var aw = await packets
                 .Where(x => x.FrameType == FrameType.CMD_ID_0)
                 .FirstAsync()
                 //.Timeout(TimeSpan.FromSeconds(0))
                 .GetAwaiter();

        return aw;

    }
    class Packet
    {
        public FrameType FrameType { get; set; }
        public Packet() 
        {
        }
        public Packet(FrameType frameType)
        {
            FrameType = frameType;
        }
    }
    class ErrorPacket : Packet
    {
        public ErrorPacket(Error error)
        {
        }
    }

    enum FrameType
    {
        CMD_ID_0,
        CMD_ID_1
    }

    enum Error
    {
        TIMEOUT
    }
}

await packets
         .Where(x => x.frameType == CMD_ID_0 )       
         .TimeOut( TimeSpan.FromSeconds(5))
         .Catch( Observable.Empty<packet>())
         .LastOrDefaultAsync();