C#入门必备，基本知识点梳理

C#和C语言，C++有许多相似的地方，学过C语言的同学相信可以快速掌握C#

一、C# 程序的基本结构

一个完整的 C# 程序由命名空间（Namespace）、类（Class）、方法（Method） 三大核心部分组成，Main 方法是程序的入口点。

基础示例：Hello World

// 引入系统核心命名空间（提供基础功能，如控制台输入输出）
using System;

// 自定义命名空间：用于组织代码，避免类名冲突
namespace CSharpBasicDemo
{
    // 类：C#中所有代码都必须包含在类中，是代码的容器
    class Program
    {
        // Main方法：程序的入口，必须是static，返回值可void或int
        static void Main(string[] args)
        {
            // 控制台输出：向控制台打印内容，WriteLine输出内容后自动换行
            Console.WriteLine("Hello C# World!");
            // 暂停控制台，避免程序运行后直接关闭
            Console.ReadLine();
        }
    }
}

1. using 指令：引入已有的命名空间，避免写全类名（如System.Console.WriteLine可简化为Console.WriteLine）；
2. 命名空间命名规范：通常采用 “公司名。项目名。模块名” 格式，如Microsoft.AspNetCore.Mvc；
3. Main 方法规则：必须是static，可修饰为public/private，参数固定为string[] args（接收命令行参数）。
4. Console.ReadLine()用于接收字符串，用户输入的内容会被自动转为string类型，如果需要得到int或其他类型的值都可以使用Parse()方法，代码如下：

//string类型---->int类型
Console.WriterLine("请输入一个数");
int a=int.Prase(Console.ReadLine());
Console.WriterLine($"请输入一个数{a}");


//string类型----->double类型
Console.WriterLine("请输入一个数");
double a=doublie.Prase(Console.ReadLine());

//同理，string转其他类型数值类型均可通过这种方式实现

     5. 输出语句中字符串插值$"{变量名}"比+拼接更直观，性能更好

二、数据类型

C# 是强类型语言，变量声明时必须指定数据类型，主要分为值类型和引用类型两大类。

1. 值类型（直接存储数据，分配在栈上）

2. 引用类型（存储数据地址，分配在堆上）

实战示例：值类型与引用类型区别

// 值类型：赋值是拷贝
int a = 10;
int b = a;
b = 20;
Console.WriteLine(a); // 输出10（a不受b影响）

// 引用类型：赋值是地址传递
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr2[0] = 100;
Console.WriteLine(arr1[0]); // 输出100（arr1受arr2影响）

// 自定义结构体（值类型）
struct Point
{
    public int X;
    public int Y;
}
Point p1 = new Point { X = 1, Y = 2 };
Point p2 = p1;
p2.X = 10;
Console.WriteLine(p1.X); // 输出1（值类型拷贝）

C#中值类型的转换：

1、可以使用Prase()方法

2、(int) —— 显式数值类型转换

(1)不能用于字符串：(int)"123" 会编译错误。

(2)转换时如果数值超出 int 范围，在 checked 上下文中会抛出 OverflowException，在 unchecked      上下文中会溢出（截断高位），但不会报错（默认是 unchecked）。

(3) 对于 double 或 float，直接截断小数部分，不是四舍五入。

(4)对于 bool、string 等非数值类型不能转换

三、变量与常量

1. 变量

• 定义：可变的存储单元，语法：数据类型 变量名 = 初始值;
• 命名规范：驼峰命名（首字母小写，后续单词首字母大写），如userName、studentAge。

2. 常量

• 定义：不可变的量，用const修饰，必须声明时赋值，语法：const 数据类型 常量名 = 值;
• 命名规范：全大写，单词间用下划线分隔，如MAX_NUM、PI。

示例

// 变量
string userName = "李四";
userName = "王五"; // 变量可修改

// 常量
const double PI = 3.1415926;
// PI = 3.14; // 报错：常量不可修改

const int MAX_SCORE = 100;
Console.WriteLine($"满分：{MAX_SCORE}");

四、运算符

C# 运算符分为算术、赋值、比较、逻辑、三元等，核心常用如下：

1. 核心运算符示例

// 算术运算符：+ - * / %（取模）
int x = 10, y = 3;
Console.WriteLine(x + y); // 13
Console.WriteLine(x % y); // 1（取余数）

// 赋值运算符：= += -= *= /=
int num = 5;
num += 3; // 等价于num = num + 3 → 8
num *= 2; // 等价于num = num * 2 → 16

// 比较运算符：== != > < >= <=（返回bool值）
Console.WriteLine(10 > 5); // true
Console.WriteLine("abc" == "abc"); // true

// 逻辑运算符：&&（与） ||（或） !（非）
bool isAdult = true;
bool hasId = false;
Console.WriteLine(isAdult && hasId); // false（都真才真）
Console.WriteLine(isAdult || hasId); // true（一真则真）
Console.WriteLine(!isAdult); // false（取反）

// 三元运算符：条件 ? 表达式1 : 表达式2
int score = 85;
string result = score >= 60 ? "及格" : "不及格";
Console.WriteLine(result); // 输出及格

2. 运算符优先级

• 算术运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符；
• 可通过()提升优先级，如(10 + 2) * 3（先算括号内）。

五、流程控制

流程控制决定程序执行顺序，核心包括分支、循环、跳转语句。

1. 分支语句（if-else、switch）

// if-else
int score = 90;
if (score >= 90)
{
    Console.WriteLine("优秀");
}
else if (score >= 80)
{
    Console.WriteLine("良好");
}
else
{
    Console.WriteLine("继续努力");
}

// switch（支持int、string、枚举等类型）
string season = "春季";
switch (season)
{
    case "春季":
        Console.WriteLine("春暖花开");
        break; // 跳出switch
    case "夏季":
        Console.WriteLine("夏日炎炎");
        break;
    default: // 匹配不到时执行
        Console.WriteLine("未知季节");
        break;
}

2. 循环语句（for、while、foreach）

// for循环：适合已知循环次数
for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"循环次数：{i}");
}

// while循环：适合未知循环次数
int count = 0;
while (count < 3)
{
    Console.WriteLine("while循环");
    count++;
}

// foreach：遍历集合/数组
int[] nums = {10, 20, 30};
foreach (int n in nums)
{
    Console.WriteLine(n); // 依次输出10、20、30
}

for语句适合已知循环次数

foreach语句只读遍历数组/集合，代码简洁但不可修改元素

break跳出循环

continue跳过本此循环

3. 跳转语句（break、continue、return）

// break：跳出当前循环/switch
for (int i = 0; i < 5; i++)
{
    if (i == 2) break;
    Console.WriteLine(i); // 输出0、1
}

// continue：跳过当前循环，进入下一次
for (int i = 0; i < 5; i++)
{
    if (i == 2) continue;
    Console.WriteLine(i); // 输出0、1、3、4
}

// return：跳出方法
static int Add(int a, int b)
{
    return a + b; // 返回结果并结束方法
}

六、数组

1、一维数组

(1)核心特征

• 存储结构：连续内存空间，存储一组相同类型元素，属于引用数据类型。
• 三要素（扩展）：元素数据类型、数组名（命名规则同变量）、数组元素、数组长度（容量）。

(2)使用步骤

(3) 初始化方式

(4)常用操作

• 获取长度：arr.Length（动态获取，避免硬编码）。
• 遍历数组：通过 for 循环（下标遍历），示例：

int sum = 0;
for (int i = 0; i < arr.Length; i++) {
    sum += arr[i];
}

元素查找：遍历数组匹配目标值，记录下标（未找到返回 - 1）。
极值查找：假设第一个元素为极值，遍历后续元素对比更新。
冒泡排序：
升序：两两比较，大值后移；降序：小值后移。
轮数：数组长度-1，每轮比较次数：数组长度-轮数。

2、Array 类（System 命名空间）

数组默认继承 System.Array，提供静态方法简化操作：

3、二维数组

(1)矩形二维数组 长度获取：

arr.Length：总元素个数；

arr.GetLength(0)：行数；

arr.GetLength(1)：列数。

遍历：双层 for 循环（外层行、内层列）：

for (int i = 0; i < arr.GetLength(0); i++) {
    for (int j = 0; j < arr.GetLength(1); j++) {
        Console.Write(arr[i,j] + " ");
    }
    Console.WriteLine();
}

静态初始化：

int[,] arr = {
    {1,2,3},
    {4,5,6}
};

底层结构：本质是一维数组，一维下标 = 行下标 × 列数 + 列下标。

(2)锯齿二维数组
使用步骤：声明 → 开辟一维数组空间 → 为每行一维数组赋值：

int[][] arr = new int[2][];
arr[0] = new int[]{1,2}; // 第一行2个元素
arr[1] = new int[]{3,4,5}; // 第二行3个元素

长度获取：
arr.Length：一维数组个数（行数）；
arr[i].Length：第 i 行一维数组的长度。
遍历：双层 for 循环（外层遍历行，内层遍历每行的列）。

补充知识点
var 关键字：根据赋值推导变量类型，类型一旦确定不可变更（如 var a = 10; → int 类型）。

常见异常：
IndexOutOfRangeException：下标越界 → 检查下标范围；
NullReferenceException：空引用调用成员 → 先做非空判断。
插值语法：$"{表达式[,对齐宽度][:格式]}"，对齐宽度：正数右对齐，负数左对齐。
杨辉三角（补充）：
每行第一个数为 1；
下一项值 = 当前项 × (行 - 列 +1)/ 列（行、列从 0 开始）；
空格数 = 总行数 - 1 - 当前行。

七、方法（函数）

方法是封装可复用代码的单元，核心要素：访问修饰符、返回类型、方法名、参数列表。

1. 方法定义与调用

class MethodDemo
{
    // 静态方法：通过类名直接调用
    public static int Sum(int num1, int num2)
    {
        return num1 + num2;
    }

    // 非静态方法：需要实例化类后调用
    public string GetInfo(string name)
    {
        return $"姓名：{name}";
    }

    static void Main()
    {
        // 调用静态方法
        int result = Sum(10, 20);
        Console.WriteLine(result); // 30

        // 调用非静态方法
        MethodDemo demo = new MethodDemo();
        string info = demo.GetInfo("赵六");
        Console.WriteLine(info); // 姓名：赵六
    }
}

2. 方法重载

同一类中，方法名相同、参数列表（个数 / 类型 / 顺序）不同，称为重载，提升代码灵活性。

class OverloadDemo
{
    public static int Add(int a, int b)
    {
        return a + b;
    }

    // 重载：参数个数不同
    public static int Add(int a, int b, int c)
    {
        return a + b + c;
    }

    // 重载：参数类型不同
    public static double Add(double a, double b)
    {
        return a + b;
    }

    static void Main()
    {
        Console.WriteLine(Add(1,2)); // 调用第一个Add
        Console.WriteLine(Add(1,2,3)); // 调用第二个Add
        Console.WriteLine(Add(1.5, 2.5)); // 调用第三个Add
    }
}

八、总结

本文梳理了 C# 入门核心基础：程序结构、数据类型、变量常量、运算符、流程控制、方法，这些是编写 C# 程序的基石。后续可进一步学习面向对象（封装、继承、多态）、集合、异常处理等进阶知识点。

建议结合示例代码动手实操，理解每一个知识点的底层逻辑，而非死记硬背。如果本文对你有帮助，欢迎点赞收藏，后续会持续更新 C# 进阶内容～

补充说明：本文适用于 C# 零基础入门者，基于.NET 6/7 环境编写，代码可直接在 Visual Studio/VS Code 中运行。