C # 'da statik değişkenin kullanımı nedir? Ne Zaman Kullanılır? Yöntem içindeki statik değişkeni neden bildiremiyorum?

C # 'da statik değişkenler hakkında araştırma yaptım, ancak hala kullanımının ne olduğunu anlamıyorum. Ayrıca, metodun içindeki değişkeni bildirmeye çalışırsam, bana bunu yapma izni vermez. Neden?

Statik değişkenler hakkında bazı örnekler gördüm. Değişkene erişmek için sınıfın bir örneğini oluşturmamız gerekmediğini gördüm, ancak bu onun kullanımının ne olduğunu ve ne zaman kullanılacağını anlamak için yeterli değil.

İkinci şey

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

Bir staticdeğişken, sınıfın tüm örnekleri arasında değerini paylaşır.

Statik olarak bildirmeden örnek:

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

Açıklama: Yukarıdaki örneğe bakarsanız, sadece intdeğişkeni beyan ederim . Bu kodu çalıştırdığımda çıktı 10ve olacaktır 10. Basit.

Şimdi burada statik değişkene bakalım; Değişkeni bir static.

Statik değişkenli örnek:

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

Şimdi yukarıdaki kodu çalıştırdığımda, çıktı 10ve olacaktır 15. Dolayısıyla, statik değişken değeri o sınıfın tüm örnekleri arasında paylaşılır.

C # hiç statik değişken içermez . Belirli bir tür tanımındaki statik alanı C # aracılığıyla bildirebilirsiniz . Statik alan, belirli türdeki tüm örneklerle paylaşılan bir durumdur. Bu nedenle, statik alanın kapsamı tüm türdür. Bu nedenle, bir yöntem içinde statik alan bildiremezsiniz - yöntem, bir kapsamın kendisidir ve bir yöntemde bildirilen öğelerin, yöntemin sınırı üzerinden erişilemez olması gerekir.

statik değişkenler, değişkenin yalnızca bir kopyası gerektiğinde kullanılır. bu nedenle, yöntemin içinde değişken bildirirseniz, böyle bir değişken kullanılmaz, yalnızca işlev görecek yerel hale gelir ..

statik örneği

class myclass
{
    public static int a = 0;
}

Statik olarak bildirilen değişkenler, genellikle bir sınıfın tüm örnekleri arasında paylaşılır.

Statik olarak bildirilen değişkenler, genellikle bir sınıfın tüm örnekleri arasında paylaşılır. VariableTest sınıfının birden çok örneğini oluşturduğunuzda Bu kalıcı değişken, tümü arasında paylaşılır. Bu nedenle, herhangi bir zaman noktasında, kalıcı değişkende yalnızca bir dize değeri olacaktır.

Değişkenin tüm örnekler için kullanılabilen yalnızca bir kopyası olduğundan, this.permament kodu derleme hatalarına neden olur çünkü this.variablename değişkeninin adını ifade ettiği hatırlanabilir. Bu nedenle, statik değişkenlere, kodda belirtildiği gibi doğrudan erişilebilir.

Statik değişkenler için bazı "gerçek dünya" örnekleri:

uygulamanız için kodlanmış değerlere ulaşabileceğiniz bir sınıf oluşturmak. Numaralandırmaya benzer, ancak veri türünde daha fazla esnekliğe sahiptir.

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

Yaygın olarak bilinen singleton, bu, bir sınıfın tam olarak bir örneğine sahip olmayı kontrol etmeye izin verir. Bu, tüm uygulamanızda ona erişmek istiyorsanız, ancak yalnızca bu sınıfın kullanmasına izin vermek için onu her sınıfa geçirmiyorsanız çok kullanışlıdır.

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

        private static TextureManager sInstance = new TextureManager();

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

ve texturemanager'ı böyle adlandırırsınız

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

Son sorunuz hakkında: CS0176 derleyici hatasına başvuruyorsunuz . Bunun hakkında daha fazla bilgi bulmaya çalıştım, ancak yalnızca msdn'nin bu konuda söylediği şeyi bulabildim:

Statik bir yöntem, alan, özellik veya olay, sınıfın hiçbir örneği oluşturulmamış olsa bile bir sınıfta çağrılabilir. Sınıfın herhangi bir örneği oluşturulursa, bunlar statik üyeye erişmek için kullanılamaz. Statik alanların ve olayların yalnızca bir kopyası vardır ve statik yöntemler ve özellikler yalnızca statik alanlara ve statik olaylara erişebilir.

Statik değişkenler, yalnızca bir kopyası gerektiğinde kullanılır. Bunu bir örnekle açıklayayım:

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

Şimdi burada çemberimiz için 2 örnek oluşturduk class, yani _PI diğer değişkenlerle birlikte 2 kopya kümesi oluşturuldu. Diyelim ki, bu sınıfın birçok örneğine _PIsahipsek, hafızayı işgal eden birden fazla kopyası oluşturulacaktır. Bu yüzden bu gibi durumlarda, bu tür değişkenler yapmak _PI staticve onlar üzerinde çalışmak daha iyidir .

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

Şimdi, classdaire için kaç örnek yapılırsa yapılsın, _PIhafızamızı kaydeden değişkenin yalnızca bir kopyası vardır .

Statik sınıflar, bu sınıfın bir nesnesini oluşturmanızı / bunları başlatmanızı gerektirmez, statik yapmak için C # anahtar sözcüğünü sınıf adının önüne önek olarak ekleyebilirsiniz.

Unutmayın: Console sınıfını, String sınıfını, Array Sınıfını başlatmıyoruz.

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

    }
}

Bu @ Kartik Patel örneğinden başlayarak, biraz değiştim belki şimdi statik değişken hakkında daha net

 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. C # 'da Sınıf Değişkeni VS Örnek Değişkeni

   Statik Sınıf Üyeleri C # VEYA Sınıf Değişkeni

   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

Tip vakasında çalışan veri üyeleri ve işlev üyelerine örnek üyeler denir. İnt'in ToString yöntemi (örneğin), örnek üyelerin örnekleridir. Varsayılan olarak, üyeler örnek üyeleridir. Tip örneğinde değil, tipin kendisinde işlem yapan veri üyeleri ve işlev üyeleri statik olarak işaretlenmelidir. Test.Main ve Console.WriteLine yöntemleri statik yöntemlerdir. Console sınıfı aslında statik bir sınıftır, yani tüm üyeleri statiktir. Asla bir Konsolun örneklerini oluşturmazsınız; tüm uygulama genelinde bir konsol paylaşılır.

"Ne zaman kullanılmalı?" Sorusuna yanıt olarak soru:

Bir sınıfın her örneğine benzersiz bir örnek kimliği atamak için genellikle statik (sınıf) bir değişken kullanıyorum. Her sınıfta aynı kodu kullanıyorum, çok basit:

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

Bu, statik değişkenler ve yöntemler hakkında birkaç noktayı gösterir:

1. Statik değişkenler ve yöntemler, sınıfın herhangi bir belirli örneği ile değil, sınıfla ilişkilendirilir.
2. Bir örneğin yapıcısında statik bir yöntem çağrılabilir - bu durumda, NextIID statik yöntemi, bu örneğin benzersiz kimliği olan salt okunur özelliği IID'yi başlatmak için kullanılır.

Bunu yararlı buluyorum çünkü içinde nesne sürülerinin kullanıldığı uygulamalar geliştiriyorum ve kaç tane yaratıldığını izleyebilmek ve bireysel örnekleri izleyebilmek / sorgulamak iyi.

Ayrıca, gerçek zamanlı olarak raporlanabilen örneklerin özelliklerinin toplamları ve ortalamaları gibi şeyleri izlemek için sınıf değişkenlerini de kullanıyorum. Sınıfın, sınıfın tüm örnekleri hakkında özet bilgileri saklamak için iyi bir yer olduğunu düşünüyorum.

Doğrudan sınıf adıyla aramayı deneyin Book.myInt

Oturum değişkenleriyle karşılaştırıldığında statik değişkenler, sunucuda konuşlandırılmış bir uygulamayı kullandığımı düşünen tüm kullanıcılar için aynı değere sahip olacaktır. Bir uygulamanın aynı sayfasına erişen iki kullanıcı varsa, statik değişken en son değeri tutacak ve her kullanıcı için farklı olan oturum değişkenlerinin aksine aynı değer her iki kullanıcıya da sağlanacaktır. Bu nedenle, uygulama kodu boyunca kullanılması gereken değerler dahil olmak üzere tüm kullanıcılar için ortak ve aynı bir şey istiyorsanız, o zaman yalnızca statik kullanın.

Bir nesneyi başlatmanıza gerek yoktur, çünkü yau statik bir değişken kullanacaktır: Console.WriteLine (Book.myInt);

Statik değişken, program çıkana kadar önceki değerini korur. Statik, doğrudan class_Name.Method () veya class_Name.Property çağrılarak kullanılır. Nesne referansına gerek yoktur. Statik'in en popüler kullanımı C # 'ın Math sınıfıdır. Math.Sin (), Math.Cos (), Math.Sqrt ().