青少年编程与数学 02-020 C#程序设计基础 04课题、常量和变量

摘要：本文介绍了C#程序设计基础中的常量和变量。详细讲解了主函数的格式、参数和返回值，变量的声明、初始化、类型、作用域和生命周期，常量的定义、作用域和使用场景，字面量的类型和使用方法，赋值语句的基本用法和复合赋值运算符，以及控制台输出语句的使用。通过这些内容，读者可以掌握C#中常量和变量的基本概念及其在编程中的应用。

关键词：C#程序设计、主函数、变量、常量、字面量、赋值语句、控制台输出

AI助手：Kimi、DeepSeek

---

一、主函数

在C#编程中，主函数（Main函数）是程序的入口点，是程序开始执行的地方。以下是关于C#主函数的详细说明：

1. 主函数的基本格式

主函数的定义通常如下：

public static void Main()
{// 程序代码
}

• public：访问修饰符，表示该函数可以被外部调用。虽然主函数通常被定义为public，但它也可以是private或protected，具体取决于程序的结构。
• static：静态修饰符，表示该函数属于类本身，而不是类的某个实例。因此，主函数可以直接通过类名调用，而无需创建类的实例。
• void：返回类型，表示主函数不返回任何值。主函数也可以返回int类型，通常用于表示程序的退出状态码。
• Main：函数名称，必须是Main，这是C#语言规定的程序入口点名称。

2. 主函数的参数

主函数可以接受一个字符串数组作为参数，用于接收命令行参数。格式如下：

public static void Main(string[] args)
{// 程序代码
}

• string[] args：字符串数组，存储从命令行传递给程序的参数。例如，如果在命令行中运行程序时输入了program.exe param1 param2，那么args[0]的值为param1，args[1]的值为param2。

3. 主函数的返回值

主函数可以返回void，也可以返回int类型。返回int类型时，通常用于表示程序的退出状态码：

public static int Main()
{// 程序代码return 0; // 返回0表示程序正常退出
}

• 返回值0通常表示程序正常退出，其他非零值通常表示程序运行中出现了错误。

4. 主函数的作用

主函数是程序的入口点，它负责初始化程序的运行环境，并调用其他函数来完成程序的主要功能。以下是主函数的一些常见作用：

• 初始化程序：设置程序的初始状态，如加载配置文件、初始化变量等。
• 调用其他函数：根据程序的逻辑，调用其他函数来完成具体的功能。
• 处理命令行参数：如果程序需要从命令行接收参数，主函数可以解析这些参数并根据参数值执行不同的操作。

5. 主函数的示例

以下是一个简单的C#程序示例，展示了主函数的基本用法：

using System;namespace HelloWorld
{class Program{public static void Main(string[] args){// 检查是否有命令行参数if (args.Length > 0){Console.WriteLine("Hello, " + args[0] + "!");}else{Console.WriteLine("Hello, World!");}}}
}

• 如果在命令行中运行该程序并传递参数John，程序将输出Hello, John!。
• 如果不传递任何参数，程序将输出Hello, World!。

6. 主函数的注意事项

• 唯一性：一个C#程序中只能有一个Main函数作为程序的入口点。
• 线程安全：主函数是程序的主线程入口，因此在多线程程序中，主函数的代码可能会与其他线程并发执行。
• 异常处理：主函数中应该包含异常处理机制，以防止程序在运行过程中因未捕获的异常而崩溃。

总之，主函数是C#程序的核心部分，它负责启动程序并协调程序的运行。

二、变量

在C#中，变量是用来存储数据的容器，它具有一个名称（标识符）、一个数据类型和一个值。变量的使用是编程的基础，以下是关于C#中变量的详细解释。

1. 变量的声明

在C#中，变量的声明需要指定变量的类型和名称。语法如下：

类型 变量名;

示例

int age; // 声明一个整数类型的变量
double price; // 声明一个双精度浮点数类型的变量
string name; // 声明一个字符串类型的变量

2. 变量的初始化

变量可以在声明时进行初始化，也可以在声明后单独赋值。

声明时初始化

int age = 25; // 声明并初始化一个整数类型的变量
double price = 3.14; // 声明并初始化一个双精度浮点数类型的变量
string name = "Kimi"; // 声明并初始化一个字符串类型的变量

声明后赋值

int age;
age = 25; // 单独赋值
double price;
price = 3.14; // 单独赋值
string name;
name = "Kimi"; // 单独赋值

3. 变量的类型

C# 是一种强类型语言，变量的类型在声明时必须明确指定，且在程序运行过程中不能改变。C# 中的变量类型可以分为两大类：值类型和引用类型。

3.1 值类型（Value Types）

值类型变量直接存储数据值，它们存储在栈内存中。值类型包括以下几种：

3.1.1 简单类型

C# 提供了一些内置的简单类型，用于表示数字、布尔值和字符等。

整数类型

类型	大小（字节）	范围
sbyte	1	-128 到 127
byte	1	0 到 255
short	2	-32768 到 32767
ushort	2	0 到 65535
int	4	-2147483648 到 2147483647
uint	4	0 到 4294967295
long	8	-9223372036854775808 到 9223372036854775807
ulong	8	0 到 18446744073709551615

示例

int age = 25;
long population = 7800000000;

浮点类型

类型	大小（字节）	范围
float	4	约 ±1.5 × 10^-45 到 ±3.4 × 10^38
double	8	约 ±5.0 × 10^-324 到 ±1.8 × 10^308

示例

float price = 3.14f; // 注意：float 类型的字面量需要加 f 或 F
double distance = 3.141592653589793;

布尔类型

布尔类型用于表示逻辑值，只有两个可能的值：true 和 false。

bool isApproved = true;

字符类型

字符类型用于表示单个 Unicode 字符，使用单引号表示。

char grade = 'A';

3.1.2 枚举类型

枚举类型是一种特殊的值类型，它是一组命名的常量集合。枚举类型可以基于任何整数类型，默认是 int。

示例

enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };Day today = Day.Mon;

3.1.3 结构类型

结构类型是一种用户定义的值类型，它允许将多个相关变量组合在一起。结构类型使用 struct 关键字定义。

示例

struct Point
{public int X;public int Y;public Point(int x, int y){X = x;Y = y;}
}Point p = new Point(1, 2);

3.2 引用类型（Reference Types）

引用类型变量存储的是对象的引用，而不是对象本身。引用类型变量存储在堆内存中，而引用本身存储在栈内存中。引用类型包括以下几种：

3.2.1 类类型

类是C#中最常见的引用类型，它是一种用户定义的类型，可以包含数据成员和方法。

示例

class Person
{public string Name { get; set; }public int Age { get; set; }
}Person person = new Person { Name = "Kimi", Age = 25 };

3.2.2 接口类型

接口是一种引用类型，它定义了一组方法和属性，但不实现它们。类可以实现接口，从而实现接口中定义的方法和属性。

示例

interface IAnimal
{void MakeSound();
}class Dog : IAnimal
{public void MakeSound(){Console.WriteLine("Woof!");}
}IAnimal animal = new Dog();
animal.MakeSound(); // 输出 "Woof!"

3.2.3 数组类型

数组是一种引用类型，用于存储一组相同类型的元素。数组的大小在创建时确定，且不能改变。

示例

int[] numbers = new int[5] { 1, 2, 3, 4, 5 };
string[] names = { "Kimi", "Alice", "Bob" };

3.2.4 委托类型

委托是一种引用类型，它用于定义方法的签名，并可以指向符合该签名的方法。

示例

delegate void MyDelegate(string message);class Program
{static void Main(){MyDelegate del = PrintMessage;del("Hello, World!");}static void PrintMessage(string message){Console.WriteLine(message);}
}

3.2.5 动态类型（C# 4.0+）

动态类型是一种特殊的引用类型，它允许在运行时动态地绑定成员访问和方法调用。

示例

dynamic obj = 10;
Console.WriteLine(obj + 5); // 输出 15obj = "Hello, World!";
Console.WriteLine(obj.ToUpper()); // 输出 "HELLO, WORLD!"

4. 变量的作用域

变量的作用域是指变量可以被访问的范围。C# 中的变量作用域主要有以下几种：

4.1 局部变量

局部变量是在方法或代码块中声明的变量，它的作用域仅限于该方法或代码块。

示例

void PrintMessage()
{string message = "Hello, World!"; // 局部变量Console.WriteLine(message);
}

4.2 成员变量

成员变量是在类中声明的变量，它的作用域是整个类。成员变量又可以分为实例变量和静态变量。

实例变量

实例变量是与类的实例相关联的变量，每个实例都有自己的实例变量副本。

class Person
{public string Name; // 实例变量public int Age; // 实例变量
}Person person1 = new Person { Name = "Kimi", Age = 25 };
Person person2 = new Person { Name = "Alice", Age = 30 };

静态变量

静态变量是与类本身相关联的变量，而不是与类的实例相关联。静态变量在整个程序运行期间都存在。

class Program
{static int count = 0; // 静态变量static void Main(){Console.WriteLine(count); // 输出 0count++;Console.WriteLine(count); // 输出 1}
}

4.3 参数变量

参数变量是在方法声明中定义的变量，它的作用域是整个方法体。

void PrintMessage(string message) // 参数变量
{Console.WriteLine(message);
}

4.4 全局变量（C# 8.0+）

C# 8.0 引入了全局变量的概念，允许在命名空间级别声明变量。

global using static System.Console;class Program
{static void Main(){WriteLine("Hello, World!");}
}

5. 变量的存储位置

变量的存储位置取决于变量的类型和作用域。C# 中的变量存储位置主要有以下几种：

5.1 栈内存

栈内存用于存储局部变量和方法调用的上下文信息。栈内存中的变量在方法调用结束时自动释放。

5.2 堆内存

堆内存用于存储引用类型对象。堆内存中的对象在程序运行期间一直存在，直到被垃圾回收器回收。

5.3 静态存储区

静态存储区用于存储静态变量和常量。静态存储区中的变量在程序启动时初始化，在程序结束时释放。

6. 变量的生命周期

变量的生命周期是指变量从创建到销毁的过程。变量的生命周期取决于变量的作用域和存储位置。

6.1 局部变量的生命周期

局部变量的生命周期从变量声明开始，到方法或代码块结束时结束。

6.2 成员变量的生命周期

实例变量的生命周期与类的实例的生命周期相同，从实例创建开始，到实例被垃圾回收器回收时结束。

静态变量的生命周期与程序的生命周期相同，从程序启动时初始化，到程序结束时销毁。

6.3 参数变量的生命周期

参数变量的生命周期与方法的生命周期相同，从方法调用开始，到方法调用结束时结束。

7. 变量的命名规则

C# 中的变量命名需要遵循一定的规则：

1. 变量名必须以字母或下划线开头，不能以数字开头。
2. 变量名只能包含字母、数字和下划线（A-z, 0-9, _ ）。
3. 变量名不能是C#的关键字，如int、string、class等。
4. 变量名是区分大小写的，Age和age是两个不同的变量。

示例

int age = 25; // 合法
int _age = 25; // 合法
int 1age = 25; // 不合法，变量名不能以数字开头
int int = 25; // 不合法，变量名不能是关键字

8. 变量的修饰符

C# 中的变量可以使用修饰符来限制变量的访问权限或行为。

8.1 访问修饰符

访问修饰符用于控制变量的访问权限。C# 中的访问修饰符主要有以下几种：

• public：表示变量可以被任何其他类访问。
• private：表示变量只能被定义它的类访问。
• protected：表示变量可以被定义它的类及其派生类访问。
• internal：表示变量只能被同一程序集中的类访问。
• protected internal：表示变量可以被同一程序集中的类或派生类访问。

示例

class Person
{public string Name { get; set; } // 公有变量private int age; // 私有变量
}

8.2 静态修饰符

静态修饰符用于修饰静态变量。静态变量与类本身相关联，而不是与类的实例相关联。

class Program
{static int count = 0; // 静态变量
}

8.3 只读修饰符

只读修饰符用于修饰只读变量。只读变量在声明时或构造函数中赋值后，其值不能被修改。

class Person
{public readonly string Name;public Person(string name){Name = name; // 只能在构造函数中赋值}
}

8.4 常量修饰符

常量修饰符用于修饰常量变量。常量变量的值在声明时赋值后，不能被修改。

class Program
{const double PI = 3.141592653589793; // 常量变量
}

9. 变量的默认值

在C#中，变量在声明时如果没有显式初始化，会自动赋予默认值。默认值取决于变量的类型。

值类型的默认值

• 整数类型（int、long等）：默认值为0
• 浮点类型（float、double等）：默认值为0.0
• 布尔类型（bool）：默认值为false
• 字符类型（char）：默认值为'\0'
• 枚举类型：默认值为枚举类型的第一个值
• 结构类型：默认值为结构类型的每个成员的默认值

引用类型的默认值

引用类型的默认值为null，表示没有引用任何对象。

示例

int age; // 默认值为 0
double price; // 默认值为 0.0
bool isApproved; // 默认值为 false
string name; // 默认值为 null

10. 变量的使用示例

以下是一个综合示例，展示了C#中变量的声明、初始化、作用域和生命周期等概念：

using System;class Program
{static void Main(){// 声明并初始化变量int age = 25;double price = 3.14;string name = "Kimi";// 输出变量的值Console.WriteLine($"Name: {name}, Age: {age}, Price: {price}");// 局部变量的作用域{int localAge = 30; // 局部变量Console.WriteLine($"Local Age: {localAge}");}// Console.WriteLine(localAge); // 错误：局部变量的作用域已结束// 引用类型变量Person person = new Person { Name = "Kimi", Age = 25 };Console.WriteLine($"Person: {person.Name}, {person.Age}");// 静态变量Program.IncrementCount();Program.IncrementCount();Console.WriteLine($"Count: {Program.count}");}static int count = 0; // 静态变量static void IncrementCount(){count++;}
}class Person
{public string Name { get; set; }public int Age { get; set; }
}

运行结果：

Name: Kimi, Age: 25, Price: 3.14
Local Age: 30
Person: Kimi, 25
Count: 2

总之，变量是C#编程的基础，通过合理使用变量，可以方便地存储和操作数据。

三、常量

在C#中，常量是指在程序运行过程中其值不能被修改的变量。常量的使用可以提高代码的可读性和可维护性，同时也有助于避免硬编码问题。以下是关于C#中常量的详细解释。

1. 常量的定义

常量的定义使用const关键字，语法如下：

const 类型 常量名 = 值;

示例

const int MAX_SIZE = 100; // 定义一个整数常量
const double PI = 3.141592653589793; // 定义一个双精度浮点数常量
const string APP_NAME = "MyApp"; // 定义一个字符串常量

注意事项

• 必须在定义时初始化：常量必须在定义时赋予一个初始值，且该值在程序运行过程中不能被修改。
• 类型推断：C# 9.0 及更高版本支持在某些情况下省略常量的类型声明，编译器会根据初始值推断类型。

  const MAX_SIZE = 100; // C# 9.0+ 支持
  

2. 常量的作用域

常量的作用域取决于其定义的位置。

2.1 类级别常量

类级别的常量可以在类的任何地方使用，但只能在类的静态方法或静态构造函数中访问。

class Program
{const int MAX_SIZE = 100; // 类级别的常量static void Main(){Console.WriteLine(MAX_SIZE); // 可以访问}void PrintSize(){Console.WriteLine(MAX_SIZE); // 非静态方法中也可以访问}
}

2.2 命名空间级别常量（C# 8.0+）

C# 8.0 引入了全局常量的概念，允许在命名空间级别定义常量。

namespace MyNamespace
{const int MAX_SIZE = 100; // 命名空间级别的常量
}class Program
{static void Main(){Console.WriteLine(MyNamespace.MAX_SIZE); // 可以访问}
}

3. 常量的类型

常量可以是任何数据类型，包括基本数据类型（如int、double、string等）和用户定义的类型（如枚举）。

3.1 基本数据类型常量

const int MAX_SIZE = 100;
const double PI = 3.141592653589793;
const string APP_NAME = "MyApp";
const char GRADE = 'A';
const bool IS_ACTIVE = true;

3.2 枚举类型常量

enum Day
{Sun,Mon,Tue,Wed,Thu,Fri,Sat
}class Program
{const Day TODAY = Day.Mon;static void Main(){Console.WriteLine(TODAY); // 输出 "Mon"}
}

4. 常量的使用场景

常量通常用于以下场景：

4.1 避免硬编码

硬编码是指直接在代码中写入固定的值，这会导致代码难以维护和扩展。使用常量可以避免硬编码问题。

const int MAX_SIZE = 100;
const double PI = 3.141592653589793;void CalculateArea(double radius)
{double area = PI * radius * radius;Console.WriteLine($"Area: {area}");
}

4.2 配置参数

常量可以用于定义配置参数，这些参数在程序运行过程中不会改变。

const string DATABASE_URL = "localhost";
const int DATABASE_PORT = 3306;

4.3 状态码

常量可以用于定义状态码，这些状态码在程序运行过程中不会改变。

const int STATUS_OK = 200;
const int STATUS_NOT_FOUND = 404;
const int STATUS_INTERNAL_ERROR = 500;

5. 常量与只读变量的区别

C# 中的常量和只读变量（readonly）都表示不可变的值，但它们之间有一些区别：

5.1 常量

• 编译时常量：常量的值在编译时确定，且不能被修改。
• 存储位置：常量存储在元数据中，而不是在内存中。
• 作用域：常量的作用域是其定义的类或命名空间。
• 使用场景：常量通常用于表示不会改变的值，如数学常量、状态码等。

5.2 只读变量

• 运行时只读：只读变量的值可以在运行时确定，且只能在构造函数中赋值。
• 存储位置：只读变量存储在内存中，与普通变量类似。
• 作用域：只读变量的作用域是其定义的类。
• 使用场景：只读变量通常用于表示在对象构造后不会改变的值，如对象的唯一标识符等。

示例

class Program
{const int MAX_SIZE = 100; // 常量readonly int ID; // 只读变量public Program(int id){ID = id; // 只能在构造函数中赋值}static void Main(){Console.WriteLine(MAX_SIZE); // 输出 100Program program = new Program(1);Console.WriteLine(program.ID); // 输出 1}
}

6. 常量的注意事项

6.1 常量的命名规范

常量的命名通常使用大写字母，单词之间用下划线分隔，以提高可读性。

const int MAX_SIZE = 100;
const double PI = 3.141592653589793;

6.2 常量的类型推断

C# 9.0 及更高版本支持在某些情况下省略常量的类型声明，编译器会根据初始值推断类型。

const MAX_SIZE = 100; // C# 9.0+ 支持

6.3 常量的存储位置

常量存储在元数据中，而不是在内存中。因此，常量的值在编译时被嵌入到程序集中，这可能导致一些意外行为。

示例

namespace MyNamespace
{const int MAX_SIZE = 100;
}class Program
{static void Main(){Console.WriteLine(MyNamespace.MAX_SIZE); // 输出 100}
}

如果修改了MyNamespace.MAX_SIZE的值，但没有重新编译Program类，Program类中使用的仍然是旧的值。

7. 常量的示例

以下是一个综合示例，展示了C#中常量的定义、使用和注意事项：

using System;namespace MyNamespace
{const int MAX_SIZE = 100; // 命名空间级别的常量const double PI = 3.141592653589793; // 命名空间级别的常量
}class Program
{const string APP_NAME = "MyApp"; // 类级别的常量static void Main(){Console.WriteLine(MyNamespace.MAX_SIZE); // 输出 100Console.WriteLine(MyNamespace.PI); // 输出 3.141592653589793Console.WriteLine(APP_NAME); // 输出 MyApp// 使用常量计算圆的面积double radius = 5.0;double area = MyNamespace.PI * radius * radius;Console.WriteLine($"Area: {area}"); // 输出 "Area: 78.53981633974483"}
}

运行结果：

100
3.141592653589793
MyApp
Area: 78.53981633974483

总之，常量是C#编程中非常重要的概念，通过合理使用常量，可以提高代码的可读性和可维护性，同时也有助于避免硬编码问题。

四、字面量

在C#中，字面量（Literal）是指在代码中直接表示的数据值。字面量是编程语言中的一种基本概念，用于在代码中直接表示具体的值，而无需通过变量或表达式来计算。以下是关于C#中字面量的详细解释。

1. 字面量的类型

C#中的字面量可以表示多种数据类型，包括整数、浮点数、布尔值、字符、字符串等。每种类型的字面量都有其特定的语法和表示方法。

1.1 整数字面量

整数字面量用于表示整数值。C#支持多种整数类型，包括int、long、uint、ulong等。整数字面量可以使用十进制、十六进制或二进制表示。

十进制表示

int a = 123; // 十进制整数字面量

十六进制表示

int b = 0x7B; // 十六进制整数字面量，等价于十进制的123

二进制表示（C# 7.0+）

int c = 0b1111011; // 二进制整数字面量，等价于十进制的123

整数字面量的类型推断

如果整数字面量的值超出了int类型的范围，C#会自动将其视为long类型。

long d = 1234567890123456789; // 超出int范围，自动视为long类型

1.2 浮点数字面量

浮点数字面量用于表示浮点数值。C#支持float和double两种浮点数类型。浮点数字面量默认为double类型，可以通过添加后缀f或F将其显式指定为float类型。

示例

double pi = 3.141592653589793; // 默认为double类型
float f = 3.14f; // 显式指定为float类型

1.3 布尔字面量

布尔字面量用于表示布尔值，只有两个可能的值：true和false。

示例

bool isApproved = true;
bool isDenied = false;

1.4 字符字面量

字符字面量用于表示单个字符，使用单引号'括起来。字符字面量可以是任何Unicode字符，也可以使用转义序列表示特殊字符。

示例

char letter = 'A'; // 普通字符
char newline = '\n'; // 转义序列，表示换行符
char tab = '\t'; // 转义序列，表示制表符

1.5 字符串字面量

字符串字面量用于表示字符串，使用双引号"括起来。字符串字面量可以包含多个字符，也可以使用转义序列表示特殊字符。

示例

string greeting = "Hello, World!"; // 普通字符串
string path = "C:\\Users\\Kimi\\Documents"; // 使用转义序列表示反斜杠
string multiline = "This is a\nmultiline string."; // 使用转义序列表示换行符

1.6 逐字字符串字面量（Verbatim String Literals）

逐字字符串字面量是一种特殊的字符串字面量，使用@符号作为前缀。逐字字符串字面量中的反斜杠被视为普通字符，而不是转义字符。逐字字符串字面量可以包含换行符和制表符，而无需使用转义序列。

示例

string path = @"C:\Users\Kimi\Documents"; // 逐字字符串，反斜杠被视为普通字符
string multiline = @"This is a
multiline string."; // 逐字字符串，包含换行符

1.7 日期和时间字面量

C#没有专门的日期和时间字面量，但可以通过DateTime类的构造函数或静态方法来创建日期和时间对象。

示例

DateTime now = new DateTime(2025, 5, 8, 10, 30, 0); // 创建一个DateTime对象
DateTime today = DateTime.Today; // 获取当前日期
DateTime now2 = DateTime.Now; // 获取当前日期和时间

2. 字面量的使用

字面量在C#编程中非常常见，它们通常用于初始化变量、作为方法参数或在表达式中直接使用。

2.1 初始化变量

int age = 25; // 使用整数字面量初始化变量
double price = 3.14; // 使用浮点数字面量初始化变量
string name = "Kimi"; // 使用字符串字面量初始化变量
bool isApproved = true; // 使用布尔字面量初始化变量

2.2 作为方法参数

Console.WriteLine("Hello, World!"); // 使用字符串字面量作为方法参数
Console.WriteLine(3.14); // 使用浮点数字面量作为方法参数

2.3 在表达式中使用

int result = 10 + 20; // 使用整数字面量在表达式中
double area = 3.14 * 5 * 5; // 使用浮点数字面量在表达式中

3. 字面量的注意事项

3.1 整数字面量的类型推断

如果整数字面量的值超出了int类型的范围，C#会自动将其视为long类型。为了避免类型不匹配的问题，可以在整数字面量后添加后缀L或l显式指定为long类型。

示例

long bigNumber = 1234567890123456789L; // 显式指定为long类型

3.2 浮点数字面量的类型推断

浮点数字面量默认为double类型。如果需要指定为float类型，可以在浮点数字面量后添加后缀f或F。

示例

float f = 3.14f; // 显式指定为float类型

3.3 字符串字面量的转义序列

在字符串字面量中，反斜杠\是一个特殊字符，用于表示转义序列。如果需要在字符串中包含反斜杠，可以使用双反斜杠\\。

示例

string path = "C:\\Users\\Kimi\\Documents"; // 使用转义序列表示反斜杠

3.4 逐字字符串字面量的换行符

逐字字符串字面量可以包含换行符，但换行符会直接保留在字符串中。如果需要在逐字字符串中包含换行符，可以直接换行。

示例

string multiline = @"This is a
multiline string."; // 逐字字符串，包含换行符

3.5 字面量的大小写敏感性

C#是大小写敏感的语言，字面量的大小写也会影响其值。例如，布尔字面量true和false是大小写敏感的，必须使用小写字母。

示例

bool isApproved = true; // 正确
bool isDenied = false; // 正确
bool IsApproved = True; // 错误，True不是有效的布尔字面量

4. 字面量的示例

以下是一个综合示例，展示了C#中各种字面量的使用：

using System;class Program
{static void Main(){// 整数字面量int a = 123; // 十进制int b = 0x7B; // 十六进制int c = 0b1111011; // 二进制（C# 7.0+）long d = 1234567890123456789L; // 超出int范围，显式指定为long类型// 浮点数字面量double pi = 3.141592653589793;float f = 3.14f;// 布尔字面量bool isApproved = true;bool isDenied = false;// 字符字面量char letter = 'A';char newline = '\n';char tab = '\t';// 字符串字面量string greeting = "Hello, World!";string path = "C:\\Users\\Kimi\\Documents"; // 使用转义序列表示反斜杠string multiline = @"This is a
multiline string."; // 逐字字符串，包含换行符// 输出所有字面量Console.WriteLine($"a: {a}, b: {b}, c: {c}, d: {d}");Console.WriteLine($"pi: {pi}, f: {f}");Console.WriteLine($"isApproved: {isApproved}, isDenied: {isDenied}");Console.WriteLine($"letter: {letter}, newline: {newline}, tab: {tab}");Console.WriteLine($"greeting: {greeting}");Console.WriteLine($"path: {path}");Console.WriteLine($"multiline: {multiline}");}
}

运行结果：

a: 123, b: 123, c: 123, d: 1234567890123456789
pi: 3.14159265358979, f: 3.14
isApproved: True, isDenied: False
letter: A, newline: 
, tab:     
greeting: Hello, World!
path: C:\Users\Kimi\Documents
multiline: This is a
multiline string.

总之，字面量是C#编程中非常重要的概念，通过合理使用字面量，可以方便地在代码中表示各种数据值。

五、赋值语句

在C#中，赋值语句是编程的基础，用于将值赋给变量。赋值语句的语法简单，但其功能和使用场景非常广泛。以下是对C#中赋值语句的详细解释：

1. 基本赋值语句

赋值语句的基本语法是：

变量名 = 表达式;

其中，变量名是要赋值的变量，表达式是要赋给变量的值。

示例

int a = 10; // 将整数10赋值给变量a
double b = 3.14; // 将双精度浮点数3.14赋值给变量b
string name = "Kimi"; // 将字符串"Kimi"赋值给变量name

2. 赋值运算符

C# 提供了多种赋值运算符，用于简化赋值操作。

简单赋值运算符

int x = 5;

复合赋值运算符

复合赋值运算符结合了赋值和运算操作，常见的复合赋值运算符包括：

• +=：加法赋值
• -=：减法赋值
• *=：乘法赋值
• /=：除法赋值
• %=：取模赋值
• &=：按位与赋值
• |=：按位或赋值
• ^=：按位异或赋值
• <<=：左移赋值
• >>=：右移赋值

示例

int a = 10;
a += 5; // 等价于 a = a + 5，结果 a = 15
a -= 3; // 等价于 a = a - 3，结果 a = 12
a *= 2; // 等价于 a = a * 2，结果 a = 24
a /= 4; // 等价于 a = a / 4，结果 a = 6
a %= 5; // 等价于 a = a % 5，结果 a = 1

3. 多变量赋值

可以同时为多个变量赋相同的值，或者通过一行代码完成多个变量的赋值。

示例

int x, y, z;
x = y = z = 10; // x, y, z 都被赋值为10int a = 1, b = 2, c = 3; // 同时声明并赋值多个变量

4. 条件赋值

条件赋值语句可以根据条件表达式的值来决定赋值的结果。C# 提供了三元运算符（?:）来实现条件赋值。

语法

变量名 = 条件表达式 ? 表达式1 : 表达式2;

如果条件表达式为true，则变量被赋值为表达式1的结果；否则，变量被赋值为表达式2的结果。

示例

int age = 18;
string status = age >= 18 ? "Adult" : "Minor";
Console.WriteLine(status); // 输出 "Adult"

5. 引用类型赋值

对于引用类型（如类、数组等），赋值操作会将一个引用赋给另一个变量，而不是复制对象本身。

示例

class Person
{public string Name { get; set; }
}Person person1 = new Person { Name = "Kimi" };
Person person2 = person1; // person2 和 person1 指向同一个对象person2.Name = "Alice";
Console.WriteLine(person1.Name); // 输出 "Alice"

在这个例子中，person1 和 person2 都指向同一个Person对象，因此修改person2.Name也会影响person1.Name。

6. 值类型赋值

对于值类型（如int、double、struct等），赋值操作会创建一个独立的副本。

示例

int a = 10;
int b = a; // b 是 a 的一个副本b = 20;
Console.WriteLine(a); // 输出 10
Console.WriteLine(b); // 输出 20

在这个例子中，b 是 a 的一个副本，对 b 的修改不会影响 a。

7. 解构赋值（C# 7.0+）

C# 7.0 引入了解构赋值，允许将一个元组或对象的多个属性一次性赋值给多个变量。

示例

(int, string) GetPerson()
{return (1, "Kimi");
}var (id, name) = GetPerson();
Console.WriteLine(id); // 输出 1
Console.WriteLine(name); // 输出 "Kimi"

8. 注意事项

• 类型兼容性：赋值时，表达式的类型必须与变量的类型兼容。如果类型不兼容，可能需要进行显式类型转换。

  double d = 3.14;
  int i = (int)d; // 显式类型转换
  

• 空值赋值：对于引用类型，可以赋值为null，表示没有引用任何对象。

  Person person = null;
  

• 只读变量赋值：只读变量（readonly）只能在声明时或构造函数中赋值。

  readonly int ReadOnlyVar = 10;
  

9. 示例代码

以下是一个综合示例，展示了C#中赋值语句的多种用法：

using System;class Program
{static void Main(){// 基本赋值int a = 10;Console.WriteLine("a = " + a);// 复合赋值a += 5;Console.WriteLine("a += 5: " + a);// 条件赋值int age = 18;string status = age >= 18 ? "Adult" : "Minor";Console.WriteLine("Status: " + status);// 引用类型赋值Person person1 = new Person { Name = "Kimi" };Person person2 = person1;person2.Name = "Alice";Console.WriteLine("person1.Name: " + person1.Name);// 解构赋值var (id, name) = GetPerson();Console.WriteLine("id: " + id + ", name: " + name);}static (int, string) GetPerson(){return (1, "Kimi");}
}class Person
{public string Name { get; set; }
}

运行结果：

a = 10
a += 5: 15
Status: Adult
person1.Name: Alice
id: 1, name: Kimi

总之，C#中的赋值语句是编程的基础，通过合理使用赋值语句，可以方便地操作变量和对象。

六、输出语句

在C#中，控制台输出主要通过System.Console类来实现。Console类提供了多种方法用于向控制台输出信息。以下是对C#中控制台输出语句的详细解释：

1. Console.WriteLine 方法

Console.WriteLine 是最常用的控制台输出方法，用于在控制台输出一行文本，并在输出后自动换行。

基本用法

Console.WriteLine("Hello, World!");

输出结果：

Hello, World!

输出变量

可以输出变量的值：

int age = 25;
Console.WriteLine("My age is " + age);

输出结果：

My age is 25

使用占位符

Console.WriteLine 支持使用占位符（{0}、{1} 等）来格式化输出：

string name = "Kimi";
int age = 25;
Console.WriteLine("My name is {0} and I am {1} years old.", name, age);

输出结果：

My name is Kimi and I am 25 years old.

2. Console.Write 方法

Console.Write 与 Console.WriteLine 类似，但它不会在输出后自动换行。

基本用法

Console.Write("Hello, ");
Console.Write("World!");

输出结果：

Hello, World!

输出变量

同样可以输出变量的值：

int age = 25;
Console.Write("My age is ");
Console.Write(age);

输出结果：

My age is 25

使用占位符

Console.Write 也支持占位符：

string name = "Kimi";
int age = 25;
Console.Write("My name is {0} and I am {1} years old.", name, age);

输出结果：

My name is Kimi and I am 25 years old.

3. 格式化输出

C# 提供了多种格式化选项，可以在输出时指定数字、日期等的格式。

格式化数字

double price = 123.456;
Console.WriteLine("The price is {0:C}", price); // 货币格式
Console.WriteLine("The price is {0:N2}", price); // 保留两位小数

输出结果：

The price is $123.46
The price is 123.46

格式化日期

DateTime now = DateTime.Now;
Console.WriteLine("Today is {0:yyyy-MM-dd}", now); // 自定义日期格式
Console.WriteLine("Today is {0:dddd, MMMM dd, yyyy}", now); // 更详细的日期格式

输出结果：

Today is 2025-05-08
Today is Thursday, May 08, 2025

4. 设置控制台属性

Console 类还提供了一些方法来设置控制台的属性，如前景色、背景色、标题等。

设置前景色和背景色

Console.ForegroundColor = ConsoleColor.Red;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine("This is red text on a black background.");
Console.ResetColor(); // 恢复默认颜色

输出结果：

This is red text on a black background.

设置控制台标题

Console.Title = "My Console Application";

这会将控制台窗口的标题设置为“My Console Application”。

清空控制台

Console.Clear();

这会清空控制台窗口中的所有内容。

5. 控制台输入与输出结合

控制台输出通常与控制台输入结合使用，以实现交互式程序。

示例：简单的交互程序

Console.Write("Please enter your name: ");
string name = Console.ReadLine();
Console.WriteLine("Hello, " + name + "!");

运行结果：

Please enter your name: Kimi
Hello, Kimi!

6. 注意事项

• 编码问题：在某些情况下，控制台输出可能会出现乱码，特别是当输出非ASCII字符时。可以通过设置控制台的编码来解决：

  Console.OutputEncoding = System.Text.Encoding.UTF8;
  

• 性能问题：频繁的控制台输出可能会影响程序的性能，尤其是在输出大量数据时。如果需要高效输出，可以考虑使用其他方式（如写入文件）。

总之，Console 类提供了丰富的功能来实现控制台输出，通过合理使用这些方法，可以方便地在控制台显示各种信息。

七、综合示例

以下是一个综合示例代码，展示了C#中常量和变量的相关特性，包括变量的声明、初始化、类型、作用域，常量的定义和使用，以及赋值语句和控制台输出的使用。

using System;namespace ConstantsAndVariablesExample
{class Program{// 类级别的常量const double PI = 3.141592653589793;const string APP_NAME = "ConstantsAndVariablesApp";// 类级别的变量static int count = 0;static void Main(string[] args){// 局部变量的声明和初始化int age = 25; // 值类型变量string name = "Kimi"; // 引用类型变量bool isApproved = true; // 布尔类型变量// 输出变量的值Console.WriteLine($"Name: {name}, Age: {age}, Is Approved: {isApproved}");// 使用类级别的常量double radius = 5.0;double area = PI * radius * radius;Console.WriteLine($"Area of circle with radius {radius} is {area}");// 局部变量的作用域{int localAge = 30; // 局部变量Console.WriteLine($"Local Age: {localAge}");}// Console.WriteLine(localAge); // 错误：局部变量的作用域已结束// 引用类型变量的赋值Person person1 = new Person { Name = "Kimi", Age = 25 };Person person2 = person1; // 引用赋值person2.Name = "Alice";Console.WriteLine($"Person1 Name: {person1.Name}, Person2 Name: {person2.Name}");// 值类型变量的赋值int a = 10;int b = a; // 值赋值b = 20;Console.WriteLine($"a: {a}, b: {b}");// 条件赋值int ageThreshold = 18;string status = age >= ageThreshold ? "Adult" : "Minor";Console.WriteLine($"Status: {status}");// 解构赋值var (id, nameTuple) = GetPerson();Console.WriteLine($"id: {id}, name: {nameTuple}");// 调用方法并输出结果IncrementCount();IncrementCount();Console.WriteLine($"Count: {count}");// 控制台属性设置Console.ForegroundColor = ConsoleColor.Green;Console.WriteLine("This is green text.");Console.ResetColor();// 等待用户输入后退出Console.WriteLine("Press any key to exit...");Console.ReadKey();}static void IncrementCount(){count++;}static (int, string) GetPerson(){return (1, "Kimi");}}class Person{public string Name { get; set; }public int Age { get; set; }}
}

代码说明

1. 主函数（Main）：

   • 程序的入口点，接受命令行参数。
   • 使用了类级别的常量和变量。

2. 变量的声明和初始化：

   • 局部变量 age、name 和 isApproved 的声明和初始化。
   • 输出变量的值。

3. 常量的使用：

   • 类级别的常量 PI 和 APP_NAME 的定义和使用。
   • 使用常量计算圆的面积。

4. 局部变量的作用域：

   • 局部变量 localAge 的作用域限制在代码块内。

5. 引用类型变量的赋值：

   • 引用类型变量 person1 和 person2 的赋值和修改。

6. 值类型变量的赋值：

   • 值类型变量 a 和 b 的赋值和修改。

7. 条件赋值：

   • 使用三元运算符根据条件赋值。

8. 解构赋值：

   • 使用解构赋值从方法返回的元组中提取值。

9. 静态变量的使用：

   • 静态变量 count 的使用和修改。

10. 控制台输出：

    • 使用 Console.WriteLine 和 Console.Write 输出信息。
    • 设置控制台属性，如前景色。

运行这段代码后，你将看到各种变量和常量的使用结果，以及控制台输出的效果。

总结

本文是关于常量和变量的使用。首先介绍了主函数（Main）作为程序入口点的基本概念，包括其格式、参数和返回值。接着详细讲解了变量的声明、初始化、类型（值类型和引用类型）、作用域、存储位置和生命周期。常量部分则涵盖了常量的定义、作用域、类型、使用场景以及与只读变量的区别。此外，文章还介绍了字面量的类型、使用方法和注意事项，以及赋值语句的基本用法、复合赋值运算符、条件赋值和解构赋值。最后，文章讲解了控制台输出语句的使用，包括Console.WriteLine和Console.Write的方法、格式化输出和控制台属性设置。通过这些内容，读者可以全面了解C#中常量和变量的基础知识及其在编程中的应用。