C# 为集合中的多个对象使用块创建

给定以下代码：

using (payment.GetModifyLock())
{
    foreach (var paymentItem in paymentItems)
    {
        using (paymentItem.GetModifyLock())
        {
            
        }
    }
    DoAction();
}

我希望修改这段代码，以便

DoAction

在所有using块（而不仅仅是一个）内完成。如果集合包含两项，我希望它以以下方式运行：

using(payment.GetModifyLock())
using(paymentItem1.GetModifyLock())
using(paymentItem2.GetModifyLock())
{
    DoAction();
}

---

这可能吗？

我想我已经用这个代码解决了这个问题：

using (payment.GetModifyLock())
{
    var locks = new List<DistributedLock>();
    try
    {
        foreach (var paymentItem in paymentItems)
        {
            locks.Add(paymentItem.GetModifyLock());
        }

        // Do action
    }
    finally
    {
        foreach (var locker in locks)
        {
            locker.Dispose(); ;
        }
    }
}

使用（payment.GetModifyLock（））
{
var locks=新列表（）；
尝试
{
foreach（paymentItems中的var paymentItem）
{
locks.Add（paymentItem.GetModifyLock（））；
}
//行动
}
最后
{
foreach（var锁中的锁）
{
locker.Dispose（）；
}
}
}

如果您想创建一个更可重用的版本，您可以将该功能包装到IDisposable helper类中。这很幼稚，不建议用于生产代码，但它是一个简单的、可重用的抽象

public class NestedLocker : IDisposable
{
    private readonly IDisposable _parentLocker;
    private readonly Queue<IDisposable> _childLockers = new Queue<IDisposable>();
    
    public NestedLocker(Func<IDisposable> parentLocker, 
        IEnumerable<Func<IDisposable>> childLockers)
    {
        _parentLocker = parentLocker();
        
        foreach (var childLocker in childLockers)
        {
            _childLockers.Enqueue(childLocker());
        }
    }

    public void Dispose()
    {
        foreach (var childLocker in _childLockers)
        {
            childLocker.Dispose();
        }
        
        _parentLocker.Dispose();
    }
}

void Main()
{
    Func<IDisposable> parentLocker = () => new ParentLocker();
    List<Func<IDisposable>> childLockers = 
        new List<Func<IDisposable>> { () => new ChildLocker(), () => new ChildLocker() };
    using (new NestedLocker(parentLocker, childLockers))
    {
        Console.WriteLine("action");
    }
}

public class ParentLocker : IDisposable
{
    public ParentLocker()
    {
        Console.WriteLine("Parent locker created");
    }
    
    public void Dispose()
    {
        Console.WriteLine("Parent locker disposed");
    }
}

public class ChildLocker : IDisposable
{
    public ChildLocker()
    {
        Console.WriteLine("Child locker created");
    }
    
    public void Dispose()
    {
        Console.WriteLine("Child locker disposed");
    }
}

Parent locker created
Child locker created
Child locker created
action
Child locker disposed
Child locker disposed
Parent locker disposed