Was ist die richtige Alternative zur statischen Methodenvererbung?

Ich verstehe, dass die Vererbung statischer Methoden in C # nicht unterstützt wird. Ich habe auch eine Reihe von Diskussionen gelesen (einschließlich hier), in denen Entwickler behaupten, dass diese Funktionalität benötigt wird. Die typische Antwort lautet: "Wenn Sie eine statische Mitgliedervererbung benötigen, liegt ein Fehler in Ihrem Design vor."

OK, da OOP nicht möchte, dass ich überhaupt über statische Vererbung nachdenke, muss ich zu dem Schluss kommen, dass mein offensichtlicher Bedarf darauf auf einen Fehler in meinem Design hinweist. Aber ich stecke fest. Ich würde mich sehr über Hilfe bei der Lösung dieses Problems freuen. Hier ist die Herausforderung ...

Ich möchte eine abstrakte Basisklasse erstellen (nennen wir es eine Frucht), die einen komplexen Initialisierungscode enthält. Dieser Code kann nicht in den Konstruktor eingefügt werden, da ein Teil davon auf virtuellen Methodenaufrufen beruht.

Obst wird von anderen konkreten Klassen (Apple, Orange) geerbt, von denen jede eine Standard-Factory-Methode CreateInstance () verfügbar machen muss, um eine Instanz zu erstellen und zu initialisieren.

Wenn eine Vererbung statischer Elemente möglich wäre, würde ich die Factory-Methode in die Basisklasse einfügen und einen virtuellen Methodenaufruf an die abgeleitete Klasse verwenden, um den Typ zu erhalten, von dem eine konkrete Instanz initialisiert werden muss. Der Client-Code würde einfach Apple.CreateInstance () aufrufen, um eine vollständig initialisierte Apple-Instanz zu erhalten.

Dies ist jedoch eindeutig nicht möglich. Kann jemand erklären, wie sich mein Design ändern muss, um die gleiche Funktionalität zu gewährleisten?

Eine Idee:

public abstract class Fruit<T>
    where T : Fruit<T>, new()
{
    public static T CreateInstance()
    {
        T newFruit = new T();
        newFruit.Initialize();  // Calls Apple.Initialize
        return newFruit;
    }

    protected abstract void Initialize();
}

public class Apple : Fruit<Apple>
{
    protected override void Initialize() { ... }
}

Und ruf so an:

Apple myAppleVar = Fruit<Apple>.CreateInstance();

Keine zusätzlichen Fabrikklassen erforderlich.

Verschieben Sie die Factory-Methode aus dem Typ und fügen Sie sie in eine eigene Factory-Klasse ein.

public abstract class Fruit
{
    protected Fruit() {}

    public abstract string Define();

}

public class Apple : Fruit
{
    public Apple() {}

    public override string Define()
    {
         return "Apple";
    }
}

public class Orange : Fruit
{
    public Orange() {}

    public override string Define()
    {
         return "Orange";
    }
}

public static class FruitFactory<T> 
{
     public static T CreateFruit<T>() where T : Fruit, new()
     {
         return new T();
     }
}

Wenn ich mir das anschaue, ist es nicht erforderlich, die Create-Methode in eine eigene Factory-Klasse zu verschieben (obwohl ich denke, dass dies vorzuziehen ist - Trennung von Bedenken -). Sie können sie in die Fruit-Klasse einfügen:

public abstract class Fruit
{

   public abstract string Define();

   public static T CreateFruit<T>() where T : Fruit, new()
   {
        return new T();
   }

}

Und um zu sehen, ob es funktioniert:

    class Program
    {
        static void Main( string[] args )
        {
            Console.WriteLine (Fruit.CreateFruit<Apple> ().Define ());
            Console.WriteLine (Fruit.CreateFruit<Orange> ().Define ());

            Console.ReadLine ();
        }        
    }

Warum nicht eine Factory-Klasse (mit Vorlagen) mit einer create-Methode erstellen?

FruitFactory<Banana>.Create();

Ich würde so etwas tun

 public abstract class Fruit() {
      public abstract void Initialize();
 }

 public class Apple() : Fruit {
     public override void Initialize() {

     }
 }

 public class FruitFactory<T> where T : Fruit, new {
      public static <T> CreateInstance<T>() {
          T fruit = new T();
          fruit.Initialize();
          return fruit;  
      }
 } 


var fruit = FruitFactory<Apple>.CreateInstance()

Die WebRequestKlasse und ihre Ableitungstypen in der .NET BCL sind ein gutes Beispiel dafür, wie diese Art von Design relativ gut implementiert werden kann.

Die WebRequestKlasse hat mehrere Unterklassen, einschließlich HttpWebRequestund FtpWebReuest. Diese WebRequestBasisklasse ist jetzt auch ein Factory-Typ und macht eine statische CreateMethode verfügbar (die Instanzkonstruktoren sind ausgeblendet, wie es das Factory-Muster erfordert).

public static WebRequest Create(string requestUriString)
public static WebRequest Create(Uri requestUri)

Diese CreateMethode gibt eine bestimmte Implementierung von zurückWebRequest Klasse zurück und bestimmt anhand des URI (oder der URI-Zeichenfolge) den Objekttyp, der erstellt und zurückgegeben werden soll.

Dies hat das Endergebnis des folgenden Verwendungsmusters:

var httpRequest = (HttpWebRequest)WebRequest.Create("http://stackoverflow.com/");
// or equivalently
var httpRequest = (HttpWebRequest)HttpWebWebRequest.Create("http://stackoverflow.com/");

var ftpRequest = (FtpWebRequest)WebRequest.Create("ftp://stackoverflow.com/");
// or equivalently
var ftpRequest = (FtpWebRequest)FtpWebWebRequest.Create("ftp://stackoverflow.com/");

Ich persönlich denke, dies ist ein guter Weg, um das Problem anzugehen, und es scheint tatsächlich die bevorzugte Methode der .NET Framework-Ersteller zu sein.

Erstens bedeutet das Fehlen von statischen Initialisierern, die virtuell sein können, nicht, dass Sie keine "Standard" -Mitgliedmethoden haben können, die überladen sein könnten. Zweitens können Sie Ihre virtuellen Methoden von Konstruktoren aus aufrufen, und sie funktionieren wie erwartet, sodass hier kein Problem auftritt. Drittens können Sie Generika verwenden, um eine typsichere Fabrik zu haben.
Hier ist ein Code, der die vom Konstruktor aufgerufene Methode factory + member Initialize () verwendet (und geschützt ist, sodass Sie sich keine Sorgen machen müssen, dass jemand sie nach dem Erstellen eines Objekts erneut aufruft):

abstract class Fruit
{
    public Fruit()
    {
        Initialize();
    }

    protected virtual void Initialize()
    {
        Console.WriteLine("Fruit.Initialize");
    }
}

class Apple : Fruit
{
    public Apple()
        : base()
    { }

    protected override void Initialize()
    {
        base.Initialize();
        Console.WriteLine("Apple.Initialize");
    }

    public override string ToString()
    {
        return "Apple";
    }
}

class Orange : Fruit
{
    public Orange()
        : base()
    { }

    protected override void Initialize()
    {
        base.Initialize();
        Console.WriteLine("Orange.Initialize");
    }

    public override string ToString()
    {
        return "Orange";
    }
}

class FruitFactory
{
    public static T CreateFruit<T>() where T : Fruit, new()
    {
        return new T();
    }
}

public class Program
{

    static void Main()
    {
        Apple apple = FruitFactory.CreateFruit<Apple>();
        Console.WriteLine(apple.ToString());

        Orange orange = new Orange();
        Console.WriteLine(orange.ToString());

        Fruit appleFruit = FruitFactory.CreateFruit<Apple>();
        Console.WriteLine(appleFruit.ToString());
    }
}

Ich würde sagen, das Beste ist, eine virtuelle / abstrakte Initialisierungsmethode für die Fruchtklasse zu erstellen, die aufgerufen werden muss, und dann eine externe 'Fruchtfabrik'-Klasse zu erstellen, um Instanzen zu erstellen:

public class Fruit
{
    //other members...
    public abstract void Initialise();
}

public class FruitFactory()
{
    public Fruit CreateInstance()
    {
        Fruit f = //decide which fruit to create
        f.Initialise();

        return f;
    }
}