Quelle est l'utilisation de la variable statique en C #? Quand l'utiliser? Pourquoi ne puis-je pas déclarer la variable statique inside méthode?
J'ai cherché des variables statiques en C #, mais je ne comprends toujours pas son utilisation. De plus, si j'essaie de déclarer la variable à l'intérieur de la méthode, cela ne me donnera pas la permission de le faire. Pourquoi?
J'ai vu quelques exemples concernant la variable statique. J'ai vu qu'il n'était pas nécessaire de créer une instance de la classe pour accéder à la variable, mais cela ne suffisait pas pour comprendre son utilisation et quand l'utiliser.
Deuxième chose
class Book
{
public static int myInt = 0;
}
public class Exercise
{
static void Main()
{
Book book = new Book();
Console.WriteLine(book.myInt); // Shows error why does it show me error?
// Can't I access the static variable
// by making the instance of a class?
Console.ReadKey();
}
}
Une variable static partage sa valeur parmi toutes les instances de la classe.
Exemple sans le déclarer statique:
public class Variable
{
public int i = 5;
public void test()
{
i = i + 5;
Console.WriteLine(i);
}
}
public class Exercise
{
static void Main()
{
Variable var = new Variable();
var.test();
Variable var1 = new Variable();
var1.test();
Console.ReadKey();
}
}
Explication: Si vous regardez l'exemple ci-dessus, je déclare simplement la variable int. Lorsque je lance ce code, la sortie sera 10 et 10. C'est simple.
Maintenant, regardons la variable statique ici; Je déclare la variable en tant que static.
Exemple avec variable statique:
public class Variable
{
public static int i = 5;
public void test()
{
i = i + 5;
Console.WriteLine(i);
}
}
public class Exercise
{
static void Main()
{
Variable var = new Variable();
var.test();
Variable var1 = new Variable();
var1.test();
Console.ReadKey();
}
}
Maintenant, lorsque je lance le code ci-dessus, la sortie sera 10 et 15. La valeur de la variable statique est donc partagée entre toutes les instances de cette classe.
C # n'a pas statique variables du tout. Vous pouvez déclarer static field dans la définition de type particulière via C #. Le champ statique est un état partagé avec toutes les instances d'un type particulier. Par conséquent, la portée du champ statique est un type entier. C'est pourquoi vous ne pouvez pas déclarer statique field au sein d'une méthode - la méthode est une étendue et les éléments déclarés dans une méthode doivent être inaccessibles par-dessus la bordure de la méthode.
les variables statiques sont utilisées lorsqu'une seule copie de la variable est requise. ainsi, si vous déclarez une variable dans la méthode, cette variable n’est pas utilisée, elle devient locale pour fonctionner uniquement ..
exemple de statique est
class myclass
{
public static int a = 0;
}
Les variables déclarées statiques sont généralement partagées entre toutes les instances d'une classe.
Les variables déclarées statiques sont généralement partagées entre toutes les instances d'une classe. Lorsque vous créez plusieurs instances de la classe VariableTest Cette variable permanente est partagée par toutes les instances. Ainsi, à tout moment, la variable permanente ne contiendra qu'une seule valeur de chaîne.
Comme il n’existe qu’une seule copie de la variable disponible pour toutes les instances, le code this.permament entraînera des erreurs de compilation car on peut rappeler que this.variablename fait référence au nom de la variable d’instance. Ainsi, les variables statiques doivent être accédées directement, comme indiqué dans le code.
Quelques exemples "réels" pour les variables statiques:
construire une classe où vous pouvez atteindre des valeurs codées en dur pour votre application. Semblable à une énumération, mais avec plus de flexibilité sur le type de données.
public static class Enemies
{
public readonly static Guid Orc = new Guid("{937C145C-D432-4DE2-A08D-6AC6E7F2732C}");
}
Le singleton largement connu, cela permet de contrôler d'avoir exactement une instance d'une classe. Ceci est très utile si vous voulez y accéder dans l’ensemble de votre application, mais ne le passez pas à toutes les classes simplement pour permettre à cette classe de l’utiliser.
public sealed class TextureManager
{
private TextureManager() {}
public string LoadTexture(string aPath);
private static TextureManager sInstance = new TextureManager();
public static TextureManager Instance
{
get { return sInstance; }
}
}
et voici comment vous appelez le texturemanager
TextureManager.Instance.LoadTexture("myImage.png");
À propos de votre dernière question: Vous faites référence à l’erreur de compilation CS0176 . J'ai essayé de trouver plus d'informations à ce sujet, mais je n'ai pu que trouver ce que le msdn avait à dire à ce sujet:
Une méthode, un champ, une propriété ou un événement statique est appelable sur une classe même lorsqu'aucune instance de la classe n'a été créée. Si des instances de Si la classe est créée, elle ne peut pas être utilisée pour accéder à la statique membre. Une seule copie des champs et des événements statiques existe, et static les méthodes et les propriétés ne peuvent accéder qu'aux champs statiques et à static événements.
Les classes statiques ne nécessitent pas que vous créiez un objet de cette classe/instanciez-les, vous pouvez préfixer le mot clé C # en statique devant le nom de la classe, pour le rendre statique.
Rappelez-vous: nous n’instancions pas la classe Console, la classe String, la classe Array.
class Book
{
public static int myInt = 0;
}
public class Exercise
{
static void Main()
{
Book book = new Book();
//Use the class name directly to call the property myInt,
//don't use the object to access the value of property myInt
Console.WriteLine(Book.myInt);
Console.ReadKey();
}
}
Les membres de données et les membres de fonction opérant sur l'instance de type .__ sont appelés membres d'instance. La méthode ToString de int (par exemple) sont des exemples de membres d’instance. Par défaut, les membres sont des membres d'instance. Les membres de données et les membres de fonction qui n’opèrent pas sur l’instance du type, mais sur le type lui-même, doivent être marqués comme statiques. Les méthodes Test.Main et Console.WriteLine sont des méthodes statiques. La classe Console est en fait une classe statique, ce qui signifie que tous ses membres sont statiques. Vous ne créez jamais réellement d'instances d'une console: une console est partagée par toute l'application.
En réponse au "quand l'utiliser?" question:
J'utilise souvent une variable statique (classe) pour affecter un ID d'instance unique à chaque instance d'une classe. J'utilise le même code dans chaque classe, c'est très simple:
//Instance ID ----------------------------------------
// Class variable holding the last assigned IID
private static int xID = 0;
// Lock to make threadsafe (can omit if single-threaded)
private static object xIDLock = new object();
// Private class method to return the next unique IID
// - accessible only to instances of the class
private static int NextIID()
{
lock (xIDLock) { return ++xID; }
}
// Public class method to report the last IID used
// (i.e. the number of instances created)
public static int LastIID() { return xID; }
// Instance readonly property containing the unique instance ID
public readonly int IID = NextIID();
//-----------------------------------------------------
Ceci illustre quelques points concernant les variables statiques et les méthodes:
- Les variables statiques et les méthodes sont associées à la classe, pas à une instance spécifique de la classe.
- Une méthode statique peut être appelée dans le constructeur d'une instance. Dans ce cas, la méthode statique NextIID est utilisée pour initialiser l'IID de la propriété en lecture seule, qui est l'ID unique de cette instance.
Je trouve cela utile car je développe des applications dans lesquelles des essaims d'objets sont utilisés et il est bon de pouvoir suivre le nombre d'objets créés et de suivre/interroger des instances individuelles.
J'utilise également des variables de classe pour suivre des éléments tels que les totaux et les moyennes des propriétés des instances pouvant être signalés en temps réel. Je pense que la classe est un bon endroit pour conserver des informations résumées sur toutes les instances de la classe.
Les variables statiques sont utilisées lorsqu'une seule copie est requise. Laissez-moi vous expliquer ceci avec un exemple: -
class circle
{
public float _PI =3.14F;
public int Radius;
public funtionArea(int radius)
{
return this.radius * this._PI
}
}
class program
{
public static void main()
{
Circle c1 = new Cirle();
float area1 = c1.functionRaduis(5);
Circle c2 = new Cirle();
float area2 = c1.functionRaduis(6);
}
}
Maintenant, ici, nous avons créé 2 instances pour notre cercle de classe, c’est-à-dire 2 jeux de copies de _PI et d’autres variables. Donc, disons que si nous avons beaucoup d'occurrences de cette classe, plusieurs copies de _PI seront créées en occupant de la mémoire. Dans ce cas, il est préférable de créer des variables telles que _PI static et de les utiliser.
class circle
{
static float _PI =3.14F;
public int Radius;
public funtionArea(int radius)
{
return this.radius * Circle._PI
}
}
class program
{
public static void main()
{
Circle c1 = new Cirle();
float area1 = c1.functionRaduis(5);
Circle c2 = new Cirle();
float area2 = c1.functionRaduis(6);
}
}
Maintenant, quel que soit le nombre d'occurrences créées pour le cercle de classe, il ne reste qu'une copie de la variable _PI sauvegardant notre mémoire.
Essayez de l'appeler directement avec le nom de classe Book.myInt
Par rapport aux variables de session, les variables statiques auront la même valeur pour tous les utilisateurs qui envisagent d’utiliser une application déployée sur le serveur. Si deux utilisateurs accèdent à la même page d'une application, la variable statique contiendra la dernière valeur et la même valeur sera fournie aux deux utilisateurs, contrairement aux variables de session qui sont différentes pour chaque utilisateur. Donc, si vous voulez quelque chose de commun et identique pour tous les utilisateurs, y compris les valeurs censées être utilisées avec le code de l'application, utilisez uniquement statique.
Vous n'avez pas besoin d'instancier un objet, car vous allez utiliser Une variable statique: Console.WriteLine (Book.myInt);