Existe-t-il un moyen de forcer l'initialisation des champs statiques en C#?

Question

Consultez le code suivant:

class Program 
{ 
    static Program() { 
     Program.program1.Value = 5; 
    } 

    static List<Program> values = new List<Program>(); 
    int value; 
    int Value 
    { 
     get { return value; } 
     set { 
      this.value = value; 
      Program.values.Add(this); 
     } 
    } 

    static Program program1 = new Program { value = 1 }; 
    static Program program2 = new Program { value = 2 }; 
    static Program program3 = new Program { value = 3 }; 

    static void Main(string[] args) 
    { 
     if (Program.values.Count == 0) Console.WriteLine("Empty"); 
     foreach (var value in Program.values) 
      Console.WriteLine(value.Value); 
     Console.ReadKey(); 
    } 
} 

Il imprime seulement le numéro 5, et si supprimé le code dans le constructeur statique, il imprime « vide ».

Existe-t-il un moyen de forcer l'initialisation des champs statiques même s'ils ne sont pas encore utilisés?

J'ai besoin d'une propriété statique nommée Valeurs avec toutes les occurrences du type référencé.

J'ai essayé quelques variantes de ce code et certaines fonctionnent pour certains types mais pas pour d'autres.

EDIT: L'EXEMPLE CI-DESSUS BROKEN, FAITES L'ESSAI UN:

class Subclass<T> { 
    static Subclass() 
    { 
     Values = new List<Subclass<T>>(); 
    } 
    public Subclass() 
    { 
     if (!Values.Any(i => i.Value.Equals(this.Value))) 
     { 
      Values.Add(this); 
     } 
    } 

    public T Value { get; set; } 

    public static List<Subclass<T>> Values { get; private set; } 
} 

class Superclass : Subclass<int> 
{ 
    public static Superclass SuperclassA1 = new Superclass { Value = 1 }; 
    public static Superclass SuperclassA2 = new Superclass { Value = 2 }; 
    public static Superclass SuperclassA3 = new Superclass { Value = 3 }; 
    public static Superclass SuperclassA4 = new Superclass { Value = 4 }; 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     //Console.WriteLine(Superclass.SuperclassA1); //UNCOMMENT THIS LINE AND IT WORKS 
     foreach (var value in Superclass.Values) 
     { 
      Console.WriteLine(value.Value); 
     } 
     Console.ReadKey(); 
    } 
} 

Answer 1

La réponse à votre question est 'bien, oui'. Mais l'une des deux façons de "forcer" c'est ce que vous faites déjà.

La section pertinente dans la spécification du langage est 10.11 Static constructors, et plus précisément:

« Le constructeur statique pour une classe exécute au plus une fois dans un domaine d'application donné L'exécution d'un constructeur statique est déclenchée par la première. les événements suivants se produisent dans un domaine d'application:..

• une instance de la classe est créée
• Tous les membres statiques de la classe sont référencés

Si une classe contient la méthode Main (Section 3.1) dans laquelle l'exécution commence, le constructeur statique de cette classe s'exécute avant que la méthode Main ne soit appelée. Si une classe contient des champs statiques avec initializers, les initialiseurs sont exécutées dans l'ordre textuel immédiatement avant l'exécution du constructeur statique. »

Answer 2

ressemble en fait vous 'valeur' ​​mal orthographié -> 'Valeur' ​​ Ainsi:

static Program program1 = new Program { Value = 1 }; 
    static Program program2 = new Program { Value = 2 }; 
    static Program program3 = new Program { Value = 3 }; 

jolies imprime plus de lignes

Answer 3

Mais vous ne définissez jamais la propriété - au lieu de cela, vous définissez le champ de sauvegarde directement, ne passant pas par votre logique pour l'ajouter à la liste statique lors de la création de programme1, p rogram2 et program3.

dire que vous devez changer:

static Program program1 = new Program { value = 1 }; 
    static Program program2 = new Program { value = 2 }; 
    static Program program3 = new Program { value = 3 }; 

à:

static Program program1 = new Program { Value = 1 }; 
    static Program program2 = new Program { Value = 2 }; 
    static Program program3 = new Program { Value = 3 }; 

Answer 4

Le second échantillon ne fonctionne pas simplement parce que Value est membre statique de Subclass.

La syntaxe C# permet Superclass.Values, mais éventuellement l'appel de la méthode compilée sera au getter Subclass.Values, donc le type Superclass n'est jamais réellement touché, Superclass.SuperclassA1 d'autre part touche le type et déclenche l'initialisation statique.C'est pourquoi C# n'a pas vraiment d'initialisation statique implicite et vous avez besoin de frameworks de composition comme MEF et Unity.

Answer 5

Il existe en fait un moyen de forcer l'initialisation des propriétés dans ce cas. La modification nécessite l'ajout d'un paramètre de type à la classe de base pour représenter la future sous-classe de la classe de base qui contiendra les champs à initialiser. Ensuite, nous pouvons utiliser RuntimeHelpers.RunClassConstructor pour nous assurer que les champs statiques de sous-classe sont initialisés.

Ce qui suit donne les résultats que vous recherchez:

class Subclass<TSubclass, T> 
{ 
    static Subclass() 
    { 
     Values = new List<Subclass<TSubclass, T>>(); 
     // This line is where the magic happens 
     System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(TSubclass).TypeHandle); 
    } 
    public Subclass() 
    { 
     if (!Values.Any(i => i.Value.Equals(this.Value))) 
     { 
      Values.Add(this); 
     } 
    } 

    public T Value { get; set; } 

    public static List<Subclass<TSubclass, T>> Values { get; private set; } 
} 

class Superclass : Subclass<Superclass, int> 
{ 
    public static Superclass SuperclassA1 = new Superclass { Value = 1 }; 
    public static Superclass SuperclassA2 = new Superclass { Value = 2 }; 
    public static Superclass SuperclassA3 = new Superclass { Value = 3 }; 
    public static Superclass SuperclassA4 = new Superclass { Value = 4 }; 
} 

public class Program 
{ 
    public static void Main() 
    { 
     foreach (var value in Superclass.Values) 
     { 
      Console.WriteLine(value.Value); 
     } 
     Console.ReadKey(); 
    } 
} 

Ce qui se passe est, l'appel à RuntimeHelpers.RunClassConstructor(typeof(TSubclass).TypeHandle) force le constructeur statique de TSubclass pour exécuter si elle n'a pas déjà exécuté. Cela garantit que les champs statiques ont initialisé d'abord comme par cette ligne de https://msdn.microsoft.com/en-us/library/aa645612(VS.71).aspx:

Si une classe contient des champs statiques avec initializers, les initialiseurs sont exécutées dans l'ordre textuel immédiatement avant l'exécution du constructeur statique.

Voici une démonstration dotnetfiddle fonctionner:

https://dotnetfiddle.net/MfXzFd