Tại sao tôi không thể có các phương thức tĩnh trừu tượng trong C #?

Gần đây tôi đã làm việc với các nhà cung cấp một cách công bằng và tôi đã gặp một tình huống thú vị khi tôi muốn có một lớp trừu tượng có một phương thức tĩnh trừu tượng. Tôi đọc một vài bài viết về chủ đề này, và nó có ý nghĩa, nhưng có một lời giải thích rõ ràng tốt đẹp?

Các phương thức tĩnh không được khởi tạo như vậy, chúng chỉ khả dụng mà không cần tham chiếu đối tượng.

Một cuộc gọi đến một phương thức tĩnh được thực hiện thông qua tên lớp, không phải thông qua một tham chiếu đối tượng và mã Ngôn ngữ trung gian (IL) để gọi nó sẽ gọi phương thức trừu tượng thông qua tên của lớp đã định nghĩa nó, không nhất thiết phải là tên của lớp bạn đã sử dụng.

Hãy để tôi chỉ ra một ví dụ.

Với đoạn mã sau:

public class A
{
    public static void Test()
    {
    }
}

public class B : A
{
}

Nếu bạn gọi B.Test, như thế này:

class Program
{
    static void Main(string[] args)
    {
        B.Test();
    }
}

Sau đó, mã thực tế bên trong phương thức Main như sau:

.entrypoint
.maxstack 8
L0000: nop 
L0001: call void ConsoleApplication1.A::Test()
L0006: nop 
L0007: ret 

Như bạn có thể thấy, cuộc gọi được thực hiện cho A.Test, vì đó là lớp A đã định nghĩa nó chứ không phải B.Test, mặc dù bạn có thể viết mã theo cách đó.

Nếu bạn có các loại lớp , như trong Delphi, nơi bạn có thể tạo một biến tham chiếu đến một loại chứ không phải một đối tượng, bạn sẽ sử dụng nhiều hơn cho các phương thức tĩnh ảo và do đó trừu tượng (và cả các hàm tạo), nhưng chúng không có sẵn và do đó, các cuộc gọi tĩnh là không ảo trong .NET.

Tôi nhận ra rằng các nhà thiết kế IL có thể cho phép mã được biên dịch để gọi B.Test và giải quyết cuộc gọi khi chạy, nhưng nó vẫn không phải là ảo, vì bạn vẫn sẽ phải viết một loại tên lớp ở đó.

Các phương thức ảo, và do đó là các phương thức trừu tượng, chỉ hữu ích khi bạn đang sử dụng một biến, trong thời gian chạy, có thể chứa nhiều loại đối tượng khác nhau và do đó bạn muốn gọi đúng phương thức cho đối tượng hiện tại mà bạn có trong biến. Với các phương thức tĩnh, dù sao bạn cũng cần phải đi qua một tên lớp, vì vậy phương thức chính xác để gọi được biết đến vào thời gian biên dịch vì nó không thể và sẽ không thay đổi.

Vì vậy, các phương thức tĩnh ảo / trừu tượng không có sẵn trong .NET.

Các phương thức tĩnh không thể được kế thừa hoặc ghi đè và đó là lý do tại sao chúng không thể trừu tượng. Vì các phương thức tĩnh được định nghĩa trên kiểu chứ không phải thể hiện của một lớp, nên chúng phải được gọi rõ ràng trên kiểu đó. Vì vậy, khi bạn muốn gọi một phương thức trên một lớp con, bạn cần sử dụng tên của nó để gọi nó. Điều này làm cho sự kế thừa không liên quan.

Giả sử bạn có thể, trong một khoảnh khắc, kế thừa các phương thức tĩnh. Hãy tưởng tượng kịch bản này:

public static class Base
{
    public static virtual int GetNumber() { return 5; }
}

public static class Child1 : Base
{
    public static override int GetNumber() { return 1; }
}

public static class Child2 : Base
{
    public static override int GetNumber() { return 2; }
}

Nếu bạn gọi Base.GetNumber (), phương thức nào sẽ được gọi? Giá trị nào được trả về? Nó khá dễ dàng để thấy rằng không tạo ra các thể hiện của các đối tượng, kế thừa là khá khó khăn. Các phương thức trừu tượng không có sự kế thừa chỉ là các phương thức không có cơ thể, vì vậy không thể được gọi.

Một người trả lời khác (McDowell) nói rằng đa hình chỉ hoạt động cho các trường hợp đối tượng. Điều đó cần phải có trình độ; có những ngôn ngữ coi các lớp là thể hiện của loại "Lớp" hoặc "Siêu dữ liệu". Các ngôn ngữ này hỗ trợ đa hình cho cả hai phương thức thể hiện và lớp (tĩnh).

C #, giống như Java và C ++ trước đó, không phải là một ngôn ngữ như vậy; các statictừ khóa được sử dụng một cách rõ ràng để biểu thị rằng phương pháp này là tĩnh-bound chứ không phải năng động / ảo.

Đây là một tình huống chắc chắn cần có sự kế thừa cho các trường và phương thức tĩnh:

abstract class Animal
{
  protected static string[] legs;

  static Animal() {
    legs=new string[0];
  }

  public static void printLegs()
  {
    foreach (string leg in legs) {
      print(leg);
    }
  }
}


class Human: Animal
{
  static Human() {
    legs=new string[] {"left leg", "right leg"};
  }
}


class Dog: Animal
{
  static Dog() {
    legs=new string[] {"left foreleg", "right foreleg", "left hindleg", "right hindleg"};
  }
}


public static void main() {
  Dog.printLegs();
  Human.printLegs();
}


//what is the output?
//does each subclass get its own copy of the array "legs"?

Để thêm vào các giải thích trước đó, các cuộc gọi phương thức tĩnh được liên kết với một phương thức cụ thể tại thời gian biên dịch , thay vào đó loại trừ hành vi đa hình.

Chúng tôi thực sự ghi đè các phương thức tĩnh (trong delphi), nó hơi xấu, nhưng nó hoạt động tốt cho nhu cầu của chúng tôi.

Chúng tôi sử dụng nó để các lớp có thể có một danh sách các đối tượng có sẵn của chúng mà không cần thể hiện của lớp, ví dụ, chúng tôi có một phương thức giống như sau:

class function AvailableObjects: string; override;
begin
  Result := 'Object1, Object2';
end; 

Thật xấu xí nhưng cần thiết, theo cách này chúng ta có thể khởi tạo ngay những gì cần thiết, thay vì tất cả các lớp được tạo ngay lập tức chỉ để tìm kiếm các đối tượng có sẵn.

Đây là một ví dụ đơn giản, nhưng bản thân ứng dụng là một ứng dụng máy chủ-máy khách có tất cả các lớp có sẵn trong một máy chủ và nhiều máy khách khác nhau có thể không cần mọi thứ mà máy chủ có và sẽ không bao giờ cần đối tượng.

Vì vậy, điều này dễ bảo trì hơn nhiều so với việc có một ứng dụng máy chủ khác nhau cho mỗi khách hàng.

Hy vọng ví dụ đã rõ ràng.

Các phương thức trừu tượng là ngầm ảo. Các phương thức trừu tượng yêu cầu một thể hiện, nhưng các phương thức tĩnh không có một thể hiện. Vì vậy, bạn có thể có một phương thức tĩnh trong một lớp trừu tượng, nó chỉ không thể là trừu tượng tĩnh (hoặc trừu tượng tĩnh).