What is the use of static variable in C#? When to use it? Why can't I declare the static variable inside method?

I have searched about static variables in C#, but I am still not getting what its use is. Also, if I try to declare the variable inside the method it will not give me the permission to do this. Why?

I have seen some examples about the static variables. I've seen that we don't need to create an instance of the class to access the variable, but that is not enough to understand what its use is and when to use it.

Second thing

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();
}
}
354720 次浏览
小开

当只需要变量的一个副本时，使用静态变量。所以如果你在方法里面声明了变量就不需要这样的变量了它就变成了函数的局部变量。.

静态的例子是

class myclass
{
public static int a = 0;
}

Variables declared static are commonly shared across all instances of a class.

声明为静态的变量通常在类的所有实例之间共享。当您创建 VariableTest 类的多个实例时，此永久变量将在所有实例之间共享。因此，在任何给定的时间点，永久变量中只包含一个字符串值。

由于所有实例都只有一个变量副本，所以 this. permment 代码将导致编译错误，因为可以回想一下，this. variablename 指的是实例变量名称。因此，静态变量将被直接访问，如代码中所示。

小开

一些静态变量的“真实世界”示例:

构建一个类，您可以在其中获得应用程序的硬编码值。与枚举类似，但数据类型更加灵活。

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

众所周知的单例模式，它允许控件只拥有一个类的实例。如果您希望在整个应用程序中访问它，但不希望仅仅为了允许这个类使用它而将它传递给每个类，那么这非常有用。

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


private static TextureManager sInstance = new TextureManager();


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

你可以这样称呼纹理管理器

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

关于你最后一个问题: You are refering to compiler error CS0176. I tried to find more infor about that, but could only find what the msdn had to say about it:

A static method, field, property, or event is callable on a class even 当没有创建类的实例时 类，则不能使用它们访问静态 静态字段和事件只存在一个副本，静态 方法和属性只能访问静态字段和静态 事件。

小开

C # 不支持静态 局部变量局部变量(即在方法作用域中声明的变量)。

Https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members#static-members

但是可以声明静态 田野(类成员)。

Reasoning: Static field is a state, shared with all instances of particular type. Hence, the scope of the static field is entire type. That's why you can't declare static 实例变量 (within a method) - method is a scope itself, and items declared in a method must be inaccessible over the method's border.

小开
最佳答案

static变量在类的所有实例中共享它的值。

不声明为静态的示例:

public class Variable
{
public int i = 5;
public void test()
{
i = i + 5;
Console.WriteLine(i);
}
}




public class Exercise
{
static void Main()
{
Variable var1 = new Variable();
var1.test();
Variable var2 = new Variable();
var2.test();
Console.ReadKey();
}
}

说明: 如果你看上面的例子，我只是声明 int变量。当我运行这段代码时，输出将是 10和 10。很简单。

现在让我们看看这里的静态变量; 我将这个变量声明为 static。

静态变量示例:

public class Variable
{
public static int i = 5;
public void test()
{
i = i + 5;
Console.WriteLine(i);
}
}




public class Exercise
{
static void Main()
{
Variable var1 = new Variable();
var1.test();
Variable var2 = new Variable();
var2.test();
Console.ReadKey();
}
}

现在，当我运行以上代码时，输出将是 10和 15。因此，静态变量值在该类的所有实例之间共享。

小开

对类型的实例进行操作的数据成员和函数成员 称为实例成员。Int 的 ToString 方法(例如)是实例成员的示例。默认情况下，成员是实例成员。 Data members and function members that don’t operate on the instance of the type, but rather on the type itself, must be marked as static. The Test.Main and Console.WriteLine methods are static methods. The Console class is actually a static class, which means all its members are static. You never actually create instances of a Console—one console is shared across the whole application.

小开

Try calling it directly with class name Book.myInt

小开

静态类不需要创建该类的对象/实例化它们，可以在类名前面加上 C # 关键字 Static 的前缀，使其成为静态类。

记住: 我们没有实例化 Console 类、 String 类、 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();


}
}
小开

静态变量在程序退出之前保留它的先前值。静态通过直接调用 class _ Name 来使用。方法()或 class _ Name。财产。不需要对象引用。最常用的 static 是 C # 的 Math 类。 数学。辛() ，数学。科斯() ，数学。 Sqrt ()。

小开

在回答“何时使用它?”的问题时:

我经常使用静态(类)变量为类的每个实例分配唯一的实例 ID。我在每堂课都用同样的代码，很简单:

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

这说明了关于静态变量和方法的几点:

  1. 静态变量和方法与类关联，而不是与类的任何特定实例关联。
  2. 可以在实例的构造函数中调用静态方法——在本例中，静态方法 NextIID 用于初始化 readonly 属性 IID，这是此实例的唯一 ID。

我发现这很有用，因为我开发的应用程序中使用了大量的对象，能够跟踪创建了多少个对象，并跟踪/查询单个实例是件好事。

我还使用类变量来跟踪可以实时报告的实例属性的总和和平均值。我认为这个类是保存关于这个类的所有实例的摘要信息的好地方。

小开

与会话变量比较，静态变量将有相同的价值为所有用户考虑我使用的应用程序，是部署在服务器上。如果两个用户访问应用程序的同一页面，那么静态变量将保存最新的值，并且向两个用户提供相同的值，而会话变量对于每个用户都是不同的。因此，如果您希望为所有用户提供一些通用且相同的内容，包括应该沿应用程序代码使用的值，那么只使用 static。

小开

您不需要实例化一个对象，因为您将使用 一个静态变量: 控制台.WriteLine (Book.myInt) ;

小开

当只需要一个静态变量副本时，就会使用静态变量。让我用一个例子来解释这一点:

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

现在我们已经为 class循环创建了2个实例，即创建了2组 _PI的副本以及其他变量。因此，如果我们有很多这个类的实例，多个 _PI的副本将被创建，占用内存。因此，在这种情况下，最好使这样的变量，如 _PI static和操作他们。

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

Now no matter how many instances are made for the class circle , only one copy exists of variable _PI saving our memory.


提交答案