Perché non posso avere metodi statici astratti in C #?

Ultimamente ho lavorato con i fornitori e mi sono imbattuto in una situazione interessante in cui volevo avere una classe astratta con un metodo statico astratto. Ho letto alcuni post sull'argomento, e in un certo senso aveva senso, ma c'è una bella spiegazione chiara?

I metodi statici non sono istanziati in quanto tali, sono disponibili solo senza un riferimento all'oggetto.

Una chiamata a un metodo statico viene effettuata tramite il nome della classe, non tramite un riferimento a un oggetto, e il codice IL (Intermediate Language) per chiamarlo chiamerà il metodo astratto attraverso il nome della classe che lo ha definito, non necessariamente il nome di la classe che hai usato.

Lasciami mostrare un esempio.

Con il seguente codice:

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

public class B : A
{
}

Se chiami B.Test, in questo modo:

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

Quindi il codice effettivo all'interno del metodo Main è il seguente:

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

Come puoi vedere, la chiamata viene effettuata su A.Test, perché è stata la classe A a definirla, e non su B.Test, anche se puoi scrivere il codice in quel modo.

Se avessi tipi di classe , come in Delphi, in cui puoi creare una variabile riferendosi a un tipo e non a un oggetto, avresti più uso di metodi statici virtuali e quindi astratti (e anche di costruttori), ma non sono disponibili e pertanto le chiamate statiche non sono virtuali in .NET.

Mi rendo conto che i progettisti di IL potrebbero consentire la compilazione del codice per chiamare B.Test e risolvere la chiamata in fase di esecuzione, ma non sarebbe comunque virtuale, poiché dovresti comunque scrivere un qualche tipo di nome di classe lì.

I metodi virtuali, e quindi quelli astratti, sono utili solo quando si utilizza una variabile che, in fase di esecuzione, può contenere molti tipi diversi di oggetti, e quindi si desidera chiamare il metodo giusto per l'oggetto corrente che si ha nella variabile. Con i metodi statici devi comunque passare attraverso un nome di classe, quindi il metodo esatto da chiamare è noto al momento della compilazione perché non può e non cambierà.

Pertanto, i metodi statici virtuali / astratti non sono disponibili in .NET.

I metodi statici non possono essere ereditati o ignorati ed è per questo che non possono essere astratti. Poiché i metodi statici sono definiti sul tipo, non sull'istanza, di una classe, devono essere chiamati esplicitamente su quel tipo. Pertanto, quando si desidera chiamare un metodo su una classe figlio, è necessario utilizzare il suo nome per chiamarlo. Ciò rende l'eredità irrilevante.

Supponiamo che potresti, per un momento, ereditare metodi statici. Immagina questo scenario:

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

Se chiami Base.GetNumber (), quale metodo verrebbe chiamato? Quale valore restituito? È abbastanza facile vedere che senza creare istanze di oggetti, l'eredità è piuttosto difficile. I metodi astratti senza ereditarietà sono solo metodi che non hanno un corpo, quindi non possono essere chiamati.

Un altro intervistato (McDowell) ha affermato che il polimorfismo funziona solo per istanze di oggetti. Questo dovrebbe essere qualificato; ci sono lingue che trattano le classi come istanze di un tipo "Class" o "Metaclass". Questi linguaggi supportano il polimorfismo sia per i metodi di istanza che per quelli di classe (statici).

C #, come Java e C ++ prima, non è un tale linguaggio; la staticparola chiave viene utilizzata esplicitamente per indicare che il metodo è associato staticamente anziché dinamico / virtuale.

Ecco una situazione in cui c'è sicuramente bisogno di ereditarietà per campi e metodi statici:

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

Per aggiungere alle spiegazioni precedenti, le chiamate al metodo statico sono legate a un metodo specifico in fase di compilazione , il che esclude piuttosto il comportamento polimorfico.

In realtà sovrascriviamo i metodi statici (in delphi), è un po 'brutto, ma funziona bene per le nostre esigenze.

Lo usiamo in modo che le classi possano avere un elenco dei loro oggetti disponibili senza l'istanza della classe, ad esempio, abbiamo un metodo che assomiglia a questo:

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

È brutto ma necessario, in questo modo possiamo creare un'istanza di ciò che è necessario, invece di avere tutte le classi istanziate solo per cercare gli oggetti disponibili.

Questo è stato un semplice esempio, ma l'applicazione stessa è un'applicazione client-server che ha tutte le classi disponibili in un solo server e più client diversi che potrebbero non aver bisogno di tutto ciò che il server ha e non avranno mai bisogno di un'istanza di oggetto.

Quindi è molto più facile da gestire rispetto ad avere un'applicazione server diversa per ogni client.

Spero che l'esempio sia stato chiaro.

I metodi astratti sono implicitamente virtuali. I metodi astratti richiedono un'istanza, ma i metodi statici non hanno un'istanza. Quindi, puoi avere un metodo statico in una classe astratta, semplicemente non può essere astratto statico (o statico astratto).