Jaka jest poprawna alternatywa dla dziedziczenia metod statycznych?

Question

Rozumiem, że dziedziczenie metod statycznych nie jest obsługiwane w języku C#. Przeczytałem również wiele dyskusji (w tym tutaj), w których deweloperzy twierdzą, że istnieje taka potrzeba, na co typowa odpowiedź brzmi "jeśli potrzebujesz statycznego dziedziczenia członków, jest wada w twoim projekcie".

OK, biorąc pod uwagę, że OOP nie chce, żebym nawet myślał o dziedziczeniu statycznym, muszę stwierdzić, że moja widoczna potrzeba wskazuje na błąd w moim projekcie. Ale utknąłem. Byłbym wdzięczny za pomoc w rozwiązaniu tego problemu. Oto wyzwanie ...

Chcę utworzyć abstrakcyjną klasę bazową (nazwijmy ją Owocem), która zawiera pewien złożony kod inicjalizacyjny. Tego kodu nie można umieścić w konstruktorze, ponieważ niektóre z nich będą opierać się na wywołaniach metod wirtualnych.

Owoce zostaną odziedziczone przez inne konkretne klasy (Apple, Orange), z których każda musi narazić standardową metodę fabryki CreateInstance(), aby utworzyć i zainicjować instancję.

Jeśli możliwe jest dziedziczenie statycznych elementów, umieściłbym metodę fabryczną w klasie bazowej i użyłbym wywołania metody wirtualnej do klasy pochodnej, aby uzyskać typ, z którego konkretna instancja musi zostać zainicjalizowana. Kod klienta mógłby łatwo wywołać funkcję Apple.CreateInstance() w celu uzyskania w pełni zainicjowanej instancji Apple.

Ale to nie jest możliwe, więc proszę, proszę, proszę wyjaśnić, w jaki sposób mój projekt musi się zmienić, aby dostosować tę samą funkcjonalność.

Answer 1

Jeden pomysł:

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() { ... } 
} 

I nazwać tak:

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

Bez dodatkowych klas fabrycznych potrzebne.

Answer 2

Powiedziałbym, że najlepszym rozwiązaniem jest stworzenie wirtualnego/abstrakcyjne metody inicjalizacji na klasy owoców, które muszą być o nazwie a następnie utworzyć klasę zewnętrznego „fabrycznego owoc”, aby utworzyć instancje:

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

Answer 3

Dlaczego nie utworzyć klasy fabrycznej (szablonowej) za pomocą metody create?

Answer 4

Przenieś metodę fabryczną z typu i umieść ją w swojej własnej klasie Factory.

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

Ale jak patrzę na to, nie ma potrzeby, aby przejść do metody Create własnej klasy Factory (chociaż myślę, że jest preferrable -separation z concerns-), można go umieścić w klasie Owoce:

public abstract class Fruit 
{ 

    public abstract string Define(); 

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

} 

A, aby sprawdzić, czy to działa:

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

      Console.ReadLine(); 
     }   
    } 

Answer 5

chciałbym zrobić coś takiego

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

Answer 6

Klasa WebRequest i jej typy pochodne w .NET BCL stanowią dobry przykład tego, jak ten rodzaj projektu można wdrożyć stosunkowo dobrze.

Klasa WebRequest ma kilka podklas, w tym HttpWebRequest i FtpWebReuest. Teraz ta klasa bazowa WebRequest jest także typu fabrycznego i poddaje statycznej metodzie Create (konstruktory instancji są ukryte, zgodnie z wymaganiami fabrycznego wzorca).

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

Ta metoda Create zwraca konkretną implementację klasy WebRequest i wykorzystuje URI (lub URI string), aby określić rodzaj obiektu, aby utworzyć i powrotu.

Ma to końcowy wynik poniższego wzoru Zastosowanie:

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/"); 

Osobiście uważam, że jest to dobry sposób, aby zbliżyć się do problemu, i to rzeczywiście wydaje się być Preferowany sposób Framework twórcy.

Answer 7

Po pierwsze, brak inicjalizacji statycznych, które mogą być wirtualne, nie oznacza, że ​​nie można stosować "standardowych" metod, które mogą być przeciążone. Po drugie, możesz wywoływać swoje wirtualne metody od konstruktorów i będą działać zgodnie z oczekiwaniami, więc nie ma problemu. Po trzecie, możesz używać generycznych, by mieć fabrykę bezpieczną dla typu.
Oto kod, który używa metody Initialize() z fabryki, która jest wywoływana przez konstruktor (i jest chroniona, więc nie musisz się martwić, że ktoś wywoła ją ponownie po utworzeniu obiektu):

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