C# 从IObservable列表创建IObservable列表

我正在寻找一个实现

IObservable

和

IList

的反应式对象

就这样，我希望能够写：

var list = new MyReactiveList<int>();
var item = new new Subject<int>();
list.Subscribe(values => Console.WriteLine($"[{string.Join(", ", values)}]"));
list.Add(item);
item.OnNext(1); // Will print out [1]

var list=new MyReactiveList（）；
var item=新主题（）；
订阅（值=>Console.WriteLine（$“[{string.Join（“，”，values）}]”）；
列表。添加（项目）；
项目.OnNext（1）；//将打印出[1]

首先，您在问题中发布的代码无法编译。我已尽我所能将其修复：

var list = new MyReactiveList<int>();
var item = new Subject<int>();
list.Subscribe(values => Console.WriteLine($"[{string.Join(", ", values)}]"));
list.Add(item);
item.OnNext(1); // Will print out [1]

var list=new MyReactiveList（）；
var item=新主题（）；
订阅（值=>Console.WriteLine（$“[{string.Join（“，”，values）}]”）；
列表。添加（项目）；
项目.OnNext（1）；//将打印出[1]

现在的练习只是实现

类MyReactiveList:IObservable，IList

。这相当简单，但唯一的问题是如何将可变的

列表

转换为

IObservable

，这样，当列表发生变化时，可观察对象会自动更新

这是：

public class MyReactiveList<T> : IObservable<IReadOnlyList<T>>, IList<IObservable<T>>
{
    private List<IObservable<T>> _list = new List<IObservable<T>>();

    private Subject<Unit> _update = new Subject<Unit>();

    public IDisposable Subscribe(IObserver<IReadOnlyList<T>> observer) =>
        _update
            .Select(_ => _list.CombineLatest().Select(x => new ReadOnlyList<T>(x)))
            .Switch()
            .Subscribe(observer);

    public IObservable<T> this[int index]
    {
        get => _list[index];
        set
        {
            _list[index] = value;
            _update.OnNext(Unit.Default);
        }
    }

    public int Count => _list.Count;

    public bool IsReadOnly => false;

    public void Add(IObservable<T> item)
    {
        _list.Add(item);
        _update.OnNext(Unit.Default);
    }

    public void Clear()
    {
        _list.Clear();
        _update.OnNext(Unit.Default);
    }

    public bool Contains(IObservable<T> item) => _list.Contains(item);

    public void CopyTo(IObservable<T>[] array, int arrayIndex)
    {
        _list.CopyTo(array, arrayIndex);
    }

    public IEnumerator<IObservable<T>> GetEnumerator() => _list.GetEnumerator();

    public int IndexOf(IObservable<T> item) => _list.IndexOf(item);

    public void Insert(int index, IObservable<T> item)
    {
        _list.Insert(index, item);
        _update.OnNext(Unit.Default);
    }

    public bool Remove(IObservable<T> item)
    {
        var removed = _list.Remove(item);
        _update.OnNext(Unit.Default);
        return removed;
    }

    public void RemoveAt(int index)
    {
        _list.RemoveAt(index);
        _update.OnNext(Unit.Default);
    }

    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
}

public class ReadOnlyList<T> : IReadOnlyList<T>
{
    public ReadOnlyList(IEnumerable<T> items) { _list.AddRange(items); }

    private List<T> _list = new List<T>();

    public T this[int index] => _list[index];

    public int Count => _list.Count;

    public IEnumerator<T> GetEnumerator() => _list.GetEnumerator();

    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
}

公共类MyReactiveList:IObservable，IList
{
私有列表_List=新列表（）；
私有主题_update=新主题（）；
公共IDisposable订阅（IObserver观察员）=>
_更新
.Select（=>_list.CombineLatest（）.Select（x=>newreadonlylist（x）））
.Switch（）
.签署（观察员）；
公共IObservable此[int索引]
{
获取=>_列表[索引]；
设置
{
_列表[索引]=值；
_update.OnNext（单位默认值）；
}
}
公共整数计数=>\u list.Count；
公共bool IsReadOnly=>false；
公共作废添加（IObservable项）
{
_列表。添加（项目）；
_update.OnNext（单位默认值）；
}
公共空间清除（）
{
_list.Clear（）；
_update.OnNext（单位默认值）；
}
公共bool Contains（IObservable项）=>\u列表包含（项）；
public void CopyTo（IObservable[]数组，int-arrayIndex）
{
_CopyTo（数组，arrayIndex）；
}
public IEnumerator GetEnumerator（）=>\u list.GetEnumerator（）；
public int IndexOf（IObservable项）=>\u list.IndexOf（项）；
公共无效插入（int索引，IObservable项）
{
_列表。插入（索引，项目）；
_update.OnNext（单位默认值）；
}
公共布尔删除（IObservable项）
{
var removed=_list.Remove（项目）；
_update.OnNext（单位默认值）；
移除返回；
}
公共无效删除（整数索引）
{
_列表。删除（索引）；
_update.OnNext（单位默认值）；
}
IEnumerator IEnumerable.GetEnumerator（）=>\u list.GetEnumerator（）；
}
公共类ReadOnlyList:IReadOnlyList
{
公共只读列表（IEnumerable items）{{u list.AddRange（items）；}
私有列表_List=新列表（）；
public T this[int index]=>_list[index]；
公共整数计数=>\u list.Count；
public IEnumerator GetEnumerator（）=>\u list.GetEnumerator（）；
IEnumerator IEnumerable.GetEnumerator（）=>\u list.GetEnumerator（）；
}

---

注意：实现您自己的可观察对象不是一个好主意-很容易出错，并创建与并发性不兼容的代码。

谢谢，我修复了我问题中的列表类型参数。@Orace-我不喜欢我的代码

\u list.combinelateTest（）。选择（x=>new ReadOnlyList（x））

。你能解释一下你希望用这些类型来实现什么，这样我就能想出更好的方法来实现它吗？