C# 程序结构与基本语法

2.1 C# 程序结构

一个完整的 C# 程序由以下部分组成：

// 1. using 指令 - 引入命名空间
using System;

// 2. namespace 声明 - 定义命名空间
namespace MyApp
{
    // 3. class 声明 - 定义类
    class Program
    {
        // 4. Main 方法 - 程序入口点
        static void Main(string[] args)
        {
            // 5. 语句和表达式
            Console.WriteLine("Hello, C#!");
        }
    }
}

2.2 using 指令

引入命名空间

// 引入单个命名空间
using System;
using System.Collections.Generic;
using System.IO;

// 引入静态类（.NET 6+）
using static System.Console;

命名空间别名

// 当有命名冲突时使用别名
using IO = System.IO;
using WinForms = System.Windows.Forms;

IO.File.WriteAllText("test.txt", "Hello");

2.3 namespace 命名空间

定义命名空间

namespace Company.Project.Module
{
    class MyClass
    {
        // 类内容
    }
}

// 等效的嵌套写法
namespace Company
{
    namespace Project
    {
        namespace Module
        {
            class MyClass { }
        }
    }
}

使用命名空间

// 完整限定名
Company.Project.Module.MyClass obj = new Company.Project.Module.MyClass();

// 使用 using 后直接使用
using Company.Project.Module;
MyClass obj = new MyClass();

2.4 class 类

类的基本结构

namespace MyApp
{
    // public 访问修饰符
    public class User
    {
        // 字段
        private string _name;
        
        // 属性
        public int Age { get; set; }
        
        // 构造函数
        public User(string name)
        {
            _name = name;
        }
        
        // 方法
        public void SayHello()
        {
            Console.WriteLine($"Hello, I'm {_name}");
        }
    }
}

2.5 Main 方法

入口点形式

// 1. 返回 void，无参数
static void Main() { }

// 2. 返回 void，有参数
static void Main(string[] args) { }

// 3. 返回 int，无参数
static int Main() { return 0; }

// 4. 返回 int，有参数
static int Main(string[] args) { return 0; }

// 5. 异步入口（.NET 7.1+）
static async Task Main() { }
static async Task<int> Main() { return 0; }

命令行参数

// Program.cs
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine($"参数个数: {args.Length}");
        for (int i = 0; i < args.Length; i++)
        {
            Console.WriteLine($"参数 {i}: {args[i]}");
        }
    }
}

运行：

dotnet run arg1 arg2 arg3
# 输出:
# 参数个数: 3
# 参数 0: arg1
# 参数 1: arg2
# 参数 2: arg3

2.6 语句与表达式

语句（Statement）

语句是完整的执行单元，以分号结尾：

// 声明语句
int x = 10;

// 表达式语句
x = x + 5;

// 控制流语句
if (x > 10)
{
    Console.WriteLine("大于 10");
}

// 块语句
{
    int y = 20;
    Console.WriteLine(y);
}

表达式（Expression）

表达式产生值：

// 算术表达式
int result = 10 + 5 * 2;  // 20

// 方法调用表达式
int length = "hello".Length;  // 5

// 条件表达式
int max = (a > b) ? a : b;

// 对象创建表达式
var list = new List<int>();

2.7 注释

单行注释

1 2	// 这是单行注释 int x = 10; // 行尾注释

多行注释

/*
这是多行注释
可以跨越多行
*/
int y = 20;

XML 文档注释

/// <summary>
/// 计算两个数的和
/// </summary>
/// <param name="a">第一个数</param>
/// <param name="b">第二个数</param>
/// <returns>两数之和</returns>
public int Add(int a, int b)
{
    return a + b;
}

2.8 顶级语句（.NET 6+）

简化写法

// .NET 6+ 可以直接写代码，无需 Main 方法和类
using System;

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

int x = 10;
int y = 20;
Console.WriteLine($"Sum: {x + y}");

使用 args 参数

// 顶级语句中 args 隐式可用
foreach (var arg in args)
{
    Console.WriteLine(arg);
}

返回值

// 使用 return 返回值
if (args.Length == 0)
{
    return 1;  // 错误码
}
return 0;  // 成功

2.9 代码块与作用域

代码块

{
    // 代码块定义作用域
    int x = 10;
    Console.WriteLine(x);
}
// x 在此处不可访问

嵌套作用域

int outer = 1;

{
    int inner = 2;
    Console.WriteLine(outer);  // 可以访问外部变量
    Console.WriteLine(inner);  // 可以访问内部变量
}

// Console.WriteLine(inner);  // 错误：inner 不存在

2.10 本章小结

C# 程序由 using、namespace、class、Main 方法组成
using 指令引入命名空间，namespace 组织代码
Main 方法是程序入口点，支持多种形式
语句以分号结尾，表达式产生值
支持单行、多行、XML 文档注释
.NET 6+ 支持顶级语句简化代码

练习题

创建一个包含命名空间和类的完整 C# 程序
编写程序接收命令行参数并打印
为方法添加 XML 文档注释

以下代码输出什么？

int x = 5;
{
    int x = 10;
    Console.WriteLine(x);
}