Чому я не можу використовувати абстрактні статичні методи в C #?

Я працював із Останнім часом провайдерами досить небагато, і мені трапилось цікаве становище, коли я хотів мати абстрактний клас, який мав абстрактний статичний метод. Я прочитав кілька публікацій на цю тему, і це мало сенс, але чи є приємне чітке пояснення?

Статичні методи не інстанціювати як такі, вони просто доступні без посилання на об'єкт.

Виклик статичного методу здійснюється через ім'я класу, а не через посилання на об'єкт, і код проміжного мови (IL) для його виклику буде викликати абстрактний метод через ім'я класу, який його визначив, не обов'язково ім'я клас, який ви використовували.

Дозвольте показати приклад.

З наступним кодом:

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

public class B : A
{
}

Якщо ви телефонуєте B.Test, ось так:

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

Тоді власне код всередині методу Main полягає в наступному:

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

Як бачимо, виклик робиться до A.Test, тому що саме клас A визначав його, а не B.Test, хоча ви можете таким чином написати код.

Якби у вас були типи класів , як, наприклад, у Delphi, де ви можете зробити змінну, що посилається на тип, а не на об'єкт, ви мали би більше використання для віртуальних і, таким чином, абстрактних статичних методів (а також конструкторів), але вони недоступні і таким чином статичні виклики є невіртуальними в .NET.

Я усвідомлюю, що IL-дизайнери могли дозволити компілювати код для виклику B.Test і вирішити виклик під час виконання, але він все одно не був би віртуальним, оскільки вам все одно доведеться записати там якесь ім’я класу.

Віртуальні методи, а отже, абстрактні, корисні лише тоді, коли ви використовуєте змінну, яка під час виконання може містити багато різних типів об'єктів, і ви, таким чином, хочете викликати правильний метод для поточного об'єкта, який ви маєте в змінній. За допомогою статичних методів вам все одно потрібно пройти ім’я класу, тому точний метод виклику відомий під час компіляції, оскільки він не може і не зміниться.

Таким чином, віртуальні / абстрактні статичні методи недоступні у .NET.

Статичні методи не можуть бути успадковані або відмінені, і тому вони не можуть бути абстрактними. Оскільки статичні методи визначені для типу, а не екземпляра класу, їх потрібно чітко викликати для цього типу. Отже, коли ви хочете викликати метод у дочірньому класі, для його виклику потрібно використовувати його ім’я. Це робить спадщину не важливою.

Припустимо, ви могли на мить успадкувати статичні методи. Уявіть собі такий сценарій:

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

Якщо ви зателефонуєте на Base.GetNumber (), який би метод називався? Яке значення повернулося? Це досить легко помітити, що без створення екземплярів об'єктів успадкування досить важко. Абстрактні методи без успадкування - це лише методи, які не мають тіла, тому їх не можна назвати.

Інший респондент (МакДауелл) сказав, що поліморфізм працює лише для предметів. Це слід кваліфікувати; Є мови, які розглядають класи як екземпляри типу "Class" або "Metaclass". Ці мови підтримують поліморфізм як для екземплярних, так і класових (статичних) методів.

C #, як і Java та C ++ перед цим, не є такою мовою; staticключове слово використовується для позначення явно , що метод статичний палітуркою , а не динамічний / віртуальний.

Ось ситуація, коли безумовно необхідність успадкування статичних полів та методів:

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"?

Щоб додати до попередніх пояснень, статичні виклики методів прив'язуються до конкретного методу під час компіляції , який, швидше, виключає поліморфну ​​поведінку.

Ми фактично перекриваємо статичні методи (у delphi), це трохи некрасиво, але це працює чудово для наших потреб.

Ми використовуємо це, щоб класи могли мати список доступних об'єктів без екземпляра класу, наприклад, у нас є метод, який виглядає приблизно так:

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

Це некрасиво, але необхідно, таким чином ми можемо інстанціювати лише те, що потрібно, замість того, щоб усі класи були миттєвими лише для пошуку доступних об'єктів.

Це був простий приклад, але сама програма є клієнтсько-серверним додатком, у якому є всі класи, доступні лише на одному сервері, і багато різних клієнтів, яким може не знадобитися все, що має сервер, і ніколи не знадобиться об’єкт об'єкта.

Тож це набагато простіше в обслуговуванні, ніж наявність одного серверного додатку для кожного клієнта.

Сподіваюся, що приклад був зрозумілий.

Абстрактні методи неявно віртуальні. Абстрактні методи вимагають екземпляра, але статичні методи не мають примірника. Отже, ви можете мати статичний метод в абстрактному класі, він просто не може бути статичним абстрактним (або абстрактним статичним).