Qual è l'uso della variabile statica in C #? Quando usarlo? Perché non posso dichiarare la variabile statica all'interno del metodo?

Ho cercato variabili statiche in C #, ma non riesco ancora a capire quale sia il suo utilizzo. Inoltre, se provo a dichiarare la variabile all'interno del metodo, non mi darà il permesso di farlo. Perché?

Ho visto alcuni esempi sulle variabili statiche. Ho visto che non è necessario creare un'istanza della classe per accedere alla variabile, ma ciò non è sufficiente per capire qual è il suo utilizzo e quando usarlo.

Seconda cosa

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

Una staticvariabile condivide il valore di essa tra tutte le istanze della classe.

Esempio senza dichiararlo statico:

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

Spiegazione: se guardi l'esempio sopra, dichiaro solo la intvariabile. Quando eseguo questo codice, l'output sarà 10e 10. È semplice.

Ora diamo un'occhiata alla variabile statica qui; Dichiaro la variabile come file static.

Esempio con variabile statica:

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

Ora, quando eseguo il codice sopra, l'output sarà 10e 15. Quindi il valore della variabile statica è condiviso tra tutte le istanze di quella classe.

C # non ha affatto variabili statiche . È possibile dichiarare il campo statico nella particolare definizione del tipo tramite C #. Il campo statico è uno stato, condiviso con tutte le istanze di un tipo particolare. Quindi, l'ambito del campo statico è di tipo intero. Ecco perché non è possibile dichiarare un campo statico all'interno di un metodo: il metodo è un ambito stesso e gli elementi dichiarati in un metodo devono essere inaccessibili oltre il bordo del metodo.

le variabili statiche vengono utilizzate quando è richiesta una sola copia della variabile. quindi se dichiari variabile all'interno del metodo non c'è uso di tale variabile, diventa locale solo per funzionare ..

esempio di statica è

class myclass
{
    public static int a = 0;
}

Le variabili dichiarate statiche sono comunemente condivise tra tutte le istanze di una classe.

Le variabili dichiarate statiche sono comunemente condivise tra tutte le istanze di una classe. Quando crei più istanze della classe VariableTest Questa variabile permanente è condivisa tra tutte. Pertanto, in un dato momento, ci sarà solo un valore di stringa contenuto nella variabile permanente.

Poiché è disponibile una sola copia della variabile per tutte le istanze, il codice this.permament comporterà errori di compilazione perché si può ricordare che this.variablename si riferisce al nome della variabile di istanza. Pertanto, è necessario accedere direttamente alle variabili statiche, come indicato nel codice.

Alcuni esempi di "mondo reale" per variabili statiche:

creare una classe in cui è possibile raggiungere valori codificati per la propria applicazione. Simile a un'enumerazione, ma con maggiore flessibilità sul tipo di dati.

public static class Enemies
{
    public readonly static Guid Orc = new Guid("{937C145C-D432-4DE2-A08D-6AC6E7F2732C}");
}

Il singleton ampiamente noto, questo consente di controllare di avere esattamente un'istanza di una classe. Questo è molto utile se vuoi accedervi nell'intera applicazione, ma non passarlo a tutte le classi solo per consentire a questa classe di usarlo.

public sealed class TextureManager
    {
        private TextureManager() {}
        public string LoadTexture(string aPath);

        private static TextureManager sInstance = new TextureManager();

        public static TextureManager Instance
        {
            get { return sInstance; }
        }
    }

ed è così che chiameresti texturemanager

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

Sulla tua ultima domanda: ti riferisci all'errore del compilatore CS0176 . Ho provato a trovare maggiori informazioni su questo, ma sono riuscito a trovare solo ciò che il msdn aveva da dire al riguardo:

Un metodo statico, un campo, una proprietà o un evento è richiamabile su una classe anche quando non è stata creata alcuna istanza della classe. Se vengono create istanze della classe, non possono essere utilizzate per accedere al membro statico. Esiste solo una copia dei campi e degli eventi statici e i metodi e le proprietà statici possono accedere solo ai campi statici e agli eventi statici.

Le variabili statiche vengono utilizzate quando è richiesta una sola copia. Lasciatemi spiegare questo con un esempio:

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

Ora qui abbiamo creato 2 istanze per il nostro classcerchio, ovvero _PI vengono create 2 serie di copie di insieme ad altre variabili. Quindi supponiamo che se abbiamo molte istanze di questa classe, _PIverranno create più copie che occupano memoria. Quindi in questi casi è meglio rendere tali variabili simili _PI statice operare su di esse.

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

Ora, indipendentemente dal numero di istanze create per il classcerchio, esiste solo una copia della variabile che _PIsalva la nostra memoria.

Le classi statiche non richiedono di creare un oggetto di quella classe / istanziarle, puoi anteporre la parola chiave C # static davanti al nome della classe, per renderla statica.

Ricorda: non stiamo istanziando 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();

    }
}

Partendo da questo esempio di @Kartik Patel, ho cambiato un po 'forse ora è più chiaro sulla variabile statica

 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. Variabile di classe VS Variabile di istanza in C #

   Membri della classe statica Variabile della classe OR C #

   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

I membri dati e i membri funzione che operano sull'istanza del tipo sono chiamati membri istanza. Il metodo ToString di int (ad esempio) sono esempi di membri dell'istanza. Per impostazione predefinita, i membri sono membri dell'istanza. Membri dati e membri funzione che non operano sull'istanza del tipo, ma piuttosto sul tipo stesso, devono essere contrassegnati come statici. I metodi Test.Main e Console.WriteLine sono metodi statici. La classe Console è in realtà una classe statica, il che significa che tutti i suoi membri sono statici. Non crei mai istanze di una console: una console è condivisa nell'intera applicazione.

In risposta al "quando usarlo?" domanda:

Uso spesso una variabile statica (classe) per assegnare un ID istanza univoco a ogni istanza di una classe. Uso lo stesso codice in ogni classe, è molto semplice:

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

Questo illustra un paio di punti sulle variabili e sui metodi statici:

1. Le variabili ei metodi statici sono associati alla classe, non a un'istanza specifica della classe.
2. Un metodo statico può essere chiamato nel costruttore di un'istanza: in questo caso, il metodo statico NextIID viene utilizzato per inizializzare la proprietà readonly IID, che è l'ID univoco per questa istanza.

Lo trovo utile perché sviluppo applicazioni in cui vengono utilizzati sciami di oggetti ed è bene essere in grado di tenere traccia di quanti sono stati creati e monitorare / interrogare singole istanze.

Uso anche le variabili di classe per tenere traccia di cose come i totali e le medie delle proprietà delle istanze che possono essere riportate in tempo reale. Penso che la classe sia un buon posto per conservare le informazioni di riepilogo su tutte le istanze della classe.

Prova a chiamarlo direttamente con il nome della classe Book.myInt

A confronto con le variabili di sessione, le variabili statiche avranno lo stesso valore per tutti gli utenti considerando che sto utilizzando un'applicazione distribuita nel server. Se due utenti accedono alla stessa pagina di un'applicazione, la variabile statica conterrà il valore più recente e lo stesso valore verrà fornito a entrambi gli utenti a differenza delle variabili di sessione che sono diverse per ogni utente. Quindi, se vuoi qualcosa di comune e uguale per tutti gli utenti, inclusi i valori che dovrebbero essere usati nel codice dell'applicazione, usa solo static.

Non è necessario creare un'istanza di un oggetto, perché userete una variabile statica: Console.WriteLine (Book.myInt);

La variabile statica mantiene il valore precedente fino all'uscita dal programma. Static viene utilizzato chiamando direttamente class_Name.Method () o class_Name.Property. Non è necessario alcun riferimento all'oggetto. L'uso più popolare di static è la classe Math di C #. Math.Sin (), Math.Cos (), Math.Sqrt ().