c# - 如何在不使用反射的情况下避免重复访问属性的代码

Question

我有这些结构

class A : IFoo {
   Foo(){
      //do something
   }
   IList<B> Bs {get;set;}
   IList<C> Cs {get;set;}
}

class B : IFoo {
   Foo(){
      //do something
   }
   IList<D> Ds {get;set;}
}

class C : IFoo {
   Foo(){
      //do something
   }
}

class D : IFoo {
   Foo(){
      //do something
   }
}

class Helper{
  Bar(A a){
     a.Foo();
     Bar(a.Bs);
     Bar(a.Cs);
  }

  Bar(IList<B> bs)
  {
     foreach(var b in bs)
     {
        Bar(b);
     }
  }

  Bar(B b)
  {
     b.Foo();
     Bar(b.Ds);
  }

  Bar(IList<C> cs)
  {
     foreach(var c in cs)
     {
        Bar(c);
     }
  }

  Bar(C c)
  {
     c.Foo();
  }

  Bar(IList<D> ds)
  {
     foreach(var d in ds)
     {
        Bar(d);
     }
  }

  Bar(D d)
  {
     d.Foo();
  }
}
interface IFoo {
  void Foo();
}

如您所见，Helper 中重复了很多代码类(即方法 Bar )用于不同类型的 A,B,C,IList<A>,IList<B>,IList<C> .此外，当一个新的列表属性被添加到类时，我需要返回并更改 Helper 类，这在某种程度上与 Open/Close 主体相矛盾。

我知道如何使用 Reflection来解决这个问题，但我正在寻找另一种聪明而巧妙的方法来解决这个问题，而不是使用反射。

我有空加新Interface s 但不是基类

任何建议将不胜感激

Answer 1

如果你想保持 OPEN/CLOSE 原则不变，你可以使用这样的东西 -

• 每个类(class)都会根据需要进行扩展。
• 新类不需要修改旧类- Helper。所以实现变得有点像下面的那个。无论您添加多少个类，每个类都负责自己的 Foo 和 Bar 实现。

示例 -

public interface IFoo
{
    void Foo();
    void Bar();
}

public abstract class BaseFoo : IFoo
{
    public virtual void Foo()
    {
        //do nothing
    }

    public virtual void Bar()
    {
        //do nothing
    }
}

public class A : BaseFoo //replace with IFoo if you do not want the base class, in that case implement both methods
{
    IList<B> Bs { get; set; }
    IList<C> Cs { get; set; }

    public override void Bar()
    {
        base.Bar();

        foreach (var b in Bs)
        {
            b.Bar();
        }

        foreach (var c in Cs)
        {
            c.Bar();
        }
    }
}

public class B : BaseFoo //replace with IFoo if you do not want the base class, in that case implement both methods
{
    IList<D> Ds { get; set; }

    public override void Bar()
    {
        base.Bar();

        foreach (var d in Ds)
        {
            d.Bar();
        }
    }
}

public class C : BaseFoo //replace with IFoo if you do not want the base class, in that case implement both methods
{

}

public class D : BaseFoo //replace with IFoo if you do not want the base class, in that case implement both methods
{

}

public static class Helper
{
    public static void Bar(params IFoo[] foos)
    {
        foreach (var foo in foos)
        {
            foo.Bar();
        }
    }
}