#### 一、命名空间与程序结构相关
#### 1. `namespace`
- **定义**:用于声明命名空间,是组织代码的容器。
- **作用**:解决类、方法等成员的命名冲突,将相关代码归类(如按模块、功能划分)。
- **语法**:`namespace 命名空间名 { /* 代码 */ }`
- 示例
```csharp
namespace MyApp.DataAccess { // 数据访问层命名空间
public class UserRepository { /* 数据库操作代码 */ }
}
```
- **注意**:命名空间可嵌套(如`namespace A.B.C`),访问时需用完整路径(或`using`导入)。
#### 2. `internal`(访问修饰符)
- **定义**:指定成员(类、方法、字段等)仅在**同一程序集(Assembly)** 内可见。
- **适用场景**:需在项目内部共享,但不对外暴露的代码(如内部工具类)。
- 示例
```csharp
internal class InternalHelper { // 仅当前程序集可访问
internal void DoWork() { /* 内部逻辑 */ }
}
```
#### 3. `class`
- **定义**:用于声明类,是面向对象编程的基本单位,封装数据(字段 / 属性)和行为(方法)。
- **特性**:类是对象的模板,可通过`new`创建实例;支持继承、多态等特性。
- 示例
```csharp
public class Person { // 定义"人"类
public string Name { get; set; } // 属性(数据)
public void SayHello() { Console.WriteLine($"Hello, {Name}"); } // 方法(行为)
}
// 创建实例
Person p = new Person { Name = "张三" };
p.SayHello(); // 输出:Hello, 张三
```
#### 4. `static`
- **定义**:用于修饰类、方法、字段等,标识其为 “静态成员”,属于类本身而非实例。
- 特性
- 静态成员不依赖对象实例,可直接通过`类名.成员`访问;
- 静态类不能实例化,仅包含静态成员(如工具类)。
- 示例
```csharp
public static class MathTool { // 静态类
public static int Add(int a, int b) => a + b; // 静态方法
}
// 调用:无需实例化
int sum = MathTool.Add(2, 3); // 结果:5
```
#### 5. `void`
- **定义**:用于方法返回值声明,表示方法**无返回值**。
- 示例
```csharp
public void PrintMessage() { // 无返回值方法
Console.WriteLine("这是一个void方法");
}
```
#### 6. `const`(常量)
- **定义**:声明编译时常量,值在编译时确定,且**不可修改**。
- 特性
- 必须在声明时初始化;
- 默认静态,可通过`类名.常量名`访问;
- 仅支持值类型(如 int、string 字面量)。
- 示例
```csharp
public class Constants {
public const double Pi = 3.14159; // 编译时确定
public const string AppName = "MyApp";
}
```
#### 7. `readonly`(只读字段)
- **定义**:声明运行时常量,值可在声明时或**构造函数中初始化**,初始化后不可修改。
- 特性
- 支持运行时动态赋值(如从配置文件读取);
- 非静态`readonly`字段依赖实例,静态`readonly`字段属于类。
- 示例
```csharp
public class User {
public readonly string Id; // 实例只读字段
public static readonly string Version; // 静态只读字段
static User() { // 静态构造函数初始化
Version = "1.0.0";
}
public User(string id) { // 实例构造函数初始化
Id = id;
}
}
```
### **二、类型与转换相关**
#### 1. 基本类型(sbyte/byte/int/long 等)
- 定义:C# 内置的值类型,用于存储数值、字符等数据,按范围和精度划分:
- 整数类型:`sbyte`(8 位有符号)、`byte`(8 位无符号)、`short`(16 位)、`int`(32 位)、`long`(64 位)等;
- 浮点类型:`float`(32 位单精度)、`double`(64 位双精度)、`decimal`(高精度 decimal,适合货币);
- 字符类型:`char`(16 位 Unicode 字符)。
- 示例
```csharp
int age = 25; // 整数
double weight = 62.5; // 双精度浮点
decimal price = 99.99m; // 高精度(需加m后缀)
char gender = '男'; // 字符
```
#### 2. `string`
- **定义**:引用类型,用于存储字符串(字符序列),**不可变**(修改时会创建新对象)。
- 核心特性
- 支持`+`拼接(但频繁拼接效率低,推荐`StringBuilder`);
- 可通过索引访问单个字符(如`str[0]`);
- 常用方法见 “字符串处理” 分类。
#### 3. `object`
- **定义**:所有类型的基类(包括值类型、引用类型),任何类型都可隐式转换为`object`。
- 特性:
- 用于存储任意类型数据(如集合中混合存储不同类型);
- 包含`ToString()`、`Equals()`、`GetHashCode()`等基础方法。
- 示例
```csharp
object obj1 = 123; // int隐式转换为object(装箱)
object obj2 = "hello"; // string隐式转换为object
```
#### 4. `var`
- **定义**:隐式类型关键字,编译器根据赋值自动推断变量类型(仅用于局部变量)。
- 特性:
- 简化代码(无需显式声明类型);
- 类型在编译时确定,仍为强类型(非动态)。
- 示例
```csharp
var list = new List<int>(); // 推断为List<int>
var name = "张三"; // 推断为string
```
#### 5. `dynamic`
- **定义**:动态类型,编译时不检查类型,运行时动态解析(类似弱类型)。
- **适用场景**:处理动态数据(如 JSON 反序列化、COM 交互)。
- **注意**:牺牲编译时类型安全,可能导致运行时错误。
- 示例
```csharp
dynamic data = "test";
data = 123; // 运行时允许变更类型
Console.WriteLine(data * 2); // 运行时解析为123*2=246
```
#### 6. 显式类型转换 `(type)`
- **定义**:强制将一种类型转换为另一种类型(需手动指定目标类型)。
- **适用场景**:从大范围类型转为小范围类型(可能丢失数据),如`double`→`int`。
- 示例
```csharp
double x = 3.14;
int y = (int)x; // 显式转换,结果为3(丢失小数部分)
```
### **三、运算符相关**
#### 1. 算术运算符(`+ - * / %`)
- 作用:执行数值计算:
- `+`:加法(或字符串拼接);
- `-`:减法;
- `*`:乘法;
- `/`:除法(整数除法会截断小数);
- `%`:取模(求余数)。
- 示例
```csharp
int a = 10, b = 3;
Console.WriteLine(a / b); // 3(整数除法)
Console.WriteLine(a % b); // 1(10 ÷ 3 余数为1)
```
#### 2. 自增 / 自减(`++ --`)
- 作用:对变量值加 1 或减 1,分前缀(
```
++x
```
)和后缀(
```
x++
```
):
- 前缀:先修改值,再使用;
- 后缀:先使用值,再修改。
- 示例
```csharp
int x = 5;
Console.WriteLine(x++); // 输出5(先使用,后+1),x变为6
Console.WriteLine(++x); // 输出7(先+1,后使用),x变为7
```
#### 3. 赋值与复合赋值(`= += -= *= /= %=`)
- 作用:
- `=`:直接赋值;
- 复合赋值:赋值时同时执行运算(简化代码)。
- 示例
```csharp
int a = 5;
a += 3; // 等价于a = a + 3 → a=8
a *= 2; // 等价于a = a * 2 → a=16
```
#### 4. 关系运算符(`== != > < >= <=`)
- **作用**:比较两个值的关系,返回`bool`(`true`/`false`)。
- 示例
```csharp
int x = 5, y = 10;
bool isGreater = x > y; // false
bool isEqual = x == y; // false
```
#### 5. 逻辑运算符(`&& || !`)
- 作用:组合或反转布尔表达式:
- `&&`(逻辑与):两边都为`true`才返回`true`(短路求值:左边为`false`时右边不执行);
- `||`(逻辑或):至少一边为`true`返回`true`(短路求值:左边为`true`时右边不执行);
- `!`(逻辑非):反转布尔值。
- 示例
```csharp
bool a = true, b = false;
Console.WriteLine(a && b); // false
Console.WriteLine(a || b); // true
Console.WriteLine(!a); // false
```
### **四、流程控制相关**
#### 1. `if / else if / else`
- **作用**:根据条件执行不同代码块。
- 语法
```csharp
if (条件1) { /* 条件1为true时执行 */ }
else if (条件2) { /* 条件1为false、条件2为true时执行 */ }
else { /* 所有条件为false时执行 */ }
```
- 示例
```csharp
int score = 85;
if (score >= 90) Console.WriteLine("优秀");
else if (score >= 60) Console.WriteLine("及格");
else Console.WriteLine("不及格"); // 输出:及格
```
#### 2. `for` 循环
- **作用**:已知循环次数时使用,通过计数器控制循环。
- **语法**:`for (初始化; 条件; 迭代) { /* 循环体 */ }`
- 示例
```csharp
for (int i = 0; i < 3; i++) { // 循环3次
Console.WriteLine(i); // 输出:0、1、2
}
```
#### 3. `while` 循环
- **作用**:条件满足时重复执行循环体(先判断条件,再执行)。
- **语法**:`while (条件) { /* 循环体 */ }`
- 示例
```csharp
int i = 0;
while (i < 3) { // 条件为true时执行
Console.WriteLine(i); // 0、1、2
i++;
}
```
#### 4. `do-while` 循环
- **作用**:至少执行一次循环体,再判断条件(先执行,后判断)。
- **语法**:`do { /* 循环体 */ } while (条件);`
- 示例
```csharp
int i = 3;
do {
Console.WriteLine(i); // 输出3(即使条件不满足,仍执行一次)
i++;
} while (i < 3);
```
#### 5. `foreach` 循环
- **作用**:遍历集合或数组中的每个元素(无需手动控制索引)。
- **语法**:`foreach (元素类型 变量名 in 集合) { /* 循环体 */ }`
- 示例
```csharp
string[] fruits = { "苹果", "香蕉", "橙子" };
foreach (string fruit in fruits) {
Console.WriteLine(fruit); // 依次输出数组元素
}
```
#### 6. `break / continue`
- **`break`**:立即跳出当前循环(不再执行后续迭代);
- **`continue`**:跳过当前迭代的剩余代码,直接进入下一次迭代。
- 示例
```csharp
for (int i = 0; i < 5; i++) {
if (i == 2) break; // 跳出循环
Console.WriteLine(i); // 输出:0、1
}
for (int i = 0; i < 5; i++) {
if (i == 2) continue; // 跳过当前迭代
Console.WriteLine(i); // 输出:0、1、3、4
}
```
### **五、字符串处理相关**
#### 1. `string.Format`
- **定义**:将变量、数值等插入字符串的指定位置,生成格式化字符串。
- 参数:
- 第一个参数:格式字符串(含占位符`{0}, {1}...`);
- 后续参数:替换占位符的实际值。
- **返回值**:格式化后的新字符串。
- 示例
```csharp
string name = "张三";
int age = 20;
string msg = string.Format("姓名:{0},年龄:{1}", name, age);
// 结果:"姓名:张三,年龄:20"
```
#### 2. `string.Equals`
- **定义**:比较两个字符串的**内容**是否完全一致(区分大小写)。
- **参数**:两个待比较的字符串。
- **返回值**:`bool`(`true`表示内容相同)。
- 示例
```csharp
bool isSame = string.Equals("abc", "ABC"); // false(区分大小写)
bool isSame2 = string.Equals("abc", "abc"); // true
```
#### 3. `string.IndexOf`
- **定义**:查找子字符串或字符在当前字符串中**首次出现的索引**(从 0 开始)。
- **参数**:待查找的子串或字符。
- **返回值**:索引(`int`),未找到返回`-1`。
- 示例
```csharp
string str = "hello world";
int index = str.IndexOf("world"); // 6("world"从索引6开始)
int notFound = str.IndexOf("xyz"); // -1
```
#### 4. `string.Contains`
- **定义**:判断当前字符串是否**包含指定子字符串**。
- **参数**:待查找的子串。
- **返回值**:`bool`(`true`表示包含)。
- 示例
```csharp
bool hasHello = "hello world".Contains("hello"); // true
bool hasAbc = "hello world".Contains("abc"); // false
```
#### 5. `string.Replace`
- **定义**:将字符串中所有指定的 “旧子串” 替换为 “新子串”,返回新字符串(原字符串不变,因 string 不可变)。
- **参数**:旧子串、新子串。
- **返回值**:替换后的新字符串。
- 示例
```csharp
string str = "hello world";
string newStr = str.Replace("world", "C#"); // 结果:"hello C#"
```
#### 6. `string.ToUpper / ToLower`
- **定义**:将字符串转换为全大写(`ToUpper`)或全小写(`ToLower`)。
- **返回值**:转换后的新字符串。
- 示例
```csharp
string str = "Hello World";
string upper = str.ToUpper(); // "HELLO WORLD"
string lower = str.ToLower(); // "hello world"
```
#### 7. `StringBuilder`
- **定义**:`System.Text`命名空间下的可变字符串类,用于高效拼接、修改字符串(避免`string`不可变导致的性能损耗)。
- 核心方法:
- `Append(str)`:追加内容;
- `Insert(index, str)`:在指定索引插入内容;
- `ToString()`:转换为`string`类型。
- 示例
```csharp
var sb = new StringBuilder();
sb.Append("a");
sb.Append("b");
sb.Insert(0, "prefix_"); // 在开头插入
string result = sb.ToString(); // "prefix_ab"
```
### **六、数组与集合相关**
#### 1. 数组方法(`Array.Sort / Reverse / IndexOf / Clear`)
- **`Array.Sort`**:对数组元素排序(默认升序)。
```csharp
int[] arr = {3, 1, 2};
Array.Sort(arr); // 结果:{1, 2, 3}
```
- **`Array.Reverse`**:反转数组元素顺序。
```csharp
int[] arr = {1, 2, 3};
Array.Reverse(arr); // 结果:{3, 2, 1}
```
- **`Array.IndexOf`**:查找元素在数组中首次出现的索引(未找到返回`-1`)。
```csharp
int[] arr = {1, 2, 3};
int index = Array.IndexOf(arr, 2); // 1
```
- **`Array.Clear`**:清空数组元素(设置为默认值,如`0`、`null`)。
```csharp
int[] arr = {1, 2, 3};
Array.Clear(arr, 0, arr.Length); // 结果:{0, 0, 0}
```
#### 2. 数组条件查找(`Array.Find / FindAll / Exists`)
- **`Array.Find`**:返回数组中**第一个满足条件**的元素。
```csharp
int[] nums = {1, 2, 3, 4};
int firstEven = Array.Find(nums, x => x % 2 == 0); // 2
```
- **`Array.FindAll`**:返回数组中**所有满足条件**的元素(数组)。
```csharp
int[] evens = Array.FindAll(nums, x => x % 2 == 0); // {2, 4}
```
- **`Array.Exists`**:判断数组中**是否存在满足条件**的元素(返回`bool`)。
```csharp
bool hasOdd = Array.Exists(nums, x => x % 2 != 0); // true
```
#### 3. `List`(泛型列表)
- **定义**:动态大小的泛型集合,支持自动扩容,比数组更灵活。
- 核心方法:
- `Add(item)`:添加元素;
- `Remove(item)`:移除指定元素;
- `Insert(index, item)`:在指定位置插入元素;
- `Contains(item)`:判断是否包含元素;
- `Count`:获取元素数量。
- 示例
```csharp
var list = new List<string>();
list.Add("苹果");
list.Add("香蕉");
list.Remove("苹果"); // 结果:{"香蕉"}
```
#### 4. `Dictionary`(字典)
- **定义**:键值对集合,通过键(`TKey`)快速查找值(`TValue`),键唯一。
- 核心方法:
- `Add(key, value)`:添加键值对;
- `Remove(key)`:移除指定键的键值对;
- `ContainsKey(key)`:判断键是否存在;
- `TryGetValue(key, out value)`:安全获取值(避免键不存在时抛异常)。
- 示例
```csharp
var dict = new Dictionary<int, string>();
dict.Add(1, "苹果");
dict.Add(2, "香蕉");
string fruit = dict[1]; // "苹果"
bool hasKey = dict.ContainsKey(3); // false
```
#### 5. `ArrayList`(非泛型动态数组)
- **定义**:可存储任意类型元素的动态数组(非泛型,需手动类型转换)。
- **核心方法**:与`List`类似(`Add`、`Remove`、`Insert`等),但元素类型为`object`。
- **注意**:因非泛型,存在装箱 / 拆箱开销,推荐优先使用`List`。
- 示例
```csharp
var list = new ArrayList();
list.Add(123); // 装箱(int→object)
list.Add("hello");
int num = (int)list[0]; // 拆箱(object→int)
```
### **七、面向对象相关**
#### 1. 访问修饰符(`public / private / protected / internal`)
- **`public`**:全局可见(任何位置可访问);
- **`private`**:仅当前类内部可见;
- **`protected`**:当前类及派生类可见;
- **`internal`**:同一程序集可见。
- 示例
```csharp
public class Person {
public string Name; // 全局可见
private int age; // 仅Person类内部可见
protected string Id; // Person及派生类可见
}
```
#### 2. `this` 关键字
- 定义:指代当前类的实例对象,用于:
- 区分同名的字段和参数;
- 调用当前类的其他构造函数(`this(参数)`);
- 作为参数传递当前实例。
- 示例
```csharp
public class Car {
private string name;
public Car(string name) {
this.name = name; // 区分字段和参数
}
public void Print() {
Console.WriteLine(this.name); // 访问当前实例的字段
}
}
```
#### 3. `base` 关键字
- 定义:指代当前类的基类(父类)实例,用于:
- 调用父类的构造函数(`base(参数)`);
- 访问父类的成员(方法、属性等)。
- 示例
```csharp
public class Animal {
public void Eat() { Console.WriteLine("动物进食"); }
}
public class Dog : Animal {
public void Eat(string food) {
base.Eat(); // 调用父类的Eat方法
Console.WriteLine($"狗吃{food}");
}
}
```
#### 4. `virtual / override`(虚方法与重写)
- **`virtual`**:在父类中标记方法为 “可被重写”;
- **`override`**:在子类中重写父类的虚方法,实现多态。
- 示例
```csharp
public class Animal {
public virtual void MakeSound() { Console.WriteLine("动物叫"); }
}
public class Dog : Animal {
public override void MakeSound() { Console.WriteLine("汪汪叫"); } // 重写
}
// 多态调用
Animal animal = new Dog();
animal.MakeSound(); // 输出:汪汪叫(运行时调用子类重写的方法)
```
#### 5. `abstract`(抽象类 / 方法)
- **抽象类**:用`abstract`修饰,不能实例化,可包含抽象方法和具体方法;
- **抽象方法**:用`abstract`修饰,无方法体,强制子类实现。
- 示例
```csharp
public abstract class Shape { // 抽象类
public abstract double GetArea(); // 抽象方法(无实现)
}
public class Circle : Shape {
public double Radius;
public override double GetArea() { // 必须实现抽象方法
return Math.PI * Radius * Radius;
}
}
```
#### 6. `sealed`(密封)
- 作用:
- 修饰类:禁止被继承;
- 修饰方法:禁止子类重写(需配合`override`使用)。
- 示例
```csharp
public sealed class SealedClass { } // 不能被继承
public class Base {
public virtual void DoWork() { }
}
public class Derived : Base {
public sealed override void DoWork() { } // 禁止子类重写
}
```
### **八、委托与事件相关**
#### 1. `delegate`(委托)
- **定义**:引用类型,封装具有相同签名的方法(类似 “函数指针”,但类型安全)。
- **作用**:将方法作为参数传递,实现回调、事件等。
- 示例
```csharp
// 声明委托类型(无返回值,接受string参数)
delegate void PrintDelegate(string msg);
// 定义匹配签名的方法
static void Print(string s) { Console.WriteLine(s); }
// 委托绑定方法并调用
PrintDelegate print = Print;
print("Hello 委托"); // 输出:Hello 委托
```
#### 2. 系统委托(`Action / Func / Predicate`)
- **`Action`**:无返回值的委托(支持 0-16 个参数)。
```csharp
Action<string> log = (msg) => Console.WriteLine(msg);
log("日志信息");
```
- **`Func`**:有返回值的委托(最后一个泛型参数为返回类型)。
```csharp
Func<int, int, int> add = (a, b) => a + b;
int sum = add(2, 3); // 5
```
- **`Predicate`**:返回`bool`的委托(用于条件判断)。
```csharp
Predicate<int> isEven = x => x % 2 == 0;
bool result = isEven(4); // true
```
#### 3. 多播委托(`+= / -=`)
- **定义**:一个委托实例可绑定多个方法(通过`+=`添加,`-=`移除),调用时按顺序执行所有方法。
- 示例
```csharp
Action action = () => Console.Write("A");
action += () => Console.Write("B"); // 添加第二个方法
action(); // 输出:AB
action -= () => Console.Write("A"); // 移除第一个方法
action(); // 输出:B
```
#### 4. `event`(事件)
- **定义**:基于委托的封装,用于发布 - 订阅模式(如按钮点击事件)。
- **特性**:仅允许通过`+=`订阅、`-=`取消订阅,禁止外部直接调用。
- 示例
```csharp
public class Button {
public event Action OnClick; // 声明事件
public void Click() {
OnClick?.Invoke(); // 触发事件(安全调用)
}
}
// 订阅事件
var btn = new Button();
btn.OnClick += () => Console.WriteLine("按钮被点击");
btn.Click(); // 输出:按钮被点击
```
### **九、异步与并发相关**
#### 1. `async / await`
- **`async`**:修饰方法,标记其包含异步操作(返回`Task`/`Task`);
- **`await`**:等待异步操作完成,不阻塞当前线程(仅在`async`方法中使用)。
- 示例
```csharp
public async Task<int> GetDataAsync() {
// 模拟耗时操作(如网络请求)
return await Task.Run(() => {
Thread.Sleep(1000); // 模拟耗时
return 100;
});
}
// 调用
int result = await GetDataAsync(); // 等待结果,不阻塞主线程
```
#### 2. `Task`
- **定义**:表示异步操作的单元,用于替代传统的`Thread`,更高效。
- 核心方法
:
- `Task.Run(action)`:在线程池执行异步操作;
- `Wait()`:阻塞等待任务完成;
- `Result`:获取返回值(阻塞);
- `ContinueWith()`:任务完成后执行后续操作。
- 示例
```csharp
Task<int> task = Task.Run(() => 1 + 2);
task.ContinueWith(t => Console.WriteLine(t.Result)); // 输出3
```
#### 3. `lock`
- **定义**:确保同一时间只有一个线程执行锁定块内的代码,解决多线程共享资源竞争问题。
- 示例
```csharp
private int count = 0;
private object lockObj = new object(); // 锁对象
void Increment() {
lock (lockObj) { // 锁定,确保线程安全
count++;
}
}
```
### **十、文件操作相关**
#### 1. `File` 类方法(`Create / WriteAllText / ReadAllText`)
- **`File.Create(path)`**:创建文件,返回`FileStream`(需手动关闭或用`using`)。
- **`File.WriteAllText(path, content)`**:一次性写入文本(自动创建文件,覆盖原有内容)。
- **`File.ReadAllText(path)`**:一次性读取文件所有文本。
- 示例
```csharp
string path = "test.txt";
File.WriteAllText(path, "Hello File"); // 写入
string content = File.ReadAllText(path); // 读取:"Hello File"
```
#### 2. `StreamReader / StreamWriter`
- **`StreamReader`**:读取文本文件(支持逐行读取)。
```csharp
using (var sr = new StreamReader("test.txt")) {
string line;
while ((line = sr.ReadLine()) != null) { // 逐行读取
Console.WriteLine(line);
}
}
```
- **`StreamWriter`**:写入文本文件(支持追加)。
```csharp
using (var sw = new StreamWriter("test.txt", true)) { // true:追加模式
sw.WriteLine("追加一行");
}
```
#### 3. `Path.Combine`
- **定义**:安全拼接路径(自动处理不同系统的路径分隔符,如`\`或`/`)。
- 示例
```csharp
string path = Path.Combine("C:", "Users", "test.txt");
// Windows:"C:\Users\test.txt";Linux:"C:/Users/test.txt"
```