C# 你还不够懒吗？

我感到惊讶的是，被动扩展

CompositeDisposable

类未能通过以下测试

[Test]
public void TestDisposable()
{
    var ds = new List<IDisposable>();
    int[] a = { 1, 2, 3 };
    using (new CompositeDisposable(ds))
    {
        ds.Add(Disposable.Create(() => a[0] = 3));
        ds.Add(Disposable.Create(() => a[2] = 1));
    }
    Assert.That(a[0],Is.EqualTo(3)); //Failed here
    Assert.That(a[1], Is.EqualTo(2));
    Assert.That(a[2], Is.EqualTo(1));
}

[测试]
公开作废测试（）
{
var ds=新列表（）；
int[]a={1,2,3}；
使用（新的复合可编程（ds））
{
ds.Add（Disposable.Create（（）=>a[0]=3））；
ds.Add（Disposable.Create（（）=>a[2]=1））；
}
Assert.That（a[0]，Is.EqualTo（3））；//此处失败
断言（a[1]，等于（2））；
断言（a[2]，等于（1））；
}

这意味着如果我通过给定一个

IEnumerable

来创建一个

CompositeDisposable

，它实际上会迭代它的所有元素，而不是将其延迟到调用的

Dispose

---

这在其他情况下可能有用，但在我的情况下不方便。是否还有其他类可用于上述更简单的功能？

CompositeDisposable的构造函数将复制您的列表。因此，当您随后将元素添加到列表中时，

CompositeDisposable

将不会使用这些元素

以下是一个简单的解决方案：

using (var composite = new CompositeDisposable())
{
    composite.Add(Disposable.Create(() => a[0] = 3));
    composite.Add(Disposable.Create(() => a[2] = 1));
}

或者，如果不方便，这里有一个解决方法：

public static IDisposable AsLazyComposite(this IEnumerable<IDisposable> sequence)
{
    return Disposable.Create(() =>
    {
        foreach (var disposable in sequence)
            disposable.Dispose();
    });
}

---

CompositeDisposable

的构造函数将复制您的列表。因此，当您随后将元素添加到列表中时，

CompositeDisposable

将不会使用这些元素

以下是一个简单的解决方案：

using (var composite = new CompositeDisposable())
{
    composite.Add(Disposable.Create(() => a[0] = 3));
    composite.Add(Disposable.Create(() => a[2] = 1));
}

或者，如果不方便，这里有一个解决方法：

public static IDisposable AsLazyComposite(this IEnumerable<IDisposable> sequence)
{
    return Disposable.Create(() =>
    {
        foreach (var disposable in sequence)
            disposable.Dispose();
    });
}