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();

    }
}