[C#] - Problema su costruttore statico e Inheritance

[gugoXX]

Innanzitutto scusate la lunghezza. Se qualcuno avesse voglia di leggere e magari di aiutarmi gli sarei grato.

Mi sono incastrato in una questione "sottile", non riesco a capire se sono di fronte ad un comportamento anomalo del C# oppure se piu' semplicemente mi sfugge qualcosa.
Premetto che oramai ho risolto il problema "pulendo" e rifattorizzando un paio' di classi che volevano essere Singletone ma non erano state create come si deve.
Vorrei pero' cercare di fare chiarezza su questo punto, se qualcuno gia' lo sa oppure se riusciamo a capirlo insieme.

Da manuale C#, quando si crea un oggetto di una qualsiasi classe A, se non dimentico qualcosa vengono compiuti i seguenti passi, in questo ordine:
- Vengono creati i campi (le variabili) statici di classe, se nessun altra istanza della classe A e' stata precedentemente creata nel processo.
- Viene chiamato il costruttore statico della classe A, se nessun altra istanza della classe A e' stata precedentemente creata nel processo.
- Vengono creati (e valorizzati) i campi non statici di classe A relativi all'oggetto che si sta costruendo
- Viene chiamato il costruttore normale della classe A.

Se invece ci si limita a chiamare un metodo statico della classe A, oppure anche solo a referenziare un campo statico della classe A, allora se non sbaglio vengono compiuti i seguenti passi, in questo ordine:
- Vengono creati i campi (le variabili) statici di classe, se nessun altra istanza della classe A e' stata precedentemente create nel processo.
- Viene chiamato il costruttore statico della classe A, se nessuna altra istanza della classe A e' stata precedentemente creata nel processo.


In pratica un subset del precedente.
Il problema sorge proprio in un caso come questi, ovvero quando sto chiamando un metodo statico di una classe, in una condizione un po' particolare.

Se io ho il seguente codice:

        public class padre
        {
            public static string StaticoPadreEseguito = "Ancora no";            
            static padre()
            {
                StaticoPadreEseguito = "Statico padre eseguito";
            }

            public padre()
            {
                //Costruttore normale che non fa nulla.
            }

            public static string Funzione()
            {
                //Funzione che non fa nulla.
                return string.Empty;
            }
        }

        static void Main(string[] args)
        {
            padre.Funzione();
            Console.WriteLine(padre.StaticoPadreEseguito);
            Console.ReadKey();
        }

Ovvero una classe che ha una variabile statica inizializzata con un valore, un costruttore statico che lo sovrascrive e una funzione statica inutile,
quando lo lancio mi scrive correttamente "Statico Padre Eseguito".
Ha eseguito i passi che mi aspetto:
- Ho chiamato una funzione statica della classe
- Poche' era la prima volta che referenziavo qualcunque cosa della classe, e' stato creato e valorizzato il campo statico StaticoPadreEseguito.
- E' stato chiamato il costruttore statico della classe, che ha cambiato il valore di questo campo statico
- Ho stampato il contenuto di questo campo, che correttamente ha stampato il risultato atteso.

Se pero' estendo il tutto come segue:

        public class padre
        {
            public static string StaticoPadreEseguito = "Ancora no";
            public static string MagariQualcunoLoUsa = "Ancora no";
            static padre()
            {
                StaticoPadreEseguito = "Statico padre eseguito";
            }

            public padre()
            {
                //Costruttore normale che non fa nulla.
            }

            public static string Funzione()
            {
                //Funzione che non fa nulla.
                return string.Empty;
            }
        }        

        public class figlio : padre
        {
            static figlio()
            {
                MagariQualcunoLoUsa = "Si', lo uso io";
            }

            public figlio()
            {
                //Costruttore normale che non fa nulla.
            }
        }

        static void Main(string[] args)
        {
            figlio.Funzione();
            Console.WriteLine(figlio.MagariQualcunoLoUsa);
            Console.ReadKey();
        }

Ora c'e' una classe figlio, derivata da padre, con un suo costruttore statico.
La classe ha quindi anche ereditato le variabili statiche del padre, ed anche la funzione statica del padre.
Nel codice io richiamo la funzione statica del padre, ma sulla classe figlio.
Il costruttore statico del figlio dovrebbe andare a valorizzare una delle variabili statiche ereditate dal padre. Il programma, similmente a prima, dovrebbe stampare il contenuto di questa variabile.
Ora, premettendo che non ci sono errori o warning di compilazione, come mai l'output di questo codice e' "Ancora no" invece che "Lo uso io"?
Ovvero, come mai non mi e' stato chiamato il costruttore statico della classe figlio, sebbene io abbia chiamato una funzione statica di tale classe (anche se derivata)?
Penso che la risposta sia proprio in questo (anche se derivata), ma non mi spiego il perche'. E' per caso una dimenticanza del compilatore oppure c'e' una ragione esplicita per questo comportamento?

[^TiGeRShArK^]

sulla fiducia...
considerando che mi sono fermato a leggere a metà post e che ho un tasso alcoolico tale che se mi avessero fermato alla guida avrei + anni da scontare di totò riina, direi SI!
..se vuoi una risposta + seria dammi il tempo di riprendermi e magari domani dirò qulcosa di + sensato..

[kernel::panic]

E' corretto che sia così.

Quando derivi da una classe in realtà le variabili statiche non vengono ereditate; la variabile figlio::MagariQualcunoLoUsa in pratica punta alla stessa area di memoria di padre::MagariQualcunoLoUsa (infatti se ne modifichi il valore nella classe figlio cambia il valore anche nella classe padre e viceversa). Le varibili non statiche (public e protected) invece nella classe figlio non hanno alcun legame (di "puntamento") con quelle della classe padre.

Come giustamente dicevi, il costruttore statico viene chiamato non appena si cerca di accedere al valore di una variabile, quindi quando accedi a figlio::MagariQualcunoLoUsa è come se accedessi a padre::MagariQualcunoLoUsa e quindi viene chiamato il costruttore statico del padre.

Ciao

[gugoXX]

Ho capito perche' si comporta cosi'.
Non ne ho capito il motivo pero'.

In pratica e' come se io avessi chiamato Padre.Funzione();
Ma mi chiedo perche' di questo comportamento.
Si sarebbe arrabbiato qualcuno se il compilatore avesse chiamato il costruttore statico del padre e poi anche quello del figlio?
Si sarebbe rotto qualcosa del paradigma di incapsulamento degli oggetti?
A me sarebbe sembrato piu' logico se li avesse chiamati entrambi, dato che ho esplicitamente chiesto
Figlio.Funzione();
e non
Padre.Funzione();

[kernel::panic]

Ti do ragione, sarebbe stato più logico se il compilatore avesse chiamato entrambi i costruttori, se non altro per coerenza con quanto succede con i costruttori non statici:

public class padre
{
    public padre()
    {
        Console.WriteLine("padre");
    }
    public void Funz()
    { }
}

public class figlio : padre
{
    public figlio()
    {
        Console.WriteLine("figlio");
    }
}

static void Main()
{
    new figlio().Funz();
    Console.ReadKey();
}

Ho dato una veloce occhiata su internet per capire se c'è una motivazione a ciò ma non ho trovato nulla. L'unica cosa che ho scoperto è che il compilatore quando trova la chiamata "figlio.Funzione()" la sostituisce con "padre.Funzione()" (in quanto statica e non ridefinita in figlio), perdendo i legami con figlio.

Ma del *perchè* fa ciò nessuna info!

Per fare funzionare il costruttore statico di figlio si deve ridefinire esplicitamente la funzione:

figlio
{
....
    public static new string Funzione()
    {
        //Funzione che non fa nulla.
        return padre.Funzione();
    }
}

[gugoXX]

Ti ringrazio per il tempo dedicato al problema.
Ti assicuro che non e' assolutamente stato vano perche' sinceramente a me ora non importa piu' che sia una dimenticanza o un effetto collaterale delle "semplificazioni" del compilatore.
Quello che conta e' che hai trovato un modo per "forzare" il compilatore ad agire come speravo, con la redifinzione della funzione mediante il new.
In questo modo innanzitutto non sono costretto a duplicare il codice sulla classe figlio, e se mai dovessi trovarmi di nuovo davanti ad un probelma simile sapro' far muovere tutto come avevo pensato.
Non avevo mai pensato a ridefinire una funzione statica su una classe figlio con l'operatore new, non capita tutti i giorni...

Grazie ancora.

[kernel::panic]

Originariamente inviato da gugoXX

Ti ringrazio per il tempo dedicato al problema.

E' stato un piacere... ho imparato qualcosa di nuovo anch'io