核心 C# - 重构篇 - 变量

2.1 C# 基础

在 C# 中，方法的定义格式如下：

[modifiers] return_type MethodName([parameters]) // “[]” 中括号内可选（选填）
{
	// Method body
}

2.2 变量

在 C# 中声明变量的语法：

datatype identifier;
// 例如：
int i; // 声明
i = 10; // 赋值
// 或者：
int i = 10; // 声明并赋值
int i = 10, j = 20; // 同一行可以声明相同数据类型的变量，不能声明不同数据类型的变量
// 错误例子：
int x= 10, bool y = true;

2.2.1 初始化变量

在 C# 中，不同类型的变量在使用之前都需要初始化，但它们有不同的初始化规则。
PS：这里提到的不同类型指的是：实例变量、静态变量和局部变量。实例变量、静态变量和局部变量是什么后面会具体讲。

1. 实例变量
   1. 在类中声明的实例变量（即不包含 static 关键字的类成员）会被初始化为其默认值。数值类型默认为 0，引用类型默认为 null。

class MyClass
{
    int instanceVariable; // 默认初始化为0
    string anotherInstanceVariable = "Hello"; // 声明时初始化
}

2. 静态变量
   1. 静态变量是使用 static 关键字声明的类成员变量。它们只在类加载时初始化一次，并且可以通过类名直接访问。
   2. 静态变量默认初始化规则与实例变量相同，数值类型为 0，引用类型为 null。

class MyStaticClass
{
    static int staticVariable; // 默认初始化为0
    static string anotherStaticVariable = "World"; // 声明时初始化
}

3. 局部变量
   1. 在方法、代码块或语句内声明的局部变量必须在使用之前明确地初始化。
   2. 局部变量没有默认值，不像实例变量和静态变量，所以必须通过赋值语句为其赋值。

void MyMethod()
{
    int localVariable; // 局部变量声明，但未初始化
    // 尝试在未初始化的情况下使用 localVariable，将导致编译错误
    Console.WriteLine(localVariable);
}

2.2.2 类型判断

C# 类型推断是一种编程语言特性，允许编译器在某些情况下自动推断变量的数据类型，而无需显式指定类型。例如：

var myString = "Hello, C#"; // 编译器推断 myString 的类型为 string
var myNumber = 42; // 编译器推断 myNumber 的类型为 int

类型推断需要遵循以下一些规则：

• 变量必须初始化，以便编译器能够推断其类型。如果尝试使用未初始化的变量，编译器将报错。

var myNumber = 42; // 正确，已初始化
var uninitializedNumber; // 错误，未初始化

• 初始化器不能为空，因为编译器需要从表达式中获取足够的信息以确定变量的类型。

var emptyVar = null; // 错误，无法推断类型

• 初始化器必须是一个有效的表达式，以便编译器能够根据表达式的类型推断变量的类型。

var expressionVar = CalculateResult(); // 正确，初始化器是一个表达式

• 不能把初始化器设置为一个对象，除非在初始化器中创建了一个对象。

var person = new Person(); // 正确，初始化器是一个表达式
var obj = new { Name = "John", Age = 30 }; // 正确，初始化器创建了匿名对象
var invalidVar = new Person; // 错误，不能将对象直接赋给 var

什么是初始化器？初始化器是在声明变量或对象时，通过赋予初始值来初始化它们的一种机制。例如：

int myNumber = 42; // 变量初始化器

int[] numbers = { 1, 2, 3, 4, 5 }; // 数组初始化器

Person person = new Person
{
    Name = "John",
    Age = 30
}; // 对象初始化器

List<int> myList = new List<int> { 1, 2, 3, 4, 5 }; // 集合初始化器

var person = new { Name = "John", Age = 30 }; // 匿名类型初始化器

2.2.3 变量的作用域

C# 中的变量作用域是指变量在程序中可见的区域。作用域规定了变量在何处可以被访问以及何处不可访问。
以下是关于 C# 变量作用域的一些规则：

1. 方法作用域：在方法内部声明的变量仅在该方法内部可见。

void MyMethod()
{
    int localVar = 42; // 方法作用域
    Console.WriteLine(localVar);
}

2. 块作用域：使用大括号 {} 创建的块（比如 if 语句、for 循环、while 循环等）可以限制变量的作用域。

void MyMethod()
{
    if (true)
    {
        int blockVar = 42; // 块作用域
        Console.WriteLine(blockVar);
    }
    Console.WriteLine(blockVar); // 在这里不能访问 blockVar
}

3. 循环作用域：在 for 循环、foreach 循环等迭代语句中声明的变量只在循环内可见。

void MyMethod()
{
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine(i); // 循环作用域
    }
    // 在这里不能访问 i
}

4. 类作用域：在类内部声明的成员变量对整个类可见。

class MyClass
{
    int classVar = 42; // 类作用域
    void MyMethod()
    {
        Console.WriteLine(classVar);
    }
}

5. 局部作用域优先原则：如果在一个更小的作用域中声明了同名的变量，它会覆盖外部作用域的同名变量。

public class MyClass  
{  
    int localVar = 42;  
    public static void Main(string[] args)  
    {        
	    MyMethod();  
    }  
    private static void MyMethod()  
    {        
	    int localVar = 90;  
        Console.WriteLine(localVar); // 90
    }}

2.2.4 常量

在 C# 中，常量是一种具有固定值并且在编译时不可更改的标识符。常量使用 const 关键字声明，通常用于存储程序中的固定值，如数学常数、配置信息等。以下是 C# 中常量的特点：

1. 声明和初始化：使用 const 关键字声明常量，并在声明时立即进行初始化。一旦初始化，常量的值不能再次改变。

const int MAX_VALUE = 10;  
MAX_VALUE = 20; // 局部常量 'MAX_VALUE' 不可变。赋值目标必须为可赋值的变量、属性或索引器

2. 编译时常量：常量在编译时被解析，其值在运行时不会改变。这使得编译器能够在编译时执行优化。
3. 只能用于基本数据类型和字符串：常量可以是整数、浮点数、字符、布尔值或字符串等基本数据类型，但不能是自定义类、结构体或其他非基本类型。

const double Pi = 3.14;
const char Symbol = '*';
const bool IsEnabled = true;

4. 在类中使用：常量可以在类中声明，也可以在类的方法内部声明。在类内部声明的常量可以通过类名直接访问。

class MyClass  
{
    public const int VALUE = 10;
}
class OtherClass  
{
    void ReadValue()
    {
	    Console.WriteLine(MyClass.VALUE);
    }
}

5. 命名规范：常量的命名通常使用大写字母，使用下划线分隔单词，以便与变量区分。

const int MAX_SIZE = 100;

6. 不需要使用关键字 static：与静态变量不同，常量不需要使用 static 关键字，因为它们在编译时被解析，不依赖于类的实例。
7. 在表达式中使用：在编译时已知的常量可以在编译时使用。例如，可以在数组大小或 switch 语句中使用常量。

const int ARRAY_SIZE = 5;
int[] myArray = new int[ARRAY_SIZE];