C#编码模式问题

我有以下代码：

protected void Initialize(){
  this.Fonts.Initialize();
  this.Screens.Initialize();
  this.Menu.Initialize();
}

protected void Update(){
  this.Screens.Update();
  this.Menu.Update();
}

写了这篇文章后，我重新考虑了代码：

protected void Initialize(){
  this.CallMethod<INeedInitialization>(
  (i) => { i.Initialize(); }
  , this.Fonts, this.Screens, this.Menu
  );
}

protected void Update(){
  this.CallMethod<INeedUpdating>(
   (i) => { i.Update(); }
    , this.Screens, this.Menu
  );
}

private void CallMethod<T>(Action<T> action, params T[] items){
  items.ToList().ForEach(i => action(i));
}

protectedvoid Initialize（）{
这是一个调用方法(
（i） =>{i.初始化（）；}
，这个.字体，这个.屏幕，这个.菜单
);
}
受保护的无效更新（）{
这是一个调用方法(
（i） =>{i.Update（）；}
，这个。屏幕，这个。菜单
);
}
私有void调用方法（操作，参数T[]项）{
items.ToList（）.ForEach（i=>action（i））；
}

然后，我意识到在我的代码库中，

CallMethod

类型的操作有很多重用，因此我进一步考虑：

public static extensions{
  // I use object type as I can have INeedInitialization, INeedUpdate etc...
  public static void CallMethod<T>(this object obj, Action<T> action, 
params T[] items){
   items.ToList().ForEach(i => action(i));
  }
}

公共静态扩展{
//我使用对象类型，因为我可以使用IneInitialization、IneUpdate等。。。
公共静态void CallMethod（此对象对象、操作、，
参数T[]项）{
items.ToList（）.ForEach（i=>action（i））；
}
}

现在，我可以在我的所有对象上获得

CallMethod

，但是在这样做之后，我觉得这段代码有一些根本性的错误&无法指出我觉得它不正确的原因

此外-如何在泛型方法上设置或约束，使其仅接受

ineedUpdate

或

INeedInitialize

对象类型，而不是扩展基本

对象

类型

有人能帮忙吗

---

谢谢

要回答您的问题，您可以创建函数的两个副本，每个接口一个：

public static void CallMethod<T>(this INeedUpdating obj, Action<T> action, 
params T[] items){
   items.ToList().ForEach(i => action(i));
}
public static void CallMethod<T>(this INeedInitialize obj, Action<T> action, 
params T[] items){
   items.ToList().ForEach(i => action(i));
}

!

---

这似乎是花式编码综合征的一个例子。我看不到从常规例程中获得的任何好处，以及维护、调试和测试所需的额外代码的巨大开销。

是的，这看起来很奇怪。我想到的第一件事是创建theese的集合，然后简单地在方法中循环它们

List<INeedInitialization> InitializedComponents = new List<INeedInitialization> {Fonts, Screens, Menus};
List<INeedUpdating> UpdatedComponents = new List<INeedUpdating> {Screens, Menus}

protected void Initialize(){
  foreach(var i in InitializedComponents)
    i.Initialize();
}

protected void Update(){
  foreach(var u in UpdatedComponents)
    u.Update();
}

List initialized components=新列表{字体、屏幕、菜单}；
List UpdatedComponents=新列表{屏幕、菜单}
受保护的void初始化（）{
foreach（InitializedComponents中的变量i）
i、 初始化（）；
}
受保护的无效更新（）{
foreach（UpdatedComponents中的var u）
u、 更新（）；
}

---

这可以很好地成为复杂类层次结构的一部分，只需将更多项添加到集合中，而无需更改或重写方法本身。

或者，就此而言，只需保留原始项即可。它不需要循环。当然，只要给他选择：）我通常更喜欢命名约定

IInitializable

和

iUpdateable

。仅仅为了使用

ForEach（）

而将集合转换为列表是一件令人讨厌的事情！只要使用一个适当的循环，或者创建一个适当的扩展方法来隐藏它，如果你有这种倾向的话。。。我认为没有必要为了简单地调用几个方法而制定这样一个复杂的计划。OP采取了明显的行为，并将其转化为我必须花时间去弄清楚的东西，只是要意识到它是在以一种“奇特”的方式调用一些方法。只让你的代码尽可能复杂。。。

List<INeedInitialization> InitializedComponents = new List<INeedInitialization> {Fonts, Screens, Menus};
List<INeedUpdating> UpdatedComponents = new List<INeedUpdating> {Screens, Menus}

protected void Initialize(){
  foreach(var i in InitializedComponents)
    i.Initialize();
}

protected void Update(){
  foreach(var u in UpdatedComponents)
    u.Update();
}