Dlaczego nie mogę mieć abstrakcyjnych metod statycznych w C #?

Ostatnio współpracuję z dostawcami i natknąłem się na interesującą sytuację, w której chciałem mieć klasę abstrakcyjną z abstrakcyjną metodą statyczną. Przeczytałem kilka postów na ten temat i ma to sens, ale czy istnieje jakieś przyjemne, jasne wytłumaczenie?

Metody statyczne nie są tworzone jako takie, są one po prostu dostępne bez odwołania do obiektu.

Wywołanie metody statycznej odbywa się poprzez nazwę klasy, a nie przez odwołanie do obiektu, a kod języka pośredniego (IL), aby ją wywołać, wywoła metodę abstrakcyjną poprzez nazwę klasy, która ją zdefiniowała, niekoniecznie nazwę klasa, której użyłeś.

Pokażę przykład.

Z następującym kodem:

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

public class B : A
{
}

Jeśli zadzwonisz do B.Test, wykonaj następujące czynności:

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

Zatem rzeczywisty kod w metodzie Main wygląda następująco:

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

Jak widać, wywoływane jest A.Test, ponieważ to klasa A go zdefiniowała, a nie B.Test, nawet jeśli można w ten sposób napisać kod.

Gdybyś miał typy klas , takie jak w Delphi, w których możesz utworzyć zmienną odnoszącą się do typu, a nie obiektu, miałbyś więcej zastosowania dla wirtualnych, a tym samym abstrakcyjnych metod statycznych (a także konstruktorów), ale nie są one dostępne i dlatego wywołania statyczne nie są wirtualne w .NET.

Zdaję sobie sprawę, że projektanci IL mogliby umożliwić kompilację kodu w celu wywołania B.Test i rozwiązania wywołania w czasie wykonywania, ale nadal nie byłby wirtualny, ponieważ nadal musiałbyś tam napisać jakąś nazwę klasy.

Metody wirtualne, a tym samym abstrakcyjne, są użyteczne tylko wtedy, gdy używasz zmiennej, która w czasie wykonywania może zawierać wiele różnych typów obiektów, a zatem chcesz wywołać odpowiednią metodę dla bieżącego obiektu, który masz w zmiennej. W przypadku metod statycznych i tak musisz przejść przez nazwę klasy, więc dokładna metoda do wywołania jest znana w czasie kompilacji, ponieważ nie może i nie zmieni się.

Dlatego wirtualne / abstrakcyjne metody statyczne nie są dostępne w .NET.

Metody statyczne nie mogą być dziedziczone ani zastępowane, dlatego nie mogą być abstrakcyjne. Ponieważ metody statyczne są zdefiniowane na typie, a nie na instancji klasy, muszą być jawnie wywoływane dla tego typu. Więc jeśli chcesz wywołać metodę na klasie potomnej, musisz użyć jej nazwy, aby ją wywołać. To sprawia, że ​​dziedziczenie jest nieistotne.

Załóżmy, że możesz na chwilę odziedziczyć metody statyczne. Wyobraź sobie ten scenariusz:

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

Jeśli wywołasz funkcję Base.GetNumber (), która metoda zostanie wywołana? Która wartość zwrócona? Bardzo łatwo zauważyć, że bez tworzenia instancji obiektów dziedziczenie jest raczej trudne. Metody abstrakcyjne bez dziedziczenia to tylko metody, które nie mają ciała, więc nie można ich nazwać.

Inny respondent (McDowell) powiedział, że polimorfizm działa tylko dla instancji obiektów. To powinno być kwalifikowane; istnieją języki, które traktują klasy jako instancje typu „Class” lub „Metaclass”. Te języki obsługują polimorfizm zarówno dla metod instancji, jak i klas (statycznych).

C #, podobnie jak wcześniej Java i C ++, nie jest takim językiem; staticparametr jest używany do oznaczenia wyraźnie, że metoda jest statycznie związana zamiast dynamiczny / wirtualny.

Oto sytuacja, w której zdecydowanie istnieje potrzeba dziedziczenia pól i metod statycznych:

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

Aby dodać do poprzednich wyjaśnień, statyczne wywołania metod są powiązane z określoną metodą w czasie kompilacji , co raczej wyklucza zachowanie polimorficzne.

W rzeczywistości zastępujemy metody statyczne (w delphi), jest to trochę brzydkie, ale działa dobrze dla naszych potrzeb.

Używamy go, aby klasy mogły mieć listę dostępnych obiektów bez instancji klasy, na przykład mamy metodę, która wygląda następująco:

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

Jest to brzydkie, ale konieczne, w ten sposób możemy utworzyć instancję tylko tego, co jest potrzebne, zamiast tworzenia instancji wszystkich klas tylko w celu wyszukiwania dostępnych obiektów.

To był prosty przykład, ale sama aplikacja jest aplikacją klient-serwer, która ma wszystkie klasy dostępne na jednym serwerze i wielu różnych klientów, którzy mogą nie potrzebować wszystkiego, co serwer ma i nigdy nie będzie potrzebować instancji obiektu.

Jest to o wiele łatwiejsze w utrzymaniu niż posiadanie jednej aplikacji serwera dla każdego klienta.

Mam nadzieję, że przykład był jasny.

Metody abstrakcyjne są domyślnie wirtualne. Metody abstrakcyjne wymagają wystąpienia, ale metody statyczne nie mają wystąpienia. Tak więc możesz mieć metodę statyczną w klasie abstrakcyjnej, to po prostu nie może być statyczna abstrakcja (lub abstrakcyjna statyczność).