Wie man den Aufruf einer abgeleiteten C#-Methode erzwingt

Question

Ich habe eine Klasse, die von einem Tool generiert wurde und die ich daher nicht ändern kann. Die generierte Klasse ist sehr einfach (keine Schnittstelle, keine virtuellen Methoden):

class GeneratedFoo
{
  public void Write(string p) { /* do something */ }
}

Im C#-Projekt wollen wir eine Möglichkeit schaffen, um eine andere Implementierung von MyFoo einzubinden. Ich denke also, dass MyFoo von GeneratedFoo abgeleitet werden soll

class MyFoo : GeneratedFoo
{
  public new void Write(string p) { /* do different things */ }
}

Dann habe ich eine CreateFoo-Methode, die entweder eine Instanz der Klasse GeneratedFoo oder MyFoo zurückgeben wird. Sie ruft jedoch immer die Methode in GeneratedFoo auf.

GeneratedFoo foo = CreateFoo(); // if this returns MyFoo,
foo.Write("1"); // it stills calls GeneratedFoo.Write

Dies wird erläutert, da es sich nicht um eine virtuelle Methode handelt. Aber ich frage mich, ob es eine Möglichkeit (ein Hack vielleicht), um es die abgeleitete Methode aufrufen.

Danke,
Ian

Answer 1

Adam hat Ihnen eine (richtige) Antwort gegeben. Jetzt ist es Zeit für den Hack, nach dem du gefragt hast :)

class BaseFoo
{
    public void Write() { Console.WriteLine("Hello simple world"); }
}

class DerFoo : BaseFoo
{
    public void Write() { Console.WriteLine("Hello complicated world"); }
}

public static void Main()
{
    BaseFoo bs = new DerFoo();
    bs.Write();

    bs.GetType().GetMethod("Write").Invoke(bs, null);
}

Druckt aus:

Hello simple world
Hello complicated world

Answer 2

Ohne die Möglichkeit, die Methode virtuell zu machen, nein. Eine nicht-virtuelle Methode ist zur Kompilierzeit statisch gelinkt und kann nicht geändert werden.

Answer 3

Schreiben Sie eine Erweiterungsmethode, die auf Ihren abgeleiteten Typ safecastet und die Methode gegen que stattdessen eine Referenz.

public static class Extensions
{
  public static void WriteFoo(this GeneratedFoo foo, string p)
  {
     MyFoo derived = foo as MyFoo;
     if (derived != null)
     {
        derived.Write(p);
     }
     else
     {
        foo.Write(p);
     }
  }
}

und rufen ihn dann mit

GeneratedFoo unknownFoo;
unknownFoo.WriteFoo("win");

NB : Das ist ein schmutziger Hack. Eine klarere Lösung wäre, sich zu fragen warum müssen Sie die new Modifikator in erster Linie. Die Überladung der Bedeutung von Write(p) macht Ihren Code für die Betreuer verwirrend. Sie könnten es genauso gut deklarieren public void WriteToTarget() oder etwas viel Spezifischeres, um diese Verwirrung von vornherein zu vermeiden.

Answer 4

Die Verwendung von "new" für eine Methode ist kein Overriding, sondern ein Verstecken der ursprünglichen Methode. Dies ist etwas völlig anderes als Polymorphismus und sollte vermieden werden. Sein einziger Zweck ist die Kovarianz/Kontravarianz von Methoden, die eine identische Funktion ausführen (z. B. public Foo Clone(); und public new Bar Clone();). Der andere Zweck ist für Legacy-Code, wenn eine identisch benannte Methode zu einer Basisklasse hinzugefügt wird, über die Sie keine Kontrolle haben und den Namen Ihrer Methode zu diesem Zeitpunkt nicht ändern können.

Obwohl die beiden Methoden denselben Namen tragen, handelt es sich um völlig unterschiedliche Methoden, die einen anderen Platz in der Methodentabelle der Klasse einnehmen, während das Überschreiben die vorhandene Methode in der Methodentabelle der Klasse ersetzt.

Meine Lösung dafür wäre, eine Schnittstelle wie IFoo zu verwenden und entweder die generierte Klasse zu bearbeiten oder eine Proxyklasse zu verwenden, die alle ihre Methodenaufrufe an eine Instanz von GeneratedFoo delegiert, um IFoo zu implementieren.

public DelegatingFoo : IFoo
{
  private GeneratedFoo foo;

  public DelegatingFoo(GeneratedFoo foo) { this.foo = foo; }
  public void Write(string p) { foo.Write(p); }
}

Answer 5

Wenn die generierte Klasse keine virtuelle Methode hat, ist dies nicht möglich. Wenn Sie das Tool so ändern könnten, dass die Write-Methode als virtuell generiert wird, dann verwenden Sie in MyFoo das Schlüsselwort override anstelle von new, um die Write-Methode zu qualifizieren. Eine zweite Möglichkeit wäre, ein Skript/Makro zu schreiben, um den Quellcode von GeneratedFoo zu ändern, nachdem das Tool gelaufen ist, um die Zeichenfolge "virtual" vor den gewünschten Methoden als Teil Ihres Build-Prozesses einzufügen.