Was ist die Verwendung der statischen Variablen in C #? Wann soll man es benutzen? Warum kann ich die statische Variable innerhalb der Methode nicht deklarieren?

Ich habe nach statischen Variablen in C # gesucht, aber ich verstehe immer noch nicht, wie sie verwendet werden. Wenn ich versuche, die Variable innerhalb der Methode zu deklarieren, erhalte ich keine Berechtigung dazu. Warum?

Ich habe einige Beispiele für die statischen Variablen gesehen. Ich habe gesehen, dass wir keine Instanz der Klasse erstellen müssen, um auf die Variable zuzugreifen, aber das reicht nicht aus, um zu verstehen, was sie verwendet und wann sie verwendet werden soll.

Zweite Sache

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

Eine staticVariable teilt den Wert aller Instanzen der Klasse.

Beispiel ohne es als statisch zu deklarieren:

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

Erläuterung: Wenn Sie sich das obige Beispiel ansehen, deklariere ich nur die intVariable. Wenn ich diesen Code ausführe, lautet die Ausgabe 10und 10. Es ist einfach.

Schauen wir uns hier die statische Variable an. Ich deklariere die Variable als static.

Beispiel mit statischer Variable:

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

Wenn ich jetzt über Code laufe, wird die Ausgabe 10und sein 15. Der statische Variablenwert wird also von allen Instanzen dieser Klasse gemeinsam genutzt.

C # hat überhaupt keine statischen Variablen . Sie können ein statisches Feld in der jeweiligen Typdefinition über C # deklarieren . Das statische Feld ist ein Status, der von allen Instanzen eines bestimmten Typs gemeinsam genutzt wird. Daher ist der Umfang des statischen Feldes vom gesamten Typ. Aus diesem Grund können Sie innerhalb einer Methode kein statisches Feld deklarieren. Die Methode ist selbst ein Bereich, und auf Elemente, die in einer Methode deklariert sind, muss über den Methodenrand hinweg nicht zugegriffen werden können.

statische Variablen werden verwendet, wenn nur eine Kopie der Variablen erforderlich ist. Wenn Sie also eine Variable innerhalb der Methode deklarieren, wird diese Variable nicht verwendet. Sie wird lokal, um nur zu funktionieren.

Beispiel für statische ist

class myclass
{
    public static int a = 0;
}

Als statisch deklarierte Variablen werden gemeinsam von allen Instanzen einer Klasse verwendet.

Als statisch deklarierte Variablen werden gemeinsam von allen Instanzen einer Klasse verwendet. Wenn Sie mehrere Instanzen der VariableTest-Klasse erstellen Diese permanente Variable wird von allen gemeinsam genutzt. Somit ist zu einem bestimmten Zeitpunkt nur ein Zeichenfolgenwert in der permanenten Variablen enthalten.

Da für alle Instanzen nur eine Kopie der Variablen verfügbar ist, führt der Code this.permament zu Kompilierungsfehlern, da daran erinnert werden kann, dass sich this.variablename auf den Namen der Instanzvariablen bezieht. Somit ist auf statische Variablen direkt zuzugreifen, wie im Code angegeben.

Einige Beispiele aus der "realen Welt" für statische Variablen:

Erstellen einer Klasse, in der Sie fest codierte Werte für Ihre Anwendung erreichen können. Ähnlich einer Aufzählung, jedoch mit mehr Flexibilität beim Datentyp.

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

Mit dem weithin bekannten Singleton kann so gesteuert werden, dass genau eine Instanz einer Klasse vorhanden ist. Dies ist sehr nützlich, wenn Sie in Ihrer gesamten Anwendung darauf zugreifen möchten, es jedoch nicht an jede Klasse übergeben möchten, damit diese Klasse es verwenden kann.

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

        private static TextureManager sInstance = new TextureManager();

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

und so würden Sie den Texturmanager nennen

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

Zu Ihrer letzten Frage: Sie beziehen sich auf den Compilerfehler CS0176 . Ich habe versucht, mehr Informationen darüber zu finden, konnte aber nur herausfinden, was die MSDN dazu zu sagen hatte:

Eine statische Methode, ein Feld, eine Eigenschaft oder ein Ereignis kann für eine Klasse aufgerufen werden, auch wenn keine Instanz der Klasse erstellt wurde. Wenn Instanzen der Klasse erstellt werden, können sie nicht für den Zugriff auf das statische Element verwendet werden. Es ist nur eine Kopie statischer Felder und Ereignisse vorhanden, und statische Methoden und Eigenschaften können nur auf statische Felder und statische Ereignisse zugreifen.

Statische Variablen werden verwendet, wenn nur eine Kopie davon erforderlich ist. Lassen Sie mich dies anhand eines Beispiels erklären:

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

Jetzt haben wir hier 2 Instanzen für unseren classKreis erstellt, dh 2 Sätze von Kopien _PI zusammen mit anderen Variablen werden erstellt. Sagen wir also, wenn wir viele Instanzen dieser Klasse haben, werden mehrere Kopien _PIerstellt, die den Speicher belegen. In solchen Fällen ist es also besser, solche Variablen zu mögen _PI staticund damit zu arbeiten.

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

Unabhängig davon, wie viele Instanzen für den classKreis erstellt wurden, existiert nur eine Kopie der Variablen _PI, die unseren Speicher spart.

Bei statischen Klassen müssen Sie kein Objekt dieser Klasse erstellen / instanziieren. Sie können dem C # -Schlüsselwort static vor dem Klassennamen ein Präfix voranstellen, um es statisch zu machen.

Denken Sie daran: Wir instanziieren nicht die Konsolenklasse, String-Klasse, Array-Klasse.

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

    }
}

Ausgehend von diesem @ Kartik Patel-Beispiel habe ich ein wenig geändert, vielleicht ist jetzt klarer über statische Variablen

 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. Klassenvariable VS Instanzvariable in C #

   Statische Klassenmitglieder C # ODER Klassenvariable

   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

Die Datenelemente und Funktionselemente, die mit der Instanz des Typs arbeiten, werden als Instanzelemente bezeichnet. Die ToString-Methode des int (zum Beispiel) sind Beispiele für Instanzmitglieder. Standardmäßig sind Mitglieder Instanzmitglieder. Datenelemente und Funktionselemente, die nicht für die Instanz des Typs, sondern für den Typ selbst ausgeführt werden, müssen als statisch markiert werden. Die Methoden Test.Main und Console.WriteLine sind statische Methoden. Die Konsolenklasse ist eigentlich eine statische Klasse, was bedeutet, dass alle ihre Mitglieder statisch sind. Sie erstellen niemals Instanzen einer Konsole - eine Konsole wird für die gesamte Anwendung freigegeben.

Als Antwort auf die Frage "Wann soll es verwendet werden?" Frage:

Ich verwende oft eine statische (Klassen-) Variable, um jeder Instanz einer Klasse eine eindeutige Instanz-ID zuzuweisen. Ich benutze in jeder Klasse den gleichen Code, es ist sehr einfach:

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

Dies veranschaulicht einige Punkte zu statischen Variablen und Methoden:

1. Statische Variablen und Methoden sind der Klasse zugeordnet, keine bestimmte Instanz der Klasse.
2. Eine statische Methode kann im Konstruktor einer Instanz aufgerufen werden. In diesem Fall wird die statische Methode NextIID verwendet, um die schreibgeschützte Eigenschaft IID zu initialisieren, bei der es sich um die eindeutige ID für diese Instanz handelt.

Ich finde das nützlich, weil ich Anwendungen entwickle, in denen Schwärme von Objekten verwendet werden, und es gut ist, zu verfolgen, wie viele erstellt wurden, und einzelne Instanzen zu verfolgen / abzufragen.

Ich verwende auch Klassenvariablen, um Dinge wie Summen und Durchschnittswerte der Eigenschaften der Instanzen zu verfolgen, die in Echtzeit gemeldet werden können. Ich denke, die Klasse ist ein guter Ort, um zusammenfassende Informationen über alle Instanzen der Klasse aufzubewahren.

Versuchen Sie es direkt mit dem Klassennamen aufzurufen Book.myInt

Beim Vergleich mit Sitzungsvariablen haben statische Variablen für alle Benutzer den gleichen Wert, wenn ich eine Anwendung verwende, die auf dem Server bereitgestellt wird. Wenn zwei Benutzer auf dieselbe Seite einer Anwendung zugreifen, enthält die statische Variable den neuesten Wert, und im Gegensatz zu Sitzungsvariablen, die für jeden Benutzer unterschiedlich sind, wird beiden Benutzern derselbe Wert bereitgestellt. Wenn Sie also für alle Benutzer etwas Gemeinsames und Gleiches wünschen, einschließlich der Werte, die im Anwendungscode verwendet werden sollen, verwenden Sie nur statisch.

Sie müssen kein Objekt instanziieren, da Sie eine statische Variable verwenden werden: Console.WriteLine (Book.myInt);

Die statische Variable behält ihren vorherigen Wert bis zum Beenden des Programms bei. Statisch wird verwendet, indem direkt class_Name.Method () oder class_Name.Property aufgerufen wird. Es wird keine Objektreferenz benötigt. Die beliebteste Verwendung von Statik ist die Matheklasse von C #. Math.Sin (), Math.Cos (), Math.Sqrt ().