Le static
mot-clé peut être un peu difficile à saisir pour les débutants. Son objectif principal est d'identifier un membre de la classe comme n'appartenant à aucune instance unique de la classe, mais plutôt à la classe elle-même.
Sans entrer dans trop de détails, C # (et Java) appliquent de manière rigide l'idéal orienté objet selon lequel tout le code et les données doivent appartenir à un objet, et sont donc limités en portée, visibilité et durée de vie. C'est généralement la meilleure pratique partout où le principe fondamental d'un objet représentant quelque chose du monde réel s'applique. Cependant, ce n'est pas toujours le cas; parfois ce que vous avez besoin est une fonction ou variable que vous pouvez obtenir à partir de n'importe où dans le code, sans vous obliger à passer autour d' une référence à un objet contenant, et avec la garantie que les données que vous regardez ou le changement est exactement ce que tout le monde sinon, il ne s'agit pas d'une copie appartenant à une instance différente d'un objet.
Un tel comportement était disponible en C et C ++ sous la forme de la fonction ou variable "globale", qui n'était pas encapsulée dans un objet. Ainsi, en guise de compromis, C # et Java prennent en charge la «portée statique», à mi-chemin entre le code véritablement global sans objet parent et les membres d'instance à portée limitée.
Tout "membre de code" (fonction, propriété, champ) déclaré comme static
entrant dans la portée à partir de la première ligne de la main()
fonction du programme , et ne le laisse pas avant la main()
fin de la fonction. En clair, un membre statique existe et peut être utilisé tant que le programme est en cours d'exécution. De plus, les membres statiques sont invoqués en les appelant en tant que membres du type lui-même, et non membres d'une instance de ce type:
public class Foo
{
public int MyInt {get;set;} //this is an "instance member"
public static int MyStaticInt {get;set;} //this is a "static member"
}
...
var myFoo = new Foo();
myFoo.MyInt = 5; //valid
myFoo.MyStaticInt = 5; //invalid; MyStaticInt doesn't belong to any one Foo
Foo.MyInt = 5; //invalid; MyInt only has meaning in the context of an instance
Foo.MyStaticInt = 2; //valid
Cela rend les membres statiques visibles par tout code connaissant le type, qu'ils en connaissent ou non une seule instance.
Pour répondre à votre question, le principal avantage de marquer un élément comme statique est qu'il devient visible partout où le type lui-même est connu, que le code consommateur possède ou puisse obtenir une instance de l'objet conteneur. Il y a aussi un léger avantage en termes de performances; car la méthode a une portée statique, elle ne peut accéder qu'aux autres membres statiques (de la même classe ou d'autres) et à tout ce qui est passé en tant que paramètre. Par conséquent, le runtime n'a à résoudre aucune référence à l'instance actuelle de l'objet conteneur, comme il le devrait normalement pour une méthode d'instance afin de fournir des informations d'état spécifiques au contexte.
Des classes entières peuvent également être marquées comme statiques; ce faisant, vous indiquez au compilateur que la déclaration de classe sera uniquement composée de membres statiques et ne pourra donc pas être instanciée. Il s'agit d'un moyen simple de s'assurer qu'il existe une et une seule copie d'un objet en mémoire; rendre la classe et tout ce qu'il contient statique. Cependant, il est très rare que ce soit la meilleure solution à un tel besoin. Dans une situation où exactement une copie d'un ensemble de données est requise, le "singleton" est généralement recommandé à la place; il s'agit d'une classe non statique, qui utilise un accesseur statique et un constructeur non public pour fournir l'accès à une seule instance de lui-même. Théoriquement, un singleton offre à peu près les mêmes avantages qu'une classe entièrement statique, mais avec la possibilité supplémentaire d'utiliser la classe d'une manière orientée objet et basée sur une instance.