本文深入探讨了C#中的值类型与引用类型区别、装箱与拆箱过程、String与StringBuilder使用场景、泛型的优势与内部机制、委托与Lambda表达式等高级特性，帮助开发者更好地理解和运用这些概念。
一、 值类型和引用类型的区别
| 值类型 | 引用类型 |
| 1. 直接包含值，变量引用的位置就是值在内存中实际存储的位置。 | 存储是对一个内存位置的引用（内存地址），要去那个位置才能找到真正的数据 |
| 2. 数据存储在栈的内存区域中 | 数据存储在堆的内存区域 |
| 3. 在编译时确定内存量 | 在运行时，从变量中读取内存地址，然后到指定内存地址中读取数据。 |
| 4. 复制数据的一个副本 | 只复制数据的地址 |
| 5. 将new用于值类型，会使用默认值初始化内存 | new，调用构造函数生成一个对象（实例） |
二、 装箱与拆箱
1. 装箱：将一个值类型转换成一个引用类型
1） 首先在堆中分配好内存；
2） 一次内存复制：栈上的值类型数据复制到堆上分配好的位置；
3） 对象或接口引用得到更新，指向堆上的位置。
2. 拆箱：将一个引用类型转换为值类型
3. 装箱频繁发生，会大幅影响性能；
4. 不允许在lock()语句中使用值类型。
三、 String 与StringBuilder
1. String 对象称为不可变的（只读），因为一旦创建了该对象，就不能修改该对象的值
2. StringBuilder此类表示值为可变字符序列的类似字符串的对象
3. String 对象串联操作总是用现有字符串和新数据创建新的对象。StringBuilder 对象维护一个缓冲区，以便容纳新数据的串联。如果有足够的空间，新数据将被追加到缓冲区的末尾；否则，将分配一个新的、更大的缓冲区，原始缓冲区中的数据被复制到新的缓冲区，然后将新数据追加到新的缓冲区。
4. String 或 StringBuilder 对象的串联操作的性能取决于内存分配的发生频率。String 串联操作每次都分配内存，而 StringBuilder 串联操作仅当 StringBuilder 对象缓冲区太小而无法容纳新数据时才分配内存。因此，如果串联固定数量的 String 对象，则 String 类更适合串联操作。这种情况下，编译器甚至会将各个串联操作组合到一个操作中。如果串联任意数量的字符串，则 StringBuilder 对象更适合串联操作；例如，某个循环对用户输入的任意数量的字符串进行串联。
四、 ? 和 ??的使用
1. 可空修饰符 ?：为了声明可以存null的值类型变量。int ?x=null;
2. 使用 ?? 运算符分配默认值：expression1??expression2.检查第一个表达式是否为null，如果为null，则返回第二个表达式。
3. 当前值为空的可以为 null 的类型被赋值给非空类型时将应用该默认值，如 int? x = null; int y = x ?? -1;。
三、const和readonly
1. const：
1） 既然用于修饰字段,又可以修饰局部变量;
2） 是在编译时确定的值，不可以在运行时改变；
3） 自动成为静态字段，不能显式声明为static
2. readonly：
1） 只能用于字段（不能用于局部变量），
2） 指出字段值只能从构造函数中更改，或者直接在声明时指定。——可以在运行时赋值;
3） readony字段既可以是实例字段,也可以是静态字段.
四、静态成员和实例成员
1. 静态字段：主要存储的是对于类的数据，能由多个实例共享，需要使用static关键字
2. 实例字段：存储的是与对象关联的数据，只能从类的一个实例（对象）中访问实例字段。
3. 静态方法：不能直接访问一个类中的实例字段，必须获取类的一个实例，才能调用任一实例成员（方法或字段）。
4. 实例方法：将需要访问实例数据的方法声明为实例方法。
5. 静态构造函数：用来对类（而不是类实例）进行初始化。
运行时会在“访问类的一个静态方法或者字段时”自动调用静态构造函数。
6. 静态类：不包含任何实例字段（或方法），声明时用static 关键字。不能被实例化，不能被继承。
五、 继承：对一个现有的类型进行扩展，以包含附加的成员或实现对基类成员的定制。
1． protected 访问修饰符： 在基类中定义只有派生类才能访问的成员。
规则：要从一个派生类中访问一个受保护的成员，必须在编译时确定受保护的成员是派生类（或者它的某个子类）的一个实例。
2． C#是一种单一继承的语言，一个类不能直接从两个类派生。
3． 可以使用聚合解决多重继承的问题
4． 使用sealed修饰符，实现密封类（不能被继承）
5． C#支持重写实例方法和属性，但不支持重写字段或者任何静态成员。
1） 在基类中使用virtual修饰符标记每一个需要重写的成员，
2） 在派生类中，用override进行修饰。C#要求重写方法显式地使用override关键字。
3） 重写一个成员时，会造成“运行时”调用派生得最远的实现。
4） new 修饰符：在基类面前隐藏了派生类的重新声明的成员。
6． 抽象类：
1） 仅供派生的类，不能被实例化。
2） 包含抽象成员：不具有实现的一个方法或属性，强制所有派生类提供实现。
7． 多态性：同一个签名可以有多个实现。
1） 抽象成员是实现多态性的一个手段：基类指定方法的签名，派生类提供具体的实现；
2） 可以利用多态性：调用基类的方法，当方法具体由派生类实现。
8． is 和as运算符
1） is运算符验证基础类型
2） 使用as运算符进行转换：将对象转换为一个特定的数据类型，若源类型不是固有的目标类型，as运算符会将null值赋给目标。
六、 接口
1. 对接口的理解：
1）接口定义了一系列成员，不包含任何实现，由继承该接口的类实现；
2）接口实现关系是一个“能做”关系：类“能做”接口要求的事情；
3）接口定义了一个“契约”：实现接口的类会使用与被实现的接口相同的签名来定义方法。
4） 接口的宗旨是：定义由多个类共同遵守的一个契约，所有成员都自动定义为public。
5） C#不允许为接口成员使用访问修饰符。
6） 通过接口可以实现多态性；
7） 不能被实例化，不能使用new关键字来创建一个接口。
2. 接口实现：
1） 一个类只能从一个基类派生，但可以实现多个接口；
2） 显式实现： 为了声明一个显式接口成员实现，需要在成员名之前附加接口名前缀。
String[] IListable.ColumnValues
{
…….
}
通过接口本身来调用它——将对象转型为接口；
Values=((IListable)contact1).Columnvalues
3） 隐式实现：类成员的签名与接口成员的签名相符。
调用时不需要转型，可以直接调用。
4） 成员若是核心的类功能，则隐式实现；
5） 假如一个成员的用途在实现类中不是很明确，就考虑使用一个显式的实现；
6） 已经有一个同名的类成员，则可以使用显式实现。
3. 接口继承：
1） 一个接口可以从另一个接口派生，派生的接口将继承“基接口”的所有成员；
2） 在用于显式接口成员实现的一个完全限定的接口成员名称中，必须引用最初声明它的那个接口的名称；
3） 继承：接口代表一份契约，而一份契约可指定另一份契约也必须遵守的条款。
4） 通过接口可以实现多重继承。
4. 接口与类的比较
| 抽象类 | 接口 |
| 仅供派生的类，不能被实例化 | 不能实例化 |
| 定义了基类必须实现的抽象成员签名 | 接口的所有成员要在基类中实现 |
| 可以包含存储在字段中的数据 | 不能存储任何数据。只能在派生类中指定字段。解决这个问题的办法，是在接口中定义属性，但不能包括实现。 |
| 扩展性比接口好，不会破坏任何版本兼容性。在抽象类中，你可以添加附加的非抽象成员，它们可以由所有派生类继承 | 用更多的成员来扩展接口，会破坏版本兼容性。（只能再创建一个接口，该接口可以从原始接口派生） |
七、 重写Equals()
1. “对象同一性”和“相等的对象值”
1） 对象同一性：两个引用，引用的是同一个实例；
2） 相等的对象值：两个引用，引用不同的实例，但两个对象实例值是相等的。
3） 只有引用类型才可能引用相等，值类型不可能引用相等（ReferenceEquals()对值类型进行了装箱，由于每一个实参都被装到栈上的不同位置）。
2. 实现Equals()：
1） 检查是否为null；
2） 如果是引用类型，就检查引用是否相等；（ReferenceEquals()方法来判断引用是否相等）
3） 检查数据类型是否相等；
4） 调用一个指定了具体类型的辅助方法，它能将操作数视为要比较的类型，而不是一个对象；
5） 可能要检查散列码是否相等。（相等的两个对象，不可能散列码不同）
6） 如果基类重写了Equals()，就检查base.Equals()；
7） 比较每一个标识字段，判断是否相等；
8） 重写GetHashCode()。
9） 重写==和!=运算符。
八、 垃圾回收与资源清理
1. 垃圾回收 内存
1） “运行时”的一个核心功能：回收不再被引用的对象所占用的内存。
2） 垃圾回收器只负责回收内存，不处理其他资源，比如数据库连接、句柄（文件、窗口等）、网络端口以及硬件设备（比如串口）等；
3） 垃圾回收器处理的是引用对象，而且只回收堆上的内存；
2. 终结器 释放资源
1） 终结器：允许程序员编写代码来清理一个类的资源；
2） 由垃圾回收器负责为一个对象实例调用终结器；
3） 终结器会在上一次使用对象之后，并在应用程序关闭之前的某个时间运行。
4） 终结器不允许传递任何参数，不能被重载，不能被显式调用，不允许使用访问修饰符；
5） 终结器负责释放像数据库连接和文件句柄这样的资源，不负责回收内存（回收内存是由垃圾回收器完成）
6） 避免在终结器中出现异常，比如采用空值检查。
3. 使用using语句进行确定性终结：
1） IDisposable接口用一个名为Dispose()的方法释放当前消耗的资源；
2） using语句在对象离开作用域时自动调用Dispose()方法释放资源。
4. 垃圾回收和终结
1） f-reachable队列（终结队列）：是准备好进行垃圾回收，同时实现终结的所有对象的一个列表；
2） 假如一个对象有终结器，那么“运行时”只有在对象的终结方法被调用之后，才能对这个对象执行垃圾回收；
3） f-reachable队列是一个“引用”列表，一个对象只有在它的终结方法得到调用，而且对象引用从f-reachable队列中删除之后，才会成为“垃圾”。
九、 泛型
1. 泛型类型概述：
1） 利用泛型，可以在声明变量时创建用来处理特定类型的特殊数据结构；
2） 参数化类型，使特定泛型类型的每个变量都有相同的内部算法；
3） 声明泛型类：
public class Stack<T>
{
private T[] _Items;
public void Push(T data)
{
….
}
Public T Pop()
{
…
}
}
2. 泛型的优点：
1） 提供了一个强类型的编程模型：确保在参数化的类中，只有成员明确希望的数据类型才可以使用；
2） 为泛型类成员使用值类型，不再造成到object的强制转换，它们不再需要装箱操作；
3） 性能得到了提高：不再需要从object的强制转换，从而避免了类型检查；不再需要为值类型执行装箱操作
4） 由于避免了装箱，因此减少了堆上的内存的消耗；
3. 泛型接口：
1） 声明一个泛型接口：
Interface IPair<T>
{
T First {get;set;}
T Second {get;set}
}
2） 使用泛型接口，就可以避免执行转型，因为参数化的接口能实现更强的编译时绑定；
3） 在一个类中多次实现相同的接口：可以使用不同的类型参数来多次实现同一个接口。
4. 多个类型参数：
1） 泛型类型可以使用任意数量的类型参数；
2） 声明：
Interface IPair<TFirst,TSecond>
{
TFirst First {get;set;}
TSecond Second {get;set}
}
Public struct Pair<TFirst,TSecond>:IPair<TFirst,TSecond>
{
Public Pair(TFirst first,TSecond second)
{
_First=first;
_Second=second;
}
.
.
.
.
}
5. 约束
1） 泛型允许为类型参数定义约束。这些约束强迫类型遵守各种规则；
2） 约束声明了泛型要求的类型参数的特征。
3） 为了声明一个约束，需要使用where关键字，后跟一对“参数：要求”；其中，“参数”必须是泛型类型中定义的一个参数，而“要求”用于限制类型从中派生的类或接口，或者限制必须存在一个默认构造器，或者限制使用一个引用/值类型约束。
4） 接口约束：为了规定某个数据类型是必须实现某个接口，需要声明一个接口约束。不需要执行转型，就可以调用一个显式的接口成员实现。
声明一个接口约束：
public class BinaryTree<T>
where T:System.IComparable<T>
{
…
Public Pair<BinaryTree<T>> SubItems
{
get{return _SubItems;}
set
{
IComparable<T> first;
First=value.First.Item;
…..
}
}
}
5） 基类约束：将构建的类型限制为一个特定的类派生。
6） struct约束：将类型参数限制为一个值类型；
7） class约束：将类型参数限制为一个引用类型。
8） 多个约束：对于任何给定的类型参数，都可以指定任意数量的接口作为约束，但基类约束只能指定一个，因为一个类可以实现任意数量的接口，但肯定只能从一个类继承。
public class EntityDictionary<Tkey,Tvalue>
: Dictionary<TKey,TValue>
where TKey: IComparable<TKey>,IFormattable //多个约束接口
where TValue: EntityBase //一个基类约束
{
…
}
9） 构造器约束：可以在指定了其他所有约束之后添加new() ，指定类型参数必须有一个默认构造器。
10） 继承约束：约束可以由一个派生类继承，但必须在派生类中显式地指定这些约束。
6. 泛型方法
1） 即使包容类不是泛型类，或者方法包含的类型参数不在泛型类的类型参数列表中，也依然使用泛型的方法；
2） 为了定义泛型方法，需要紧接在方法名之后添加类型参数语法；
7. 协变性和逆变性
1） 协变性：将一个较具体的类型赋给较泛化的类型。
2） 逆变性：将较泛化的类型赋给较具体的类型；
3） 在C#4.0中使用out类型参数修饰符允许协变性；
4） 在C#4.0中使用int类型参数修饰符允许逆变性；
8. 泛型的内部机制：
1） 基于值类型的泛型的实例化：“运行时”会为每个新的参数值类型创建新的具体化泛型类型。
2） 基于引用类型的泛型的实例化：使用一个引用类型作为类型参数来首次构造一个泛型类型时，“运行时”会创建一个具体化的泛型类型，并在CIL代码中用object引用替换类型参数。以后，“运行时”都会重用以前生成好的泛型类型的版本——即使新的引用类型与第一次使用的引用类型不同。
十、 委托、Lambda表达式
1. 委托：将方法作为对象封装起来，允许在“运行时”间接地绑定一个方法调用；
2. 所有委托类型都间接从System.Delegate派生，但System.Delegate不能显式的成为一个基类；
3. 声明委托数据类型：
Public delegate bool ComparisonHandler(int first,int second);
4. 实例化委托：需要和委托类型自身的签名对应的一个方法（相同的参数及参数类型、相同的返回值）；
class DelegateSample
{
public delegate bool ComparisonHanlder(int first, int second);
public static void BubbleSort(int[] items, ComparisonHanlder comparisonMethod)
{
int i, j, temp;
for (i = items.Length - 1; i >= 0; i--)
{
for (j = 1; j <= i; j++)
{
if (comparisonMethod(items[j - 1], items[j]))
{
temp = items[j - 1];
items[j - 1] = items[j];
items[j] = temp;
}
}
}
}
public static bool GreaterThan(int first, int second)
{
return first > second;
}
static void Main(string[] args)
{
int i;
int[] items = new int[5];
for (i = 0; i < items.Length; i++)
{
Console.Write("Enter an integer:");
items[i] = int.Parse(Console.ReadLine());
}
BubbleSort(items, GreaterThan);
for (i = 0; i < items.Length; i++)
{
Console.WriteLine(items[i]);
}
}
}
5. 匿名方法：
1） 所谓匿名方法，就是没有实际方法声明的委托实例，它们的定义是直接内嵌在代码中；
2） BubbleSort(items,
delegate(int first,int second)
{
return first>second;
}
);
6. 系统定义的委托：Func<>
1） 在C#3.0中，存在一系列名为“Action”和“Func”的泛型委托；
2） System.Action代表无返回类型的委托；
3） System.Func代表有返回类型的委托；
4） Func的最后一个类型参数总是委托的返回类型，在它之前的类型参数则依次对应于委托参数的类型；
5） 可以用一个Func泛型委托来代替一个显式定义的委托。ComparisonHandler可以用Func<int,int,bool>来代替
7. Lambda表达式
1） Lambda表达式分为：语句Lambda和表达式Lambda；
2） Lambda运算符 =>，可以理解成“用于”；
3） 使用语句Lambda来传递委托：
BubbleSort(items,
(int first,int second) =>
{
return first>second;
}
);
4） C#要求用一对圆括号来封闭Lambda表达式的参数列表，不管是否指定了这些参数的数据类型；
5） 当编译器能判断出数据类型，而且只有一个输入参数的时候，语句Lambda可以带圆括号；
IEnumerable<Process> processes=Process.GetProcesses().Where(process=>{return process.WorkingSet64>2^30;});
6） 语句Lambda含有一个语句块，所以可以包含零个或者更多的语句，而表达式Lambda只有一个表达式，没有语句块；此时将Lambda运算符理解成“满足……条件”；
BubbleSort(items,(first,second)=>first<second);
//理解成first和second满足first小于second的条件
7） Lambda表达式（和匿名方法）并非CLR内部的固有构造，它们的实现是由C#编译器在编译时生成的。
8） persons.Where(person=>person.Name.ToUpper()==”INIGO MONTOYA”);
假定persons是一个Person数组，编译器将Lambda表达式编译成一个Func<person,bool>委托类型，然后将委托实例传给Where()方法。
9） 表达式树：如果一种Lambda表达式代表的是与表达式有关的数据，而不是编译好的代码，这种Lambda表达式就是“表达式树”；
10） 表达式树转换成的数据是一个对象图，它由System.Linq.Expressions.Expression表示。
11） Lambda表达式和表达式树的比较：
表达式的语法都会在编译时进行完整的语义分析验证；但是，Lambda表达式在CIL中被编译成一个委托，而表达式树被编译成System.Linq.Expressions.Expression类型的一个数据结构。
扫一扫
108
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
