Tiene problemas para deshacerse del código redundante a través de la herencia o genéricos

Question

Disculpe el título impreciso, pero no estaba seguro de cómo resumir esto en una frase. Tengo una situación con mucho código C# redundante, y realmente parece que algún tipo de truco astuto usando alguna propiedad de herencia o genéricos resolvería esto. Sin embargo, no soy un programador terriblemente experimentado (particularmente con C#) y simplemente no puedo ver la solución.

La situación, en forma simplificada, se parece a esto. Tengo un montón de clases que todas heredan de un tipo.

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

El problema surge cuando las colecciones de estos objetos deben procesarse. Mi solución de primer borrador (la mala) se ve así:

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(); 
    } 
} 

... y así sucesivamente. El problema es que básicamente todo el código en los métodos ProcessX es el mismo, aparte del tipo de los objetos que se están operando. Sería bueno consolidar todos estos en un método por razones obvias.

Mi primer pensamiento fue simplemente hacer un método genérico de Process() que tomó un List<SuperFoo> como parámetro y continuar desde allí. El problema es que un SuperFoo genérico no tiene un SomeMethod(), y no puede tener uno porque cada una de las clases secundarias 'SomeMethod() tiene un tipo de devolución diferente, por lo que no funciona el reemplazo.

Answer 1

Normalmente agrego una interfaz que opera en tipos de base.

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(); 
    } 
} 

Por supuesto, depende de qué se está utilizando el resultado para.

A veces usted puede hacer que sea más fácil usar genéricos, pero también puede terminar en un lío. A veces es más fácil deprimirse en algún lugar. Por supuesto, intenta evitar esto cada vez que puede pagarlo.

Answer 2

Aquí hay un ejemplo de cómo esto podría funcionar usando genéricos y haciendo que SuperFoo sea una clase abstracta.

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(); 
     } 
    } 
} 

podría reemplazar la interfaz ISuperFoo con una clase concreta, si es necesario, pero entonces tendría que emitir el valor de retorno qué tipo de derrota el propósito.

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(); 
     } 
    } 
}