Schwierigkeiten haben, über Vererbung oder Generika von redundantem Code befreit

Question

Sorry für die vagen Titel, aber ich war nicht sicher, wie dies in einem Satz zusammenfassen. Ich habe eine Situation mit viel redundantem C# -Code, und es sieht wirklich so aus, als würde eine Art verrückter Trick, der eine Eigenschaft der Vererbung oder Generika verwendet, dies lösen. Allerdings bin ich kein besonders erfahrener Programmierer (besonders bei C#) und kann die Lösung nicht wirklich sehen.

Die Situation, in vereinfachter Form, sieht wie folgt aus etwas. Ich habe eine Reihe von Klassen, die alle von einem Typ erben.

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

Das Problem tritt auf, wenn Sammlungen dieser Objekte verarbeitet werden müssen. Meine erste Lösung (die schlechte) sieht so aus:

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

... und so weiter. Das Problem besteht darin, dass im Prinzip der gesamte Code in den ProcessX-Methoden derselbe ist wie der Typ der Objekte, die bearbeitet werden. Es wäre schön, all dies aus offensichtlichen Gründen in einer Methode zusammenzufassen.

Mein erster Gedanke war, nur eine generische Process() -Methode zu machen, die einen List<SuperFoo> als Parameter nahm und nur von dort fortfahren. Das Problem ist, dass ein generisches SuperFoo keinen Somemethod hat(), und es kann man nicht haben, weil jeder der Somemethod Kinderklassen() einen anderen Rückgabetyp hat, so überschreibt, die nicht funktioniert.

Answer 1

ich hinzufügen, in der Regel eine Schnittstelle, die auf Basistypen arbeitet.

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

Natürlich hängt es davon ab, wofür Sie das Ergebnis verwenden.

Manchmal können Sie können machen es einfacher mit Generika, aber Sie können auch in einem Durcheinander enden. Manchmal ist es einfach einfacher irgendwo runter zu gehen. Natürlich versuchen Sie dies zu vermeiden, wann immer Sie es sich leisten können.

Answer 2

Hier ist ein Beispiel dafür, wie diese könnten Generika arbeiten mit und machen SuperFoo eine abstrakte Klasse.

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

Sie konnten die ISuperFoo Schnittstelle mit einer konkreten Klasse ersetzen, wenn nötig, aber dann müsste man den Rückgabewert werfen, welche Art von Niederlagen der Zweck.

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