难以通过继承或泛型摆脱冗余代码

Question

抱歉标题含糊不清，但我不知道如何用一句话来概括这一点。我有很多冗余 C# 代码的情况，它看起来确实像某种巧妙的技巧，使用某些继承或泛型属性可以解决这个问题。但是，我不是一个非常有经验的程序员（尤其是 C#），只是不太了解解决方案。

情况，以简化的形式，看起来像这样。我有一堆类都继承自一种类型。

public class Foo : SuperFoo
{
     ...
     public Foo SomeMethod() { ... }
}
public class Bar : SuperFoo
{
     ...
     public Bar SomeMethod() { ... }
}
public class Baz : SuperFoo
{
     ...
     public Baz SomeMethod() { ... }
}
...    
public class SuperFoo
{
     ...
}

当需要处理这些对象的集合时，问题就出现了。我的第一稿解决方案（糟糕的）如下所示：

public void SomeEventHasHappened(...)
{
     ProcessFoos();
     ProcessBars();
     ProcessBazes();
     ...
}

public void ProcessFoos()
{
     ...
     foreach (var foo in fooList)
     {
          ...
          foo.SomeMethod();
     }
}
public void ProcessBars()
{
     ...
     foreach (var bar in barList)
     {
          ...
          bar.SomeMethod();
     }
}

...等等。问题是 ProcessX 方法中的所有代码基本上都是相同的，除了正在操作的对象的类型。出于显而易见的原因，将所有这些合并到一种方法中会很好。

我的第一个想法是创建一个通用的 Process() 方法，该方法将 List<SuperFoo> 作为参数，然后从那里继续。问题是泛型 SuperFoo 没有 SomeMethod()，它也没有 SomeMethod()，因为每个子类的 SomeMethod() 都有不同的返回类型，所以覆盖不起作用。

Answer 1

我通常会添加一个对基本类型进行操作的接口。

interface ISuperFoo
{
    public ISuperFoo SomeMethod() { ... }
}

public class Foo : SuperFoo, ISuperFoo
{
     // concrete implementation
     public Foo SomeMethod() { ... }

     // method for generic use, call by base type
     public ISuperFoo ISuperFoo.SomeMethod() 
     { 
       return SomeMethod(); 
     }
}

public void Processs()
{
     ...
     foreach (var iSuperFoo in list)
     {
          ...
          iSuperFoo.SomeMethod();
     }
}

当然，这取决于您使用结果的目的。

有时您可以更轻松地使用泛型，但您也可能会陷入混乱。有时，在某个地方沮丧会更容易。当然，只要你能负担得起，你就会尽量避免这种情况。

Answer 2

这是一个如何使用泛型并使 SuperFoo 成为抽象类的示例。

public interface ISuperFoo
{
    ...
}

public abstract class SuperFoo<T> where T : ISuperFoo
{
    public abstract T SomeMethod();
}

public class BazReturn : ISuperFoo
{
    ...
}

public class Baz: SuperFoo<BazReturn>
{
    public override BazReturn SomeMethod()
    {
        throw new NotImplementedException();
    }
}

public class BarReturn : ISuperFoo
{
    ...
}

public class Bar : SuperFoo<BarReturn>
{
    public override BarReturn SomeMethod()
    {
        throw new NotImplementedException();
    }
}

public static class EventHandler
{
    public static void SomeEventHasHappened(List<SuperFoo<ISuperFoo>> list)
    {
        foreach (SuperFoo<ISuperFoo> item in list)
        {
            ISuperFoo result = item.SomeMethod();
        }
    }
}

如果需要，您可以将 ISuperFoo 接口替换为具体的类，但是您必须强制转换返回值，这会违背目的。

public abstract class SuperFoo<T>
{
    public abstract T SomeMethod();
}

public class Foo : SuperFoo<int>
{
    public override int SomeMethod()
    {
        throw new NotImplementedException();
    }
}

public static class EventHandler
{
    public static void SomeEventHasHappened(List<SuperFoo<int>> list)
    {
        foreach (SuperFoo<int> item in list)
        {
            item.SomeMethod();
        }
    }
}