What's the correct alternative to static method inheritance?

Question

I understand that static method inheritance is not supported in C#. I have also read a number of discussions (including here) in which developers claim a need for this functionality, to which the typical response is "if you need static member inheritance, there's a flaw in your design".

OK, given that OOP doesn't want me to even think about static inheritance, I must conclude that my apparent need for it points to an error in my design. But, I'm stuck. I would really appreciate some help resolving this. Here's the challenge ...

I want to create an abstract base class (let's call it a Fruit) that encapsulates some complex initialization code. This code cannot be placed in the constructor, since some of it will rely on virtual method calls.

Fruit will be inherited by other concrete classes (Apple, Orange), each of which must expose a standard factory method CreateInstance() to create and initialize an instance.

If static member inheritance were feasible, I would place the factory method in the base class and use a virtual method call to the derived class to obtain the type from which a concrete instance must be initialized. The client code would simple invoke Apple.CreateInstance() to obtain a fully initialized Apple instance.

But clearly this is not possible, so can someone please explain how my design needs to change to accommodate the same functionality.

Answer 1

One idea:

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

And call like so:

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

No extra factory classes needed.

Answer 2

Move the factory method out of the type, and put it in its own Factory class.

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

But, as I'm looking at this, there is no need to move the Create method to its own Factory class (although I think that it is preferrable -separation of concerns-), you can put it in the Fruit class:

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

And, to see if it works:

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