Giải pháp thay thế chính xác cho kế thừa phương thức tĩnh là gì?

Tôi hiểu rằng kế thừa phương thức tĩnh không được hỗ trợ trong C #. Tôi cũng đã đọc một số cuộc thảo luận (bao gồm cả ở đây) trong đó các nhà phát triển tuyên bố cần có chức năng này, mà câu trả lời điển hình là "nếu bạn cần kế thừa thành viên tĩnh, có một lỗ hổng trong thiết kế của bạn".

OK, cho rằng OOP không muốn tôi nghĩ về kế thừa tĩnh, tôi phải kết luận rằng nhu cầu rõ ràng của tôi đối với nó chỉ ra một lỗi trong thiết kế của tôi. Nhưng, tôi bị mắc kẹt. Tôi thực sự đánh giá cao một số trợ giúp giải quyết vấn đề này. Đây là thử thách ...

Tôi muốn tạo một lớp cơ sở trừu tượng (hãy gọi nó là Fruit) đóng gói một số mã khởi tạo phức tạp. Mã này không thể được đặt trong hàm tạo, vì một số mã sẽ dựa vào các lệnh gọi phương thức ảo.

Fruit sẽ được kế thừa bởi các lớp cụ thể khác (Apple, Orange), mỗi lớp phải hiển thị một phương thức nhà máy tiêu chuẩn CreateInstance () để tạo và khởi tạo một thể hiện.

Nếu việc kế thừa thành viên tĩnh là khả thi, tôi sẽ đặt phương thức gốc trong lớp cơ sở và sử dụng một lệnh gọi phương thức ảo đến lớp dẫn xuất để lấy kiểu mà từ đó một cá thể cụ thể phải được khởi tạo. Mã máy khách sẽ đơn giản gọi Apple.CreateInstance () để có được một phiên bản Apple được khởi tạo đầy đủ.

Nhưng rõ ràng điều này là không thể, vì vậy ai đó có thể vui lòng giải thích cách thiết kế của tôi cần thay đổi như thế nào để phù hợp với chức năng tương tự.

Một ý tưởng:

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

Và gọi như vậy:

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

Không cần các lớp học thêm tại nhà máy.

Di chuyển phương thức factory ra khỏi kiểu và đặt nó vào lớp Factory của chính nó.

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

Tuy nhiên, khi tôi đang xem xét điều này, không cần phải di chuyển phương thức Create sang lớp Factory của chính nó (mặc dù tôi nghĩ rằng nó thích hợp hơn - điều chỉnh mối quan tâm-), bạn có thể đặt nó vào lớp Fruit:

public abstract class Fruit
{

   public abstract string Define();

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

}

Và, để xem nó có hoạt động không:

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

            Console.ReadLine ();
        }        
    }

Tại sao không tạo một lớp nhà máy (mẫu) bằng phương thức create?

FruitFactory<Banana>.Create();

Tôi sẽ làm một cái gì đó như thế này

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

Các WebRequest lớp và các loại phái sinh của nó trong NET BCL đại diện cho một ví dụ tốt về cách loại thiết kế này có thể được thực hiện tương đối tốt.

Các WebRequestlớp có một số phụ lớp, bao gồm HttpWebRequestvà FtpWebReuest. Bây giờ, WebRequestlớp cơ sở này cũng là một kiểu nhà máy và hiển thị một Createphương thức tĩnh (các hàm tạo cá thể được ẩn, theo yêu cầu của mẫu nhà máy).

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

CreatePhương thức này trả về một triển khai cụ thể củaWebRequest lớp và sử dụng URI (hoặc chuỗi URI) để xác định loại đối tượng để tạo và trả về.

Điều này có kết quả cuối cùng của kiểu sử dụng sau:

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

Cá nhân tôi nghĩ rằng đây là một cách tốt để tiếp cận vấn đề và nó thực sự có vẻ là phương pháp ưa thích của những người tạo .NET Framework.

Trước hết, việc không có các trình khởi tạo tĩnh có thể là ảo không có nghĩa là bạn không thể có các phương thức thành viên "chuẩn", điều đó có thể bị quá tải. Trước hết, bạn có thể gọi các phương thức ảo của mình từ các hàm tạo và chúng sẽ hoạt động như mong đợi, vì vậy không có vấn đề gì ở đây. Thứ ba, bạn có thể sử dụng generic để có nhà máy an toàn về loại.
Đây là một số đoạn mã sử dụng phương thức factory + member Initialize () được gọi bởi hàm tạo (và nó được bảo vệ, vì vậy bạn không cần phải lo lắng rằng ai đó sẽ gọi lại nó sau khi tạo một đối tượng):

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

Tôi muốn nói điều tốt nhất nên làm là tạo một phương thức Initialise ảo / trừu tượng trên lớp fruit mà phải được gọi và sau đó tạo một lớp 'fruit factory' bên ngoài để tạo các thể hiện:

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