Quelle est l'utilisation de la variable statique en C #? Quand l'utiliser? Pourquoi ne puis-je pas déclarer la variable statique dans la méthode?

J'ai recherché 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 l'autorisation de le faire. Pourquoi?

J'ai vu quelques exemples sur les variables statiques. J'ai vu que nous n'avons pas besoin de créer une instance de la classe pour accéder à la variable, mais cela ne suffit 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 static variable en partage la valeur entre 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 intvariable. Lorsque j'exécute ce code, la sortie sera 10et10 . C'est simple.

Regardons maintenant la variable statique ici; Je déclare la variable comme unstatic .

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 j'exécute le code ci-dessus, la sortie sera 10et 15. La valeur de la variable statique est donc partagée entre toutes les instances de cette classe.

C # n'a pas du tout de variables statiques . Vous pouvez déclarer un champ statique 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 de type entier. C'est pourquoi vous ne pouvez pas déclarer de champ statique dans une méthode - la méthode est une portée elle-même et les éléments déclarés dans une méthode doivent être inaccessibles au-dessus de la bordure de la méthode.

les variables statiques sont utilisées lorsqu'une seule copie de la variable est requise. donc si vous déclarez une variable à l'intérieur de la méthode, il n'y a pas d'utilisation d'une telle variable, 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 entre toutes. Ainsi, à tout moment donné, il n'y aura qu'une seule valeur de chaîne contenue dans la variable permanente.

Comme il n'y a qu'une seule copie de la variable disponible pour toutes les instances, le code this.permament entraînera des erreurs de compilation car il peut être rappelé 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 "du monde réel" pour les variables statiques:

créer une classe dans laquelle vous pouvez atteindre des valeurs codées en dur pour votre application. Similaire à 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 toute votre application, mais ne pas le transmettre à chaque classe juste 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 appelleriez le texturemanager

TextureManager.Instance.LoadTexture("myImage.png");

À propos de votre dernière question: Vous faites référence à l'erreur du compilateur CS0176 . J'ai essayé de trouver plus d'informations à ce sujet, mais je n'ai pu trouver que ce que le msdn avait à dire à ce sujet:

Une méthode, un champ, une propriété ou un événement statique peut être appelé sur une classe même lorsqu'aucune instance de la classe n'a été créée. Si des instances de la classe sont créées, elles ne peuvent pas être utilisées pour accéder au membre statique. Une seule copie des champs et événements statiques existe, et les méthodes et propriétés statiques ne peuvent accéder qu'aux champs statiques et aux événements statiques.

Les variables statiques sont utilisées lorsqu'une seule copie est requise. Laissez-moi vous expliquer cela 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 classcercle, c'est-à-dire que 2 ensembles de copies _PI ainsi que d'autres variables sont créés. Donc, disons que si nous avons beaucoup d'instances de cette classe, plusieurs copies de _PIseront créées en occupant la mémoire. Donc, dans de tels cas, il est préférable de faire aimer ces variables _PI staticet 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);
    }
}

Quel que soit le nombre d'instances créées pour le classcercle, il n'existe qu'une seule copie de la variable _PIsauvegardant notre mémoire.

Les classes statiques ne vous obligent pas à créer un objet de cette classe / à les instancier, vous pouvez préfixer le mot-clé C # static devant le nom de la classe, pour le rendre statique.

N'oubliez pas: 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();

    }
}

À partir de cet exemple @Kartik Patel, j'ai un peu changé peut-être que maintenant c'est plus clair sur la variable statique

 public class Variable
    {
        public static string StaticName = "Sophia ";
        public string nonStName = "Jenna ";
        public void test()
        {
            StaticName = StaticName + " Lauren"; 
            Console.WriteLine("  static ={0}",StaticName);
            nonStName = nonStName + "Bean ";
            Console.WriteLine("  NeStatic neSt={0}", nonStName);

        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Variable var = new Variable();
            var.test();
            Variable var1 = new Variable();
            var1.test();
            Variable var2 = new Variable();
            var2.test();
            Console.ReadKey();

        }
    }

Output 
  static =Sophia  Lauren
  NeStatic neSt=Jenna Bean
  static =Sophia  Lauren Lauren
  NeStatic neSt=Jenna Bean
  static =Sophia  Lauren Lauren Lauren
  NeStatic neSt=Jenna Bean

2. Variable de classe Variable d'instance VS en C #

   Membres de classe statiques Variable de classe C # OR

   class A
   {
       // Class variable or " static member variable"  are declared with 
       //the "static " keyword
   
       public static int i=20;
       public int j=10;         //Instance variable 
       public static string s1="static class variable"; //Class variable 
       public string s2="instance variable";        // instance variable 
   }
   class Program
   {
       static void Main(string[] args)
       {
           A obj1 = new A();
   
           // obj1 instance variables 
           Console.WriteLine("obj1 instance variables ");
           Console.WriteLine(A.i);
           Console.WriteLine(obj1.j);
           Console.WriteLine(obj1.s2);
           Console.WriteLine(A.s1);
   
           A obj2 = new A();
   
           // obj2 instance variables 
           Console.WriteLine("obj2 instance variables ");
           Console.WriteLine(A.i);
           Console.WriteLine(obj2.j);
           Console.WriteLine(obj2.s2);
           Console.WriteLine(A.s1);
   
           Console.ReadKey();
   
       }
   
   
   }

   }

https://en.wikipedia.org/wiki/Class_variable

https://en.wikipedia.org/wiki/Instance_variable

https://en.wikipedia.org/wiki/Static_variable

https://javaconceptoftheday.com/class-variables-and-instance-variables-in-java/?fbclid=IwAR1_dtpHzg3bC5WlGQGdgewaTvuOI6cwVeFUtTV8IZuGTj1qH5PmKGwX0yM

https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members

Les membres de données et les membres de fonction qui opèrent sur l'instance du 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 plutôt 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 sur l'ensemble de l'application.

En réponse à la question "quand l'utiliser?" question:

J'utilise souvent une variable statique (classe) pour attribuer 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();
//-----------------------------------------------------

Cela illustre quelques points sur les variables et méthodes statiques:

1. Les variables et méthodes statiques sont associées à la classe, et non à une instance spécifique de la classe.
2. 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 la propriété en lecture seule IID, qui est l'ID unique de cette instance.

Je trouve cela utile parce que je développe des applications dans lesquelles des essaims d'objets sont utilisés et qu'il est bon de pouvoir suivre combien ont été créés et de suivre / interroger des instances individuelles.

J'utilise également des variables de classe pour suivre des choses comme les totaux et les moyennes des propriétés des instances qui peuvent être rapportées en temps réel. Je pense que la classe est un bon endroit pour conserver des informations récapitulatives sur toutes les instances de la classe.

Essayez de l'appeler directement avec le nom de la classe Book.myInt

En comparaison avec les variables de session, les variables statiques auront la même valeur pour tous les utilisateurs considérant que j'utilise 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 de même pour tous les utilisateurs, y compris les valeurs qui sont censées être utilisées avec le code de l'application, n'utilisez que statique.

Vous n'avez pas besoin d'instancier un objet, car yau va utiliser une variable statique: Console.WriteLine (Book.myInt);

La variable statique conserve sa valeur précédente jusqu'à la fin du programme. Static est utilisé en appelant directement class_Name.Method () ou class_Name.Property. Aucune référence d'objet n'est nécessaire. L'utilisation la plus courante de statique est la classe Math de C #. Math.Sin (), Math.Cos (), Math.Sqrt ().