如何重构嵌套使用中涉及的代码

本文关键字：代码 嵌套 何重构 重构 | 更新日期: 2023-09-27 18:32:04

我有一些代码有很多重复。 问题来自我正在处理嵌套IDisposable类型的事实。 今天我有一些看起来像：

public void UpdateFromXml(Guid innerId, XDocument someXml)
{
    using (var a = SomeFactory.GetA(_uri))
    using (var b = a.GetB(_id))
    using (var c = b.GetC(innerId))
    {
        var cWrapper = new SomeWrapper(c);
        cWrapper.Update(someXml);
    }
}
public bool GetSomeValueById(Guid innerId)
{
    using (var a = SomeFactory.GetA(_uri))
    using (var b = a.GetB(_id))
    using (var c = b.GetC(innerId))
    {
        return c.GetSomeValue();
    }
}

对于这些方法中的每一个，整个嵌套using块都是相同的（显示了两个，但大约有十个）。 唯一不同的是，当您到达using块的内部级别时会发生什么。

我想的一种方法是做一些类似的事情：

public void UpdateFromXml(Guid innerId, XDocument someXml)
{
    ActOnC(innerId, c =>
    { 
        var cWrapper = new SomeWrapper(c);
        cWrapper.Update(someXml);
    });
}
public bool GetSomeValueById(Guid innerId)
{
    var result = null;
    ActOnC(innerId, c => { result = c.GetSomeValue(); });
    return result;
}
private void ActOnC(Guid innerId, Action<TheCType> action)
{
    using (var a = SomeFactory.GetA(_uri))
    using (var b = a.GetB(_id))
    using (var c = b.GetC(innerId))
    {
        action(c);
    }        
}

这有效，只是解析起来有点笨拙（作为人类）。 有没有人对如何减少像这样的嵌套using块周围的代码重复有任何其他建议？ 如果它们不是IDisposable那么人们可能只是创建一个方法来返回b.GetC(innerId)的结果......但这里的情况并非如此。

如何重构嵌套使用中涉及的代码

我喜欢BFree提供的答案作为开始，但我会做一些修改。

//Give it a better name; this isn't designed to be a general purpose class
public class MyCompositeDisposable : IDisposable 
{
    public MyCompositeDisposable (string uri, int id, int innerid)
    {
        A = SomeFactory.GetA(uri);
        B = A.GetB(id);
        C = B.GetC(innerId);
    }
    //You can make A & B private if appropriate; 
    //not sure if all three or just C should be exposed publicly.
    //Class names are made up; you'll need to fix.  
    //They should also probably be given more meaningful names.
    public ClassA A{get;private set;}
    public ClassB B{get;private set;}
    public ClassC C{get;private set;}
    public void Dispose()
    {
        A.Dispose();
        B.Dispose();
        C.Dispose();
    }
}

完成此操作后，您可以执行以下操作：

public bool GetSomeValueById(Guid innerId)
{
    using(MyCompositeDisposable d = new MyCompositeDisposable(_uri, _id, innerId))
    {
        return d.C.GetSomeValue();
    }
}

请注意，MyCompositeDisposable 可能需要在构造函数和 Dispose 方法中包含 try/finally 块，以便正确创建/销毁中的错误确保最终没有未释放的内容。

在 Rx 框架中，有一个名为 CompositeDisposable http://msdn.microsoft.com/en-us/library/system.reactive.disposables.compositedisposable%28v=vs.103%29.aspx 的类

自己

滚动应该不会太难（尽管非常精简的版本）：

public class CompositeDisposable : IDisposable
{
    private IDisposable[] _disposables;
    public CompositeDisposable(params IDisposable[] disposables)
    {
        _disposables = disposables;
    }
    public void Dispose()
    {
        if(_disposables == null)
        {
            return;
        }
        foreach(var disposable in _disposables)
        {
            disposable.Dispose();
        }
    }
}

然后这看起来更干净一点：

public void UpdateFromXml(Guid innerId, XDocument someXml)
{
    var a = SomeFactory.GetA(_uri);
    var b = a.GetB(_id);
    var c = b.GetC(innerId);
    using(new CompositeDisposable(a,b,c))
    {
        var cWrapper = new SomeWrapper(c);
        cWrapper.Update(someXml);
    }
}

您始终可以创建一个更大的上下文来管理应创建/释放哪些对象。 然后编写一个方法来创建更大的上下文...

public class DisposeChain<T> : IDisposable where T : IDisposable
{
    public T Item { get; private set; }
    private IDisposable _innerChain;
    public DisposeChain(T theItem)
    {
        this.Item = theItem;
        _innerChain = null;
    }
    public DisposeChain(T theItem, IDisposable inner)
    {
        this.Item = theItem;
        _innerChain = inner;
    }
    public DisposeChain<U> Next<U>(Func<T, U> getNext) where U : IDisposable
    {
        try
        {
            U nextItem = getNext(this.Item);
            DisposeChain<U> result = new DisposeChain<U>(nextItem, this);
            return result;
        }
        catch  //an exception occurred - abort construction and dispose everything!
        {
            this.Dispose()
            throw;
        }
    }
    public void Dispose()
    {
        Item.Dispose();
        if (_innerChain != null)
        {
            _innerChain.Dispose();
        }
    }
}

然后使用它：

    public DisposeChain<DataContext> GetCDisposeChain()
    {
        var a = new DisposeChain<XmlWriter>(XmlWriter.Create((Stream)null));
        var b = a.Next(aItem => new SqlConnection());
        var c = b.Next(bItem => new DataContext(""));
        return c;
    }
    public void Test()
    {
        using (var cDisposer = GetCDisposeChain())
        {
            var c = cDisposer.Item;
            //do stuff with c;
        }
    }

如果您的Dispoable类型正确处理了所有一次性成员，则只需要一个 using 语句。

例如，这个：

public bool GetSomeValueById(Guid innerId)
{
    using (var a = SomeFactory.GetA(_uri))
    using (var b = a.GetB(_id))
    using (var c = b.GetC(innerId))
    {
        return c.GetSomeValue();
    }
}
如果 A 具有类型 B 和 C

的成员，并且 A 在其处置方法中处理了 B 和 C，则可以变成这样：

public bool GetSomeValueById(Guid innerId)
{
    using (var a = SomeFactory.GetA(_uri))
    {
        return a.GetSomeValue();
    }
}
class A : IDisposable
{
  private a;
  private b;
  public A (B b, C c)
  {
     this.b = b; this.c = c;
  }
  public void Dispose()
  {
     Dispose(true);
  }
  protected void Dispose(bool disposing)
  {
     if (disposing)
     {
        b.Dispose();
        c.Dispose();
     }
  }
}

但是，您必须修改工厂以将 b 和 c 注入 a。

相关文章：