Quelle est l'utilisation de constructeurs statiques?
S'il vous plaît expliquez-moi l'utilisation de constructeur statique. Pourquoi et quand créerions-nous un constructeur statique et est-il possible d'en surcharger un?
Non, vous ne pouvez pas le surcharger. un constructeur statique est utile pour initialiser les champs statiques associés à un type (ou toute autre opération par type) - utile en particulier pour lire les données de configuration requises dans des champs en lecture seule, etc.
Il est exécuté automatiquement par le moteur d'exécution dès la première utilisation (les règles exactes y sont compliquées (voir "beforefieldinit"), et modifié subtilement entre CLR2 et CLR4). Sauf si vous abusez de la réflexion, il est garanti qu’elle se lance au plus une fois (même si deux threads arrivent en même temps).
De Constructeurs statiques (Guide de programmation C #) :
Un constructeur statique est utilisé pour initialiser des données statiques ou pour effectuer une action particulière à exécuter une seule fois. Il est appelé automatiquement avant la création de la première instance ou la référence à des membres statiques.
Les constructeurs statiques ont les propriétés suivantes:
Un constructeur statique ne prend pas de modificateurs d'accès ou n'a pas de paramètres.
Un constructeur statique est appelé automatiquement pour initialiser la classe avant la création de la première instance ou la référence de tous les membres statiques.
Un constructeur statique ne peut pas être appelé directement.
L'utilisateur n'a aucun contrôle sur lorsque le constructeur statique est exécuté dans le programme.
Une utilisation typique des constructeurs statiques est lorsque la classe utilise un fichier journal et que le constructeur est utilisé pour écrire des entrées dans ce fichier.
Les constructeurs statiques sont également utiles lors de la création de classes wrapper pour le code non managé, lorsque le constructeur peut appeler la méthode
LoadLibrary.
Les constructeurs statiques sont également très utiles lorsque vous avez des champs statiques qui s'appuient les uns sur les autres, de sorte que l'ordre d'initialisation est important. Si vous exécutez votre code via un formateur/esthétiseur qui modifie l'ordre des champs, vous risquez de vous retrouver avec des valeurs NULL là où vous ne les attendiez pas.
Exemple: supposons que nous ayons cette classe:
class ScopeMonitor
{
static string urlFragment = "foo/bar";
static string firstPart= "http://www.example.com/";
static string fullUrl= firstPart + urlFragment;
}
Lorsque vous accédez à fullUr, ce sera " http://www.example.com/foo/bar ".
Des mois plus tard, vous nettoyez votre code et alphabétisez les champs (disons qu'ils font partie d'une liste beaucoup plus longue, pour que vous ne remarquiez pas le problème). Tu as:
class ScopeMonitor
{
static string firstPart= "http://www.example.com/";
static string fullUrl= firstPart + urlFragment;
static string urlFragment = "foo/bar";
}
Votre valeur fullUrl est maintenant juste " http://www.example.com/ " car urlFragment n'avait pas été initialisé à l'époque où fullUrl était en cours de traitement. ensemble. Pas bon. Donc, vous ajoutez un constructeur statique pour prendre en charge l'initialisation:
class ScopeMonitor
{
static string firstPart= "http://www.example.com/";
static string fullUrl;
static string urlFragment = "foo/bar";
static ScopeMonitor()
{
fullUrl= firstPart + urlFragment;
}
}
Maintenant, peu importe l'ordre dans lequel vous avez les champs, l'initialisation sera toujours correcte.
1.Il ne peut accéder qu'aux membres statiques de la classe.
Raison: le membre non statique est spécifique à l'instance d'objet. Si les constructeurs statiques sont autorisés à travailler sur des membres non statiques, ils refléteront les modifications apportées à toutes les occurrences de l'objet, ce qui est impossible.
2.Il ne devrait pas y avoir de paramètre (s) dans le constructeur statique.
Raison: Depuis, il va être appelé par le CLR, personne ne peut lui transmettre le paramètre. 3.Un seul constructeur statique est autorisé.
Raison: La surcharge nécessite que les deux méthodes soient différentes en termes de définition de méthode/constructeur, ce qui n'est pas possible dans un constructeur statique.
4.Il ne devrait pas y avoir de modificateur d'accès.
Reason: Encore une fois, la raison est que le même appel au constructeur statique est fait par le CLR et non par l'objet, il n'est donc pas nécessaire de disposer d'un modificateur d'accès.
vous pouvez utiliser le constructeur statique pour initialiser les champs statiques. Il s'exécute à un moment indéterminé avant que ces champs ne soient utilisés. La documentation de Microsoft et de nombreux développeurs avertissent que les constructeurs statiques sur un type imposent une surcharge substantielle.
Il est préférable d’éviter les constructeurs statiques pour une performance maximale.
mise à jour: vous ne pouvez pas utiliser plus d'un constructeur statique dans la même classe, mais vous pouvez utiliser d'autres constructeurs d'instance avec (maximum) un constructeur statique.
Pourquoi et quand créerions-nous un constructeur statique ...?
Une spécifique raison d'utiliser un constructeur statique est de créer une classe 'super enum'. Voici un exemple (simple, artificiel):
public class Animals
{
private readonly string _description;
private readonly string _speciesBinomialName;
public string Description { get { return _description; } }
public string SpeciesBinomialName { get { return _speciesBinomialName; } }
private Animals(string description, string speciesBinomialName)
{
_description = description;
_speciesBinomialName = speciesBinomialName;
}
private static readonly Animals _dog;
private static readonly Animals _cat;
private static readonly Animals _boaConstrictor;
public static Animals Dog { get { return _dog; } }
public static Animals Cat { get { return _cat; } }
public static Animals BoaConstrictor { get { return _boaConstrictor; } }
static Animals()
{
_dog = new Animals("Man's best friend", "Canis familiaris");
_cat = new Animals("Small, typically furry, killer", "Felis catus");
_boaConstrictor = new Animals("Large, heavy-bodied snake", "Boa constrictor");
}
}
Vous l'utiliseriez de manière très similaire (en apparence syntaxique) à toute autre énumération:
Animals.Dog
L'avantage de ceci par rapport à un enum normal est que vous pouvez facilement encapsuler les informations associées. Un inconvénient est que vous ne pouvez pas utiliser ces valeurs dans une instruction switch (car elle nécessite des valeurs constantes).
Constructeur statique
Un constructeur déclaré à l'aide d'un modificateur statique est un constructeur statique. Un constructeur statique est utilisé pour initialiser des données statiques ou pour effectuer une action particulière qui ne doit être effectuée qu'une fois dans le cycle de vie de la classe. Le constructeur statique est le premier bloc de code à exécuter en classe. Le constructeur statique exécute une et une seule fois dans le cycle de vie d'une classe. Cela s'appelle automatiquement. Le constructeur statique ne prend aucun paramètre. Il n'a pas de spécificateurs d'accès. Ce n'est pas appelé directement.