csharp总结

1.C＃中的域（field）和属性（property）

域（field）

－域表示与对象或类相关联的变量。

－域的声明中如果加上了readonly修饰符，表明该域为只读域。对于只读域我们只能在域的定义中和它所属类的构造函数中进行修改。在其他情况下，域是“只读”的。

－static readonly的作用和#define、const的作用类似。区别是：const型表达式的值是在编译时形成的，而static readonly表达式的值直到程序运行时才形成

属性（property）

－充分体现了对象的封装性：不直接操作类的数据内容，而是通过访问器进行访问，即借助于get和set对属性的值进行读写；另一方面还可以对数据的访问属性进行控制（当然也可以通过对普通域加readonly关键字来实现。

－设计原则：属性封装了对域的操作。把要访问的域设为private，通过属性中的get和set 操作对域进行设置或访问。

－不能把属性作为引用类型或输出参数来进行传递。

－get方法没有参数；set方法有一个隐含的参数value。除了使用了abstract修饰符的抽象属性，每个访问器的执行体中只有分号“；”外，其他的所有属性的get访问器都通过return 来读取属性的值，set访问器都通过value来设置属性的值。

－采用间接方式来访问对象的属性（间接调用get、set方法）：对象.属性＝值（调用set），变量＝对象.属性（调用get）。

－在属性的访问声明中：

只有set访问器，表明该属性是只写的。

只有get访问器，表明该属性是只读的。

既有set访问器，又有get访问器，表明该属性是可读可写的。

2.partial

c#2.0引入了局部类型的概念。局部类型允许我们将一个类、接口或结构分成好几个部分，分别实现在几个不同的.cs文件中。

局部类型适用于以下情况：

（1）类型特别大，不宜放在一个文件中实现。

（2）一个类型中的一部分代码为自动化工具生成的代码，不宜与我们自己编写的代码混合在一起。

（3）需要多人合作编写一个类。例如

public partial class Program

{

static void Main(string[] args)

{

}

}

partial class Program

{

public void Test()

{

}

}

3.C# 支持两种类型：

value 类型和reference 类型。Value 类型包括简单类型(如：char,int和float)、enum类型和struct类型。Reference 类型包括class 类型、interface 类型、delegate 类型和array 类型。Value 类型和reference 类型的不同之处在于value 类型的变量直接存储它们的数据，然而reference 类型的变量存储对象的指针。

Reference 参数用于“by reference”参数的传递，在其中参数的作用是充当调用参数的别名

ref 关键字在正式参数声明和使用中是必需的。在调用处使用ref 可以引起开发人员对该参数的注意，使得开发人员知道调用的结果可以改变参数的值。

static void Swap(ref int a, ref int b)

Output 参数类似于reference 参数，只是调用提供的调用者参数的初始值不再重要。output 参数的声明包括一个out 修饰符。

static void Divide(int a, int b, out intans, out int rem)

params参数允许多对一：单个params参数可以表示多个变量。换句话说，params参数允许多个变量集合。Params参数的声明包括params修饰符。

static void F(paramsint[] args)

F();

F(1);

F(1, 2);

F(1, 2, 3);

F(new int[] {1, 2, 3, 4});

4.as和is

Is关键字用于检查对象是否与给定类型兼容。

引用转换

is作用于对象引用时，将判断被检查对象变量是否是给定类型的派生类型。如果是派生类型，返回true；否则返回false。例如：

List list = new List();

if(list is IEnumerable) //这里将返回true。因为List实现了IEnumerable接口。

{

}

装箱转换

int i = 5;

if(i is Int32) {...} //这里返回true。

if(i is Int16) {...} //这里返回false，因为int类型的包装类型是Int32，而不是Int16。

拆箱转换

Int32 int32 = new Int32();

if(int32 is int) {...} //这里返回true。

if(int32 is long) {...} //这里返回false，因为Int32类型的原始类型是int，而不是long。

as 运算符类似于强制转换操作；但是，如果转换不可行，as 会返回null 而不是引发异常。string s = obj[i] as string;

5.早期绑定和后期绑定

将对象分配给对象变量时，Visual Basic 编译器会执行一个名为binding 的进程。如果将对象分配给声明为特定对象类型的变量，则该对象为“早期绑定”。早期绑定对象允许编译器在应用程序执行前分配内存以及执行其他优化。

相反，如果将对象分配给声明为Object 类型的变量，则该对象为“后期绑定”。这种类型的对象可以存储对任何对象的引用，但没有早期绑定对象的很多优越性。

6.Override与Overload

重写和重载，即cpp中虚函数和重载

1.override: 父类：public virtual string ToString(){return "a";}

子类：public override string ToString(){return "b";}

2.overload: 同一类中或父子关系类中皆可.

public string ToString(){return "a";}

public string ToString(int id){return id.ToString();}

override是用于重写基类的虚方法,这样在派生类中提供一个新的方法；重载是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制

1. override

------------------

使用override 修饰符来修改方法、属性、索引器或事件。重写方法提供从基类继承的成员的新实现。由重写声明重写的方法称为重写基方法。重写基方法必须与重写方法具有相同的签名。

不能重写非虚方法或静态方法。重写基方法必须是虚拟的、抽象的或重写的。

也就是说，用override 修饰符重写的基类中的方法必须是virtual, abstract 或override 方法。

2. 重载(overload)

------------------

当类包含两个名称相同但签名不同的方法时发生方法重载。

使用重载方法的指南:

a. 用方法重载来提供在语义上完成相同功能的不同方法。

b. 使用方法重载而不是允许默认参数。默认参数的版本控制性能不好，因此公共语言规范

(CLS)中不允许使用默认参数。

c. 正确使用默认值。在一个重载方法系列中，复杂方法应当使用参数名来指示从简单方法中假定的默认状态发生的更改。

d. 对方法参数使用一致的排序和命名模式。提供一组重载方法，这组重载方法带有递增数目的参数，以使开发人员可以指定想要的级别的信息，这种情况很常见。您指定的参数越多，开发人员就可指定得越详细。

e. 如果必须提供重写方法的能力，请仅使最完整的重载是虚拟的并根据它来定义其他操作。

下面这个例子代码具体解释一下这种模式，只有最后一个方法(参数最完整的方法)是虚方法，在继承了这个类的子类中只要重写(override)这个方法就行了。

Code

public class SampleClass

{

private string myString;

public void MyClass(string str)

{

this.myString = str;

}

publicintIndexOf(string s)

{

returnIndexOf (s, 0);

}

publicintIndexOf(string s, intstartIndex)

{

returnIndexOf(s, startIndex, myString.Length - startIndex );

}

public virtual intIndexOf(string s, intstartIndex, int count)

{

returnmyString.IndexOf(s, startIndex, count);

}

}

checked 关键字用于对整型算术运算和转换显式启用溢出检查。

foreach遍历整个集合

C#提供了一个关键字lock，它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是几个线程同时执行一个函数，导致数据的混乱，产生不可预料的结果，因此我们必须避免这种情况的发生。

lock（expression）statement_block

expression代表你希望跟踪的对象，通常是对象引用。

如果你想保护一个类的实例，一般地，你可以使用this；如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可以了。

而statement_block就是互斥段的代码，这段代码在一个时刻内只可能被一个线程执行。

事件Events,事件是一个对象或类可以定义的元素。一个类通过事件声明来定义一个事件，和一个域或事件的声明类型。声明的类型必须是一个delegate 类型。

public delegate void EventHandler(object sender, Event e);

public class Button

{

public event EventHandler Click;

public void Reset() {

Click = null;

}

}

7.cpp和c#结构

在c里结构体只能定义数据成员，不能有函数成员，但可以定义函数指针来模拟函数。

在C++，c#中，结构体和类除了默认的访问方式和默认的继承方式不同外，其它都一样。结构体默认是公有，类默认是私有。

C#中，结构的确是不能显式声明无参数的构造函数的，同时它也不能定义析构函数。无参数的构造函数由运行时提供，用于初始化结构的数据成员，结构定义的构造函数必须为结构包含的每个字段赋值。另外，C#中的结构的确是在执行到调用结构成员的时候才会被初始化。然而结构和类有几个重要方法的不同：结构是value 类型而不是reference 类型，并且不支持继承。结构的值存储在“堆栈”“on the stack”或“序列”中“in-line”。细心的程序员可以通过明智地使用结构来提高效率。

struct类型是一种值类型，通常用来封装小型相关变量组，例如，矩形的坐标或库存商品的特征。下面的示例显示了一个简单的结构声明。

publicstructPostalAddress

{

// Fields, properties, methods and events go here...

}

结构与类共享几乎所有相同的语法，但结构比类受到的限制更多：

尽管结构的静态字段可以初始化，结构实例字段声明还是不能使用初始值设定项。

结构不能声明默认构造函数（没有参数的构造函数）或析构函数。

结构的副本由编译器自动创建和销毁，因此不需要使用默认构造函数和析构函数。实际上，编译器通过为所有字段赋予默认值（参见默认值表）来实现默认构造函数。结构不能从类或其他结构继承。

结构是值类型-- 如果从结构创建一个对象并将该对象赋给某个变量，变量则包含结构的全部值。复制包含结构的变量时，将复制所有数据，对新副本所做的任何修改都不会改变旧副本的数据。由于结构不使用引用，因此结构没有标识-- 具有相同数据的两个值类型实例是无法区分的。C# 中的所有值类型本质上都继承自ValueType，后者继承自Object。

编译器可以在一个称为装箱的过程中将值类型转换为引用类型。

结构具有以下特点:

结构是值类型,而类是引用类型

向方法传递结构时.结构是通过传值方式传递的,不是作为引用方式传递.

与类不同,结构的实例化可以不使用new运算符.

结构可以声明构造函数,但他们必须带参数

一个结构不能从另一个结构或类继承，而且不能作为一个类的基。所有结构都直接继承自System.ValueType，后者继承自System.Object。

结构可以实现接口。

在结构中初始化实例字段是错误的。

8.隐式转换和显示转换

int a = 3, double b = 3.14; a + b;则a提升为double类型3.0。为隐式转换

隐式转换常发生的情况：

1,、混合类型的算术表达式（同上）

2、同一类型的表达式赋值给另一种类型的对象

3、表达式传参，调用表达式类型与形参不一致

4、函数返回表达式与返回类型不一致

显示转换又称强制类型转换

如：unsigned int a = 0xfffffff7; //十六进制表示法

unsigned char b = (unsigned char)a; //发生显示类型转换

那么此时b = '0x000000f7'对应的字符

9.implicit和explicit

implicit关键字用于声明隐式的用户定义类型转换运算符。(explicit反之)

static implicit operator target_type { source_type identifier }

隐式转换可以通过消除不必要的类型转换来提高源代码的可读性。但是，因为可以在未指定的情况下发生隐式转换，因此必须注意防止令人不愉快的后果。一般情况下，隐式转换运算符应当从不引发异常并且从不丢失信息，以便可以在不知晓的情况下安全使用它们。如果转换运算符不能满足那些条件，则应将其标记为explicit。

10运算符声明

可以采用下列四种形式之一：

1.publicstatic result-type operator unary-operator ( op-type operand )

2.publicstatic result-type operator binary-operator ( op-type operand,

op-type2 operand2 )

3.publicstaticimplicitoperator conv-type-out ( conv-type-in operand )

4.publicstaticexplicitoperator conv-type-out ( conv-type-in operand )

参数：

1.result-type 运算符的结果类型。

2.unary-operator 下列运算符之一：+ - ! ~ ++ — true false

3.op-type 第一个（或唯一一个）参数的类型。

4.operand 第一个（或唯一一个）参数的名称。

5.binary-operator 其中一个：+ - * / % & | ^ <<>> == != ><>= <=

6.op-type2 第二个参数的类型。

7.operand2 第二个参数的名称。

8.conv-type-out 类型转换运算符的目标类型。

9.conv-type-in 类型转换运算符的输入类型。

例子// User-defined conversion from Digit to double

public static implicit operator double(Digit d)

{

return d.val;

}

// User-defined conversion from double to Digit

public static implicit operator Digit(double d)

{

return new Digit(d);

}

11.C#静态构造函数

静态构造函数是C#的一个新特性，在编程过程中用处并不广，它的主要目的是用于初始化一些静态的变量。

因为这个构造函数是属于类的，而不属于任何一个实例，所以这个构造函数只会被执行一次，而且是在创建此类的第一个实例或引用任何静态成员之前，由.NET自动调用。

12．接口

接口是一种约定。一个实现接口的类或结构必须符合这个约定。接口可以包括方法、属

性、索引和事件元素。一个派生类只能从一个类中继承。但接口可以多继承。

例子

interfaceIExample

{

string this[int index] { get; set; }

eventEventHandler E;

void F(int value);

string P { get; set; }

}

public delegate void EventHandler(object sender, Event e);

中的接口包括一个索引、事件E、方法F 和属性P。

13.代表（delegate）

Delegates 是reference 类型的，从一个共同的基础类System.Delegate派生而来。.

一个delegate 例程封装由一个方法――这是一个可调用的实体。对于例程方法，一个可调用的实体有一个例程和一个例程中的方法构成。对于静态方法，可调用的实体由一个类和类中的一个静态方法构成。

Delegate 的一个有趣而又实用的属性是它不知道或者不关心所指向的对象类型。任何对象都可以；方法的信息也适用于delegate。这使得delegates 非常适合于匿名调用。这是一个很强大的功能。

而事件与驱动函数的对应关系就是通过委托(Delegate)类来关联的。

定义和使用delegate 有三个步骤：声明、实例化和调用。Delegate 声明有其相应的语法。例子

delegate void SimpleDelegate();

声明了一个名为SimpleDelegate的delegate，其中不包括任何变量和返回值。

例子

class Test

{

static void F() {

System.Console.WriteLine("Test.F");

}

static void Main() {

SimpleDelegate d = new SimpleDelegate(F);

d();

}

}

创建了一个SimpleDelegate例程，并马上调用它。

为一个方法创建一个得了delegate 实例并马上通过该delegate 调用并没有多大的实用价值，因为直接调用方法会更加简单。Delegate 在匿名使用的时候有很强的实用性。例子voidMultiCall(SimpleDelegate d, int count) {

for (int i = 0; i < count; i++)

d();

}

}

中有一个MultiCall方法，用于重复调用SimpleDelegate。MultiCall方法不知

道或不关心SimpleDelegate目标方法类型、可调用范围或该方法是静态还是非静

态。它只关心目标方法的信息和SimpleDelegate相符合。

14.列举

列举类型声明为一组相关的符号常数定义了一个类型名称。列举应用于“多种选择”的

场景，从编译时所确定的固定数目选择中决定运行时间。

例子

enum Color

{

Red,

Blue,

Green

}访问方法Color.Red

15.Attribute

对某个属性或者某个类的附加标记（个人理解）

想读取中括号内的Attribute你需要用反射。从某种意义上讲就好像给你的某个属性/类贴了个标签一样。

例如，一个框架framework 定义了一个HelpAttribute属性，可以放置在如类和方法

的程序元素中，使得开发人员提供一个从程序元素到它们说明的映射。例子[AttributeUsage(AttributeTargets.All)]

public class HelpAttribute: System.Attribute

{

publicHelpAttribute(string url) {

this.url = url;

}

public string Topic = null;

private string url;

public string Url {

get { return url; }

}

}

定义了一个名为HelpAttribute（或缩写为Help）属性类，有一个位置参数(字符串

url)和一个命名参数(字符串Topic)。位置参数为属性类的公有构造函数，利用正式参

数定义，命名参数由属性类的公有只读属性定义。

例子

[Help("https://www.360docs.net/doc/e612906503.html,/…/Class1.htm")]

public class Class1

{

[Help("https://www.360docs.net/doc/e612906503.html,/…/Class1.htm", Topic = "F")]

public

16.命名空间和编译文件

命名空间和编译文件使得这个以组件为基础的系统成为可能。命名空间提供了一个逻辑的组织系统。命名空间同时作为内部组织系统和外部组织系统（一种将程序元素开放个其他程序的方法）来使用。

编译文件Assemblies 用于物理封装和配置。编译文件可以作为类型容器。一个编译文件可以包含类型、实现这里类型的可执行代码和指向其他编译文件的引用。

有两种主要的编译文件：应用程序和库。应用程序有一个主入口，并且文件的扩展名通常为.exe；libraries 没有主入口，文件扩展名通常为.dll。

为了说明命名空间和编译文件的使用，将重新考察前面的“Hello, world”程序，并将它分成两个部分：一个library，用于提供消息和一个控制台应用，用于显示。

我们所写的代码可以放入到一个包括类HelloMessage的库和一个包括类helloApp的

应用中。编辑的具体步骤可能会因不同的编译器或工具而有所不同。应用Visual Studio 7.0 中提供的命令行编译器，正确的调用：

csc /target:libraryHelloLibrary.cs

生成了一个类库HelloLibrary.dll，并且

csc /reference:HelloLibrary.dll HelloApp.cs

生成了应用HelloApp.exe。

17.C#反射（见反射）

反射是一种机制,通过这种机制我们可以知道一个未知类型的类型信息.比如,有一个对象a,这个对象不是我们定义的，也许是通过网络捕捉到的，也许是使用泛型定义的，但我们想知道这个对象的类型信息，想知道这个对象有哪些方法或者属性什么的．甚至我们想进一步调用这个对象的方法．关键是现在我们只知道它是一个对象，不知道它的类型，自然不会知道它有哪些方法等信息．这时我们该怎么办？反射机制就是解决这么一个问题的．通过反射机制我们可以知道未知类型对象的类型信息．

再比如，我们有一个dll文件，我们想调用里面的类．现在假设这个dll文件的类的定义，数量等不是固定的，是经常变化的．也许某一天你要在这个dll里面增加一个类定义．也许你觉得这没什么问题，现在关键是我们在另一个程序集里面要调用这个dll，这是我们的程序必须能够适应这个dll的变化，也就是说即使改变了dll文件的定义也不需要改变我们的程序集．这时候我们就会使用一个未知dll．我们该怎么办？同样，反射机制帮助了我们，我们可以通过反射来实现．

18. object类

object类。这个类是其它所有类的基类，其它类型可以直接或间接地从object类中继承。因此，对一个object类的变量可以赋于任何类型的值。

一个派生类只能从一个类中继承。但接口可以多继承。

19.sealed

密封类在声明中使用sealed修饰符，这样就可以防止该类被其它类继承。如果试图将一个密封类作为其它类的基类，C#将提示出错。理所当然，密封类不能同时又是抽象类，因为抽象总是希望被继承的。

sealed（C# 参考）

sealed 修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法，但其本身不能在任何派生类中进一步重写。当应用于方法或属性时，sealed 修饰符必须始终与override 一起使用。

在类声明中使用sealed 修饰符可防止继承此类，例如：

sealed class SealedClass

{publicint x;

public int y；

}

20.base:

用于在派生类中实现对基类公有或者受保护成员的访问，但是只局限在构造函数、实例方法和实例属性访问器中。

MSDN中小结的具体功能包括：

(1)调用基类上已被其他方法重写的方法。

(2)指定创建派生类实例时应调用的基类构造函数。

base常用于，在派生类对象初始化时和基类进行通信。

base可以访问基类的公有成员和受保护成员，私有成员是不可访问的。

在多层继承中，base可以指向的父类的方法有两种情况：一是有重载存在的情况下，base 将指向直接继承的父类成员的方法；而没有重载存在的情况下，base可以指向任何上级父类的公有或者受保护方法。

21.装箱

装箱是将值类型转换为object 类型或由此值类型实现的任一接口类型的过程。当CLR 对值

类型进行装箱时，会将该值包装到System.Object内部，再将后者存储在托管堆上。取消装箱将从对象中提取值类型。装箱是隐式的；取消装箱是显式的。装箱和取消装箱的概念是类型系统C# 统一视图的基础，其中任一类型的值都被视为一个对象。

主要引用：C#学习(微软认证教材,被誉为最好的培训资料)