复习提纲,基础浅学

c#零星整理

1、is 和 as 的区别

1、is 和 as 的区别

C# 先后设计

注:本文中山大学部图纸来自老师的PPT,多谢邵先生!文中全数剧情为协和根据PPT整理,接待指正!

public class Employee
{ }
public class Employee
{ }

第一章 初识 .NET Framework 和 C#

标识符

标记符(类名、变量名、方法名、表空间名等)

大大小小写敏感

正则表达式  小括号(组合),中括号[可有可无],大括号{重复}

只能以字母/下划线(_)/@符号起先,后面跟若干假名或数字或下划线(_)

第3字是标记符的子集

在首要字前加“@”能够把重大字转换为标志符,能够当变量等应用

能够是华语,只倘诺Unicode编码就能够

 

整型:

假定整型变量有后缀u/U,那么些变量为uint / ulong里最小的越发,

比如整型变量有后缀l/L,这么些变量为long / ulong里最小的百般,

只要整型变量未有后缀,那一个变量为uint/ulong/int/long里最小的要命

 

浮点数:

设若浮点型变量有后缀f/F,那一个变量为float

如果浮点型变量有后缀d/D,那一个变量为double

即使浮点型变量有后缀m/M,那些变量为decimal(占十四个字节,有2八-220人有效位)

一经浮点型变量未有后缀,那几个变量为double

 

字符类型:

能够是随便除了后引号(closing quote)、换行符、反斜杠\

\’    单引号    

\”    双引号    

\\    反斜杠    

\0    空字符    

\a    警报符  (alert)  

\b    退格 (backspace)   

\f    换页   (form feed) 

\n    换行  (new line) 

\r    回车   (carriage return)

\t    水平制表  (horizontal tab)  

\v    垂直制表  (vertical tab)  

转义符应用:

 澳门葡京备用网址 1

字符串以@打头:

@的功能是背后跟着的字符串增加转义字符

例:c:\data\其壹门路用字符串表示

string str = “c:\\data\\”;   

string str =@”c:\data\”;  

 澳门葡京备用网址 2

 

以身作则解释:如果以@打头并且要使字符串里有双引号,那么双引号的地点须求写成上海教室中下部的那些例子,那么些讲话等同于
 “\”C:\\sample.txt\””也正是会为须求丰盛转义符的地点活动抬高转义符,双引号特殊,须要写两次来表示用引号

 

a):

a):

.NET Framework 是帮助生成和平运动作下一代应用程序和 Web
服务的内部Windows组件

类型

分歧的连串

 澳门葡京备用网址 3

 

持有的品类都和object包容

 

值类型和引用类型的分别

 澳门葡京备用网址 4

 

关于堆和栈:

 澳门葡京备用网址 5

 

类(引用类型)的空间分配和组织进度

声明 Rectangle r;

r = new Rectangle();

率先条,在栈顶分配3个字节左右的小空间,里边是空的

其次条,在堆的顶部分配三个上空,并把首地点填到第三步实行时的空中中供调用

参照c#笔记图,在stack和heap增进到接触时,会向操作系统请求分配越来越多的空中

结构体(值类型)会把上述进程全都在栈中打开

 

主干项目强制调换

 澳门葡京备用网址 6

 

sbyte是有暗号陆人整型,-128 – 127

byte是无符号七个人整型,0 – 255

 

枚举类型

继承自Object类

在名字空间里声称,暗中认可是int值,可以强制转变为int值,默许是从0初叶,依次递增,种种增一,也得以友善内定枚举值

 澳门葡京备用网址 7

澳门葡京备用网址 8

安装了byte的功底项目,而且点名从1从头编号,依次为1-柒

强制调换为int值,x的值为②

澳门葡京备用网址 9团结钦定了种种枚举值

在动用时方可透过
Access类型的值是还是不是等于Access.Personal剖断是或不是是第一项,也得以把Access类型的值强制转变为数字类型决断数字为几明确是哪1项。

枚举类型的运算符有

澳门葡京备用网址 10位运算取反

 

注意:

不实行项目转化的话不可见一向给int或任何数值类型间接赋值

System.Enum命名空间里有枚举类型的各个操作

 

 

数组

一维数组与java中格外类似

两种注脚格局:

int[] a = new int[3];

int[] b = new int[] {3,4,5};

int[] c = {3,4,5};

纵横数组,数组的数组,数组元素的维度和尺寸能够差别样,是一维数组(通过数组名.rank求出),存的是子数组的引用(地址),在利用时声称交错数组未来要持续宣称各样子数组,表明后的子数组才能够运用,每种子数组的长度都能够是随意的,不须要一律。如下图

 澳门葡京备用网址 11

 

多维数组

多维数组更像是矩阵,为了与交错数组分开,证明时选拔中括号里加逗号隔断的不贰诀要指明数组的维数。如下图

 澳门葡京备用网址 12

 

System.Array提供了数组的操作接口,Array.Copy(a, b, 贰)
把数组a的前七个因素拷贝给b(会把b相应岗位的剧情覆盖掉)

Arraylist.Insert(int index, object value)
 将成分插入ArrayList的钦赐索引处

Array.Sort(b) 排序

 

字符串String

string有不可变性,给字符串赋值时会令字符串指向叁个新的字符串对象(幸免指向同三个字符串对象的变量因为内部贰个更改了造成别的变量同时被涂改(串池的施用),也为了缓存字符串的哈希值防止重新计算)

字符串能够接二连三、可以由此下标访问字符、能够通过.length查看长度、能够通过“==”号决断内容是还是不是一样

 

可变长度数组

链表,能够一贯通过.add()插入不相同的值(写在add方法的括号里),能够各类别型的数量混用(注意此时调用排序等方法会抛出尤其),长度通过.Count查看

 

关周详组

哈希表,通过键值对的情势存储

 

结构体和类

结构体

宣示时直接在栈顶或别的对象内分配一个object

是值类型,在栈里存款和储蓄,调用速度快,等同于栈上的类

不允许注明未有参数的构造函数,因为尚未参数的构造函数是暗许自带的,不可见覆盖,调用时对全部的数码成员赋初值(各种档案的次序暗中同意的初值)

new时只开端化,不再分配空间

能够兑现接口,无法承接类

不能够有析构函数

引用类型,存在堆里,证明时分配3个object并调用构造函数,注明的构造函数能够未有参数

能够兑现接口,能够承继类

可以有析构函数

 澳门葡京备用网址 13

 

Object类

全部类的基类,对象足以被赋值(编写翻译器会把object映射到System.Object,即Object首字母大小写均可)

装箱和拆箱

boxing

把三个栈上的值类型拷贝三个放入堆中,把首地点交给object

诸如:值类型转变来引用类型

unboxing

强制转变,把堆里的事物拷贝进栈中

诸如:引用类型强制转变为值类型,在威吓转变时都须要2遍装箱和拆箱进度,先转移成Object,再转变到供给的类型。

 

支撑接纳“泛型”容器,在宣称方法时参数写object,能够适配分歧参数类型

举例队列使用泛型,那么三个类别里能够有各个类型,拆箱供给强制类型调换

 

object obj = new Employee();
if (obj is Employee)
{
    Employee e = (Employee)obj;
    //do something....
}
object obj = new Employee();
if (obj is Employee)
{
    Employee e = (Employee)obj;
    //do something....
}

.NET Framework 的重大组件为公共语言运转时(CL大切诺基).NET Framework
类库(.dll)

表达式

表达式

操作数需借使numeric/char,++/–还足以是枚举类型

算术运算后的结果是富含操作数类型且非常的大于int的花色

无符号数和有旗号数做算术运算时,-uint会转换来Long, -ulong会报错

uint和long以外的有号子整型做运算,会转换来Long

ulong和有号子整型做运算会报错

decimal不能和float/double做运算

 

判定目的是还是不是属于某些类,用is运算符

 

sizeof运算符只能用在值类型

 

位运算
结果是两个操作数的十分的大的花色,整型类型和字符类型的小不点儿结果类型是int

 

活动运算 结果是活动的操作数,最小int

 

代码级溢出检查

用checked{

}包装要检验爆发溢出的代码

试行命令 csc /checked Test.cs

 

 

typeof运算符,取类型

 澳门葡京备用网址 14

 

b):

b):

.NET Framework
提供了托管试行蒙受简化的成本布局以及与种种编制程序语言的集成(跨语言的阳台)

声明

声明

namespace

class, interface, struct

enumeration

block 方法块

 

可知性规则

名字能够在宣称此前就应用(除了有些变量)

假如在里面宣称空间里定义了和外部空间里同名的变量,在在那之中,内部的变量会把外部的同名变量覆盖

枚举常量名称要求枚举类型名称限定才具访问

 

namespace

七个程序有所同名的namespace,四个程序能够统一,同名的namespace会见并,namespace相当于器皿,把那么些器皿中的东西纳入思虑范围,即选取namespace中的A时,能够平昔调用,而选用不在namespace中的B时,要写***.B

namespace的子空间必须写明,Util和Util.Figures不能够通过一个using
Util全包蕴了,不可见访问子名字空间

 

有关语句块内的变量的生命周期,语句块本人不是声称空间,而是属于封闭措施块的宣示空间。3个艺术块的命名空间包括了它的嵌套块的命名空间。

澳门葡京备用网址 15

从而最终1行注脚的
c与前面嵌套块里的变量重复了。注意嵌套块与嵌套块之间能够有同名变量,但无法在措施块里调用,也无法在措施块里声称2个同名变量。

 

object obj = new Employee();
Employee e = obj as Employee;
if (e != null)
{
    //do something...
}
object obj = new Employee();
Employee e = obj as Employee;
if (e != null)
{
    //do something...
}

.NET Framework 具备八个第叁组件:公共普通话言运维时(CLEvoque) .NET Framework
类库(FCL)

声明(续)

语句

赋值语句 左值提供地方,右值提供值

string Split分割,split(’,’)以,分割

string String.Join(“”, 分割的string数组)连接

 

switch语句

认清标准不可能是浮点数,比较接纳的是减法,浮点数相减只怕有精度难点

各样case和default必须以break甘休,不可见像C同样实行完3个case不break自动施行下1个case的言辞

可以通过goto case *来跳转到有些case

 

foreach语句

汇集/数组的迭代器

 

跳转

goto语句
在switch语句块中得以一贯跳转到有个别case,恐怕会毁掉程序的结构化特点,不能从循环体外跳进循环里(不能够跳进块里)可能try/catch的finally块

 

return 语句

函数和经过:函数有重回值,进程并未有重临值,重返void的函数可用作进程,return能够直接跳出函数/进程

栈里有部分变量(活动记录区), 堆里有全局变量

Main函数里的重返值再次回到给了操作系统(与java差异)

 

调控台出口

出口格式 占位符 0早先递增表示第多少个变量(表明式中的n)

中括号表示可选的

“{” n [“,” width] [“:” format [precision]] “}”

width宽度,format格式,precision保留的小数位数(精度)

format

d 整数

f 浮点数(默认2位)

n 逗号(自动在每二个人加逗号,千,百万,十亿)

e 科学计数法

c 货币

x 16进制

g 默认

 

 澳门葡京备用网址 16

 

字符串格式转变

 澳门葡京备用网址 17

 

String.Format( )括号里和决定台出口的格式1致

 

文本数据流

输出

FileStream 数据流,输出到文件,建立连接

StreamWriter 写到文件

先成立连接,再写/读

复习提纲,基础浅学。数量流用完要关闭,不然一贯攻下资源

同样时刻只可以由叁个StreamWriter

输入

键盘输入
ReadLine能够读入整个1行的内容(读到第三个回车/换行),Read会读到第二个空格

文本读入假使用Read(),会读到EOF(end of file)文件的最终会有EOF

读的写法把StreamWriter 换来StreamReader

 

在决定台运维程序,文件名 +” *&@&^%(@ “

前面包车型地铁事物是参数,便是static void Main(string[]
args)的args,依据空格拆分,每蒙受一个空格感到是二个参数

 

以上a和b的兑现效益是同样的,但是在CLMurano是运营品质却是b的高,因为CLPAJERO是项目安全的,在写法a中供给做贰遍门类安检,obj
is Employee做一回安检,Employee e =
(Employee)obj;此时再做二回安检,而写法b中Employee e = obj as
Employee;只是做了贰回品种安检。

如上a和b的落成效益是一致的,不过在CLSportage是运维品质却是b的高,因为CLPAJERO是项目安全的,在写法a中要求做3回门类安检,obj
is Employee做一遍安检,Employee e =
(Employee)obj;此时再做三回安检,而写法b中Employee e = obj as
Employee;只是做了一次品种安检。

CL瑞虎称为公共语言运行时(是治本代码实行并提供简化开采进度的劳动的运作景况)(提供了内存管理,线程施行,代码实践,代码安全认证,编写翻译以及任何系统服务

类和结构体

分红在堆里,,存款和储蓄的是值的引用。指针放在栈里供调用,用new创制对象,能够持续两个其余类,能够兑现四个接口

结构体

分红在栈上,存储的是值。消耗内部存款和储蓄器少,不需求垃圾回收,能够用new分配空间,不能够在注解属性的地方给属性初阶化,不可见评释无参构造函数,不可能承袭/被承继类

可知性修饰符

 澳门葡京备用网址 18

 

暗中认可类、结构体、接口、委托、枚举为internal,程序集内可知,接口的成员、枚举的成员默以为public,为了直接被实现/被调用,类和结构体的成员默以为private

名字空间里的内容不能够显式注明为private、protected、protected internal

字段和常量

字段

类的字段能够在宣称时起首化,初阶化的值必须是可总括的,结构体的字段不能够初叶化

常量const

在声明时务必开首化,不可改换,属于类而不属于对象,暗中同意是静态的

只读字段

readonly关键字,必须在申明时/构造函数里伊始化,不得以在事后被改换,属于对象

静态字段

属于类,类名加点调用,常量不能够被声称为静态(与私下认可的重复)

静态方法也属于类,只好修改静态字段

 

参数

值参数

澳门葡京备用网址,值调用,情势参数是实际上参数的正片,实际参数能够是表明式

引用参数 ref

引用调用,方式参数是实在参数的2个别称,传递实际参数的地址,实际参数必须是值(在调用前务必起始化)

输出参数 out

看似于引用参数,调用者不会传送任何值给被调用者,编写翻译器保险从被调用者传出的值被赋值过。

可变参数

盛传的形参能够用params 关键字贯彻动态变化(用数组,放在形参最终)

例如: void add(out int sum, params int[]
val){}数主管度动态变化,当中传入的可变参数不能是援引恐怕输出参数

 

主意重载

低精度到高精度能够包容,假若有四个能够匹配的重载函数能够调用时(最接近的随处多少个函数时),编写翻译器会报错

重载的措施无法惟有重临类型不相同,也不能够而且注明同体系的可变参数和有限参数的不2秘诀,因为CIL只包罗了章程的讲述,不分包方法的地方。

重载是静态多态性的反映。

 

构造方法

可以通过在艺术参数列表之后加:
this()的点子(在情势头里!!!)调用其余的构造方法

 澳门葡京备用网址 19

 

 

暗中认可构造方法

今非昔比品种字段的暗中认可值

 澳门葡京备用网址 20

 

结构体长久有暗许构造方法,不可能宣称无参构造,全体的构造方法都要开首化全体字段

 

静态构造方法

不可能有参数,未有可知性修饰符,每种类只好有1个,在类被第二遍使用从前被调用,用于伊始化静态字段

 

析构方法

未曾可知性修饰符,在目的被垃圾回收机制删除前调用,能够用于关闭展开的公文,基类的析构在结束前自行被调用,结构体不能够有析构

 

属性(get/set 特性)

为了访问私有成员,把属性用公有的办法封装,编写翻译器会活动在事关修改/查看某些字段时调用get/set,使用像重载了赋值符号,当中封装的秘技能够唯有二个,则不得不利用封装的章程对应的功效,比如唯有get,则使用时只可以把别的变量赋值为和那些字段相等的值,也等于readonly/writeonly

 澳门葡京备用网址 21

 

静态的字段也能够那样包装

受益:允许只读也许只写字段;能够在走访时证实字段;接口和促成的多寡足以不相同;替换接口中的数据。

 

索引器

索引器 Indexers,用index把复合的形成数组

public int this[int i]{…},函数体内是get set

接近于对[]操作符的重载,能够向来通过下标访问字段内容,能够用差异的索引器类型重载

 

运算符重载

public static A operator +(A a, A b){} 必须用static

务必返回运算结果

能够被重载的运算符:

 澳门葡京备用网址 22

 

=和!=; <和>等不可能独立重载,必须同时重载/不重载

 

转移操作符

类型转换

隐式implicit 在利用时方可间接赋值

显式explicit 在行使时索要前加括号写上转变来的体系

 澳门葡京备用网址 23

 

在评释时写显著式/隐式,调用时依照不一样的条条框框调用,括号里的类型转变来注解的品种,所以把括号里的花色的值赋值给证明的档期的顺序的变量。

 

嵌套类型

其间类能够访问到所在外部类的有所成员,其所在外部类只可以访问到里面类的公有成员

 

与java可知性的区分

类的成员c#是私有,类c#是先后集可知,java的两边都以包内可知

 

2、C#中持有的int类型均是30个人的,始终映射到Int32,无论操作系统是三玖个人还是陆拾3位。
3、C#中的long类型映射到Int6四.
4、C#中float类型的数值转变为int类型时,会向上取整,比方float类型的陆.8转移为int类型时,得出的值为陆,而不是7.
5、Decimal类型的运算性能低于其余基元(primitive)类型,BigInteger长久不会抛出OverflowException,假诺数值太大,则会抛出OutOfMemoryException。
陆、对象注明为值类型的前提:类型的实例非常的小(小于16字节)或项目标实例比非常大(大于1六字节)但不作为方法实参传递,也不从事艺术工作术再次来到。
柒、应该尽量选择泛型类型的集聚,少使用非泛型,便如应该尽大概使用List<T>,而少使用ArrayList类型,在对值类型的集中操作时,泛型类型能够不要求装箱和拆箱的操作,而非泛型群集必要有装箱和拆箱的操作,进而减弱废料回收次数,泛型类型能大大提升品质。
8、装箱是指CL劲客将值类型的实例对应的剧情复制到托管堆上,然后回到托管堆上的位置指针。拆箱是指CL瑞鹰将引用类型在托管堆上的数目复制到线程宾馆上。
玖、假使二个顺序集想访问另3个先后集的internal声明的类或艺术,能够选拔友元,如:有3个程序集Microsoft.dll,Othersoft.dll,Othersoft.dll想让Microsoft.dll访问Othersoft.dll中宣称为internal的连串或措施,能够在Othersoft.dll的命名空间上对Microsoft.dll证明为友元。如下代码:

2、C#中存有的int类型均是三十四人的,始终映射到Int3二,无论操作系统是三九位还是陆13位。
3、C#中的long类型映射到Int6四.
4、C#中float类型的数值转变为int类型时,会发展取整,举个例子float类型的6.八调换为int类型时,得出的值为6,而不是7.
5、Decimal类型的演算品质低于别的基元(primitive)类型,BigInteger永世不会抛出OverflowException,借使数值太大,则会抛出OutOfMemoryException。
陆、对象证明为值类型的前提:类型的实例一点都不大(小于1陆字节)或项目标实例非常大(大于1陆字节)但不作为方法实参传递,也不从章程重返。
七、应该尽大概选拔泛型类型的会晤,少使用非泛型,便如应该尽大概利用List<T>,而少使用ArrayList类型,在对值类型的成团操作时,泛型类型能够不须要装箱和拆箱的操作,而非泛型集合需求有装箱和拆箱的操作,进而收缩废料回收次数,泛型类型能大大进步品质。
8、装箱是指CL途乐将值类型的实例对应的始末复制到托管堆上,然后再次回到托管堆上的地方指针。拆箱是指CLMurano将引用类型在托管堆上的数据复制到线程旅馆上。
九、尽管2个程序集想访问另一个程序集的internal注脚的类或措施,能够动用友元,如:有三个程序集Microsoft.dll,Othersoft.dll,Othersoft.dll想让Microsoft.dll访问Othersoft.dll中声称为internal的门类或方法,能够在Othersoft.dll的命名空间上对Microsoft.dll表明为友元。如下代码:

IL 中间语言

继承

构造方法无法被一而再,承接的格局能够重写

此起彼伏除了private和构造函数之外的富有故事情节

Override重写 子类竹秋父类完全同名

Overlap 交叉、重复

平昔不出示评释父类的持续自Object类

子类和父类的法子调用:

从父类承袭的函数假诺有重写,调用重写的,在构造子类对象的时候先调用父类的构造函数,这么些构造函数里边再调用到的方式调用子类的(传承来的也是从子类里去调用,用new的话静态类型是父类的时候才会调用父类的函数)

 

目的的静态类型和动态类型

静态类型:申明中内定的连串,只看注脚,不看起初化调用的哪个人的组织

动态类型:引用对应的地址里放的靶子的实际类型,看其实调用的构造

强制调换转换的是静态类型,null能够转变到放肆引用类型

as运算符,能够在勒迫转变到功时进行更动,失利时把引用赋值为空引用(null)

出口时值为null的引用输出以往是空的……因为是空的所以也向来不主意tostring()

 

重写方法

除非在注明时用了virtual关键字的主意能够被子类重写,重写时加override关键字,在子类中声称方法时
public new int x() 让编写翻译器知道父类能够被子类覆盖掉,不会报warnning

主意的签名必须完全同样 可见性、参数数量、参数类型、方法类型

特色和索引器也得以被重写,静态方法不可能被重写,因为静态方法属于全局,重载会招致重复定义。

重写是动态多态性的反映

 

动态绑定

调用方法时依据动态类型应用对象

 

隐藏

子类中得以经过在证明方法时加关键字new来隐藏从父类中继续来的均等具名的情势,在子类对象调用方法时私下认可调用子类的方法,假若要经过子类对象调用父类的法子,供给强制类型转变到父类类型的靶子

 

动态绑定和隐身结合

从评释时最父类静态方法向子类中往下(动态类型)找,找到非override(可能是最终重写的此办法也只怕是率先次出现使用首要字new覆盖了在此以前的主意的地方(调用new在此以前的主意),这样一来new之后的秘诀就和原来的章程不是二个格局了)的章程就调用,否则一贯往下找

 澳门葡京备用网址 24

 

可以减轻Java语言中比较薄弱的基类难题,对调用的函数假若不可能分清是应该调用父类的函数照旧子类的函数,比方父类的某部函数里调用了父类的另三个函数而且以此被调用的函数在子类中也存在,且子类中的函数会对数码开始展览第二操作,本来想调用父类的法申时却调用了子类的法子,在调用时从没警示,大概会挑起巨大的主题材料。(低档格式化、高等格式化难点),c#中会强制供给选择override或new来制止难题。

 

拷贝

深拷贝:指的是拷贝叁个对象时,不仅仅把目的的引用进行理并答复制,还把该目标引用的值也一齐拷贝。那样实行深拷贝后的正片对象就和源对象相互独立,个中任何2个对象的改造都不会对其它三个目的造成影响。举个例子:值类型的正片

浅拷贝:指的是拷贝二个目的时,仅仅拷贝对象的引用举行拷贝,可是拷贝对象和源对象依旧引用同1份实体。此时,个中3个对象的更改都会潜移默化到另一个目标。举个例子:引用类型的正片

 

子类的构造函数

子类构造时会先调用父类的缺省构造函数,再实施子类的构造函数,如果父类未有无参的构造函数,会报错,化解办法:给父类定义无参构造函数;二.在子类构造函数施行时先显式定义父类构造函数,能够这么写

class B:A{ public B(int x) :base(x){}} 调用了A的有参构造函数A(int x){ }

 

抽象

abstract方法
在宣称时不兑现,隐式virtual(不能够再显示定义),有抽象方法的类需注脚为抽象类

sealed关键字 不容许再被接续

 

using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Microsoft")]
namespace Othersoft
{   
    internal class OthersoftGreeting
    {
        internal void SayHello()
        {
            Console.WriteLine("SayHello from Othersoft.");
        }
    }
}
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Microsoft")]
namespace Othersoft
{   
    internal class OthersoftGreeting
    {
        internal void SayHello()
        {
            Console.WriteLine("SayHello from Othersoft.");
        }
    }
}

.exe

接口

能够有总体性(get/set)、方法、索引器、事件,不可能有字段、析构,构造,运算符重载、嵌套类型

接口里的品质的get/set方法都不可能促成,都要在非抽象类的子类中落成

分子不可能是静态

隐式已经是abstract(一样也隐式是virtual)

贯彻接口的秘诀时,不可能用override关键字,不是重写,即便完结的措施允许完成接口的类的子类重写,要再声称为virtual

接口不能够实例化,不过足以用静态类型注脚接口对象,只要动态类型不是接口类的目的(普通类或null都足以)就足以,同样能够透过is关键字剖断目的是不是属于接口类

设若三个类完结的多少个接口中冒出了同名函数,在落成时要写明:

接口名.函数名(),调用时经过不一致的静态类型的接口对象调用

只顾:这种景色不可能把同名函数写成Public,会报错,是CL景逸SUV的主题素材

 澳门葡京备用网址 25

 

类和接口的异议:

 澳门葡京备用网址 26

 

Class

Interface

可以实例化

不能实例化

可以包含字段、构造、析构、运算符重载、嵌套类型等

不能包含字段、构造、析构、运算符重载、嵌套类型等

包含方法的实现

不包含方法的实现

一个类只能继承一个其他的类

一个类可以实现多个接口

一个类可以继承多个接口

一个接口可以继承多个接口

类可以包含事件、索引器、方法、属性

接口可以包含事件、索引器、方法、属性

 

 

InternalsVisibleTo类的参数为完全的主次集名称,具名和版本号可选。
如此这般在Microsoft.dll中的类中就能够直接动用Othersoft.dll中的OthersoftGreeting类和内部的点子。

InternalsVisibleTo类的参数为完整的先后集名称,签字和版本号可选。
如此在Microsoft.dll中的类中就能够平素运用Othersoft.dll中的OthersoftGreeting类和中间的办法。

JLT 即时编写翻译器 (编写翻译成2进制的机器语言)

委托和事件

委托

回去类型 + 函数名 + (参数列表)   重返类型和参数组成格局的签名

delegate + 重回类型 + 委托名 + (参数列表) 阐明委托项目

委托名 委托变量名 ;//申明叁个信托项目标寄托变量

艺术签字和信托项目里的具名(重返类型和参数类型)1致

把信托变量赋值为艺术名(也得以new二个寄托项目标变量new
A(函数名)),则委托变量也就是1个函数指针了,能够调用函数

例:

 澳门葡京备用网址 27

 

给委托分配办公室法也能够平昔greetings =
SayHello(假使不是静态方法的话必要写明对象加点可能放在类的不二等秘书籍里)1个委托变量能够是空的,没有分配办公室法,那时那么些委托变量不能被调用。委托变量能够存在数据结构里,可以作为参数字传送递。

在类外使用委托,假若是静态方法供给类名加点,动态方法须求对象加点

 

多播委托

“委托变量 += 方法”可以再绑定二个主意,所以在实施委托时会实施四个函数

能够”委托变量 -=
方法”解绑方法,解绑时先从最后绑定的办法初叶找,找到第一个同名的解绑。

一经绑定的不二等秘书技是函数,即有重临值,则最后嘱托变量的重返值是最终1个函数的重返值,如若参数有ref,前边的函数传入的参数大概早就被日前的函数修改了

 

事件

破例的嘱托

把艺术的调用和修改隔断开,只有注解方法的类能够触发event域,外部只好通过+=或许-=来改换event域,不能够使用=改变event域,能够让委托变量不会被外表随意修改

 澳门葡京备用网址 28

 

还需求在Model表明event在此之前在异乡声美赞臣个delegate,名叫Notifier,参数为string

 澳门葡京备用网址 29

注意delegate的可知性无法比event小,即类型的可知性无法比变量小

判定不为空(null)才具调用

namespace Microsoft
{
    public class MicrosoftUtil
    {
        public void SayHello()
        {
            Othersoft.OthersoftGreeting greeting = new Othersoft.OthersoftGreeting();
            greeting.SayHello();
        }
    }
}
namespace Microsoft
{
    public class MicrosoftUtil
    {
        public void SayHello()
        {
            Othersoft.OthersoftGreeting greeting = new Othersoft.OthersoftGreeting();
            greeting.SayHello();
        }
    }
}

CL奥迪Q3 是由 CTS(通用项目系统) 和 CLS(公共语言专门的学业) 组成

异常

无法不来自System.Exception

stacktrace 货仓追踪,检查极度的岗位

罕见调用的章程中抛出了拾壹分,会一层一层往外抛,直到被某1层catch或然最后抛给操作系统。更有利不过鲁棒性倒霉。抛出1贰分的每一个函数都会截止,不会继续实行。

寄托的非常和常见的函数调用非常是一律的。

只要try块前边未有别的的catch,此时必须有finally块

十、做项目设计时,要尽量收缩虚方法的多少,调用虚方法的快慢比调用非虚方法慢。

拾、做项目设计时,要尽量收缩虚方法的数目,调用虚方法的速度比调用非虚方法慢。

System.Collections.Generic; 泛型

名字空间和次序集

名字空间

取名空间
编写翻译时构造,容器,里边放的是各系列型,包涵类、接口、结构体、枚举类型、委托……

能够嵌套

应用其它名字空间里的品类,能够导入(using
Util),也足以在界定名中钦赐(Util.Color)

 

和java的包的区别:

c#中各样文件里能够包涵多个名字空间,而java的文书里各样只可以有二个包;

c#中的名字空间和类不映射到目录和文书,java的包和类映射到目录和文件;

c#中程导弹入名字空间能够把名字空间中具备的国有类型全体导入,java是选用性的导入,用.*代表导入全体的公有类型;

c#的可知性有internal,java的可知性有package;

 

程序集

被编写翻译到同一个dll文件只怕exe中的程序属于1个程序集

运行时组织,大概包涵来自差别名字空间的项目

编写翻译指令比方:

csc A.cs => A.exe

csc A.cs B.cs C.cs => B.exe (if B.cs contains the Main method) csc
/out:X.exe A.cs B.cs => X.exe

csc /t:library A.cs => A.dll

csc /t:library A.cs B.cs => A.dll

csc /t:library /out:X.dll A.cs B.cs => X.dll

csc /r:X.dll A.cs B.cs => A.exe (where A or B reference types in
X.dll)

csc /addmodule:Y.netmodule A.cs => A.exe (Y is added to this
assembly; but Y.netmodule remains as a separate file)

.dll文件在调用时加载,编写翻译出的.exe文件中存有亟待的dll文件版本号,加载时会加载对应版本号的dll

国有/私有程序集

private
assembly只好被1个应用程序使用、保存在应用程序目录中、不要求强命名、无法具名;

public
assembly能够被所用应用程序使用、保存在全局程序集中、必须有3个强命名、能够具名

村办程序集只可以被一个顺序选用,未有强名称

国有程序集能够被有着的次第选用,有强名称

强名称

饱含四部分:程序集名称、程序集版本号、程序集的文化、程序集公钥。能够接纳sn.exe生成私钥文件。

先后集用私钥签名,公钥存在程序集里

 

可知性修饰符 internal

先后集内可知,在差别的次第集里尽管是同贰个namespace也不可知,在同多少个顺序集里即便不在同多个namespace,通过using所在的namespace也足见

 

 

11、使用常量(const)的高危机,当1个先后聚集含有常量变量时,另3个主次集对那几个蕴藏常量程序集的引用时,常量被当作元数据存入了程序集,要是常量程序集中常量的值发生了转移,而引用的主次集不重复编写翻译,那样常量的值依旧改动从前的值,引用的次第集唯有重新编写翻译本领更新常量的值。

1一、使用常量(const)的高危害,当1个主次聚焦含有常量变量时,另一个程序集对那么些蕴藏常量程序集的引用时,常量被作为元数据存入了程序集,倘诺常量程序集中常量的值产生了转移,而引用的主次集不另行编译,那样常量的值依旧改动此前的值,引用的次第集唯有重新编写翻译才具更新常量的值。

System.Linq;数据库

特性

用户定义的元音讯,程序中各样成分(比方类、方法、结构、枚举、组件等)的行为消息的注明性标签,如编写翻译器指令和注释、描述、方法、类等其它音信。用中括号框起来,能够有多少个特征

 澳门葡京备用网址 30

 

通式:

[attribute(positional_parameters, name_parameter = value, …)]

positional_parameters 规定必需的音信(特性的协会),name_parameter
规定可选的音讯(性情的品质)。

 

Obsolete特性

用来表示过时。那一个预约义性情标识了不应被利用的程序实体。它能够让您文告编写翻译器吐弃有个别特定的目标成分。比方,当一个新格局被用在1个类中,可是你照旧想要保持类中的旧艺术,您能够因此突显一个应该使用新措施,而不是旧艺术的新闻,来把它标识为
obsolete(过时的)。

[Obsolete(message,iserror)] ,也能够只传入message

参数
message,是贰个字符串,描述项目怎么过时的由来以及该代替利用什么。

参数 iserror,是一个布尔值。就算该值为
true,编写翻译器应把该类型的应用作为二个谬误。暗许值是
false(编写翻译器生成叁个告诫)。

 

Conditional特性

标志了2个规则方法,其实施正视于钦赐的预管理标记符。

它会唤起方法调用的准绳编写翻译,取决于内定的值,比方 Debug 或
Trace。举例,当调节和测试代码时显得变量的值。

[Conditional(conditionalSymbol)]会在概念了conditionalSymbol的时候编写翻译那么些天性附属的剧情,如若未有定义conditionalSymbol就不会编写翻译性情附属的始末,也不会奉行那些内容调用的地方。

 

Serializable特性

可串行化/种类化,储存和获取磁盘文件、内部存款和储蓄器或其它地点中的对象。适用于类,具备此特性的类活动体系化。

NonSerialized不可串行化,适用于字段,被清除在类别化之外。引用了自家的类就须要把引用的自个儿的字段设置为不可串行化之后那么些类才得以串行化。

 

AttributeUsage特性

讲述了怎么样运用1个自定义本性类。它规定了特征可选拔到的种类的体系。

[AttributeUsage(validon, AllowMultiple=allowmultiple,
Inherited=inherited)]

参数 validon 规定脾性可被停放的语言因素。它是枚举器 AttributeTargets
的值的整合。暗许值是 AttributeTargets.All。

参数 allowmultiple(可选的)为该天性的 AllowMultiple
属性(property)提供3个布尔值。如果为 true,则该天性是多用的。私下认可值是
false(单用的)。里边写get/set

参数 inherited(可选的)为该天性的 Inherited
属性(property)提供2个布尔值。要是为
true,则该天性可被派生类承继。暗中认可值是
false(不被一而再)。里边写get/set

 澳门葡京备用网址 31

 

 

1二、readonly字段只可以在品种的构造函数中赋值,其余位置区别意修改,然则能够通过反射的方法修改。

1二、readonly字段只可以在项目标构造函数中赋值,其余地点不允许修改,可是足以由此反射的措施修改。

System.Text; Builder

线程

System.Threading

相互之间进度,抢占式,共享地址空间

可以透过Thread t = new Thread(M)
来展开一个施行M的线程,个中M是方法名

调节的蝇头单位是进程,能源分配的小不点儿单位是线程

抢占式意味着若是当前占有cpu的线程不交出cpu的使用权,则此外线程就不能够施行

设若调用了sleep,纵然是0也会交出cpu的使用权

 

与java中线程的分别

c#中不需求写Thread的子类去把要实行的线程写入类中(java需求依旧完成runnable接口)

任何多个从未有过重回值的格局都足以当做线程运转(java线程的运动必须写在方法run里)

停顿方法能够动用,能够抛出ThreadAbortException非常,捕获后在catch子句末尾重新抛出(java无法采取stop方法)

 

线程的情状

发轫在此以前 unstarted

调用start 开始   running

调用suspend 挂起  suspended

调用resume 重新苏醒 running

调用abort 退出 stopped

线程.join方法  主线程等待子线程截止再继续试行

 

abort方法

鲜有抛出尤其,向来抛到最终,奉行完finally块里的东西

线程对象调用abort方法时开始抛出

 

互斥

管教当三个线程位于代码的临界区时,另三个线程不进来临界区。若是别的线程试图进入锁定的代码,则它将一直等候(即被阻碍),直到该对象被保释。

lock是语法糖,自动在应用时加锁,使用后刑释

实质上采用的是monitor类

Monitor.Enter(object)方法是得到锁,Monitor.Exit(object)方法是假释锁

运用了lock的类就起到monitor的功用

wait和pulse

Monitor.Wait
释放对象的锁并跻身目的的等待队列,对象的妥当队列中的下二个线程(如若有)获取锁并兼有对目标的攻下使用。Wait()正是交出锁的使用权,使线程处于阻塞状态,直到再次获得锁的使用权。让日前使用对象的线程等待,释放锁

Monitor.Pulse
当前线程调用此办法以便向队列中的下3个线程发出锁的功率信号。接收到脉冲后,等待线程就被移动到就绪队列中。在调用
Pulse
的线程释放锁后,就绪队列中的下一个线程(不断定是吸收到脉冲的线程)将赢得该锁。pulse()并不会使近日线程释放锁。

三个主意必须在lock块中接纳,wait常用来等待一个标准为真,注意三个线程从等待中晋升以往只怕就再也不能够使原则为真了,所以wait应该被放在循环里并检查规范是不是为假

PulseAll(v)能够让全部等待使用v的线程唤醒,使v被中间三个加锁

 澳门葡京备用网址 32

 

共同缓冲区的可视化,使用的就是wait和pulse

 澳门葡京备用网址 33

 

一三、readonly注脚的字段,不可能改换的是以此字段指向指针,而不是不可能改变指针指向的地址的值,如:

1叁、readonly注解的字段,不能够更改的是那一个字段指向指针,而不是无法改动指针指向的地点的值,如:

静态方法能够一贯运维

C#2.0简介

泛型

为了能够使编写的类或措施对负有的类型都可用,供给引进泛型。

动用把品种注明为object类的不二等秘书诀也得以完结,不过就提到到了装箱和拆箱,供给越多的时刻开销,而且或许会促成品种的选拔混乱,区别数据类型混用导致出错

有尖括号的类是泛型类,能够用来类、结构体、接口、泛型方法,Element叫占位符,能够被代替他

class Buffer<Element>{

       private Element[] data;

       public Buffer(int size) {…}

       public void Put(Element x) {…}

       public Element Get() {…}

}

动用的时候实例化,Buffer<int>a = new Buffer<int>(拾0)

还足以对参数加多限制,比方参数能够进行比较(比方落成IComparable接口)

 澳门葡京备用网址 34

 

依赖优先级插值排序的办法,Priority:IComparable需求参数Priority的连串必须兑现了IComparable接口(是其子类就能够),使那些项目之间能够相比较

由此编写翻译时类型检查来使用钦点的数据类型

还足以带八个参数

class Buffer <Element,
Priority>,四个参数能够是不一致系列,如上海教室

在where 后能够限制品种必须有某种格局的构造函数

渴求E必须有无参构造函数

澳门葡京备用网址 35

澳门葡京备用网址 36

抛出E类型的那多少个

应用:

 澳门葡京备用网址 37

 

 

泛型的父类和子类难点

泛型子类能够持续自泛型类,也足以继续自已经实例化的泛型(其实已经不是泛型了),也得以一而再自普通类

子类和父类的泛型可以不相同(参数个数)

分裂意父类是泛型类而子类不是泛型类

泛型类必须带有泛型方法

 

三种持续示例

 

泛型的重写

父类的虚函数的参数能够是Element(占位符),

 澳门葡京备用网址 38

 

子类里重写的时候

固然子类是普通类,必须把泛型实例化,不可能再用占位符

 澳门葡京备用网址 39

借使子类是泛型类,能够保留占位符

 澳门葡京备用网址 40

不能够出现子类是经常类但是还在函数里使用占位符的情事

 澳门葡京备用网址 41

泛型方法

 澳门葡京备用网址 42

 

能够使用放肆数据类型的格局,上海体育场所的格局为别的完成了IComparable接口的种类都得以选择,排序数组

澳门葡京备用网址 43

 

调用方法,字典序排列

编写翻译器会依据办法的参数类型算计要替代占位符类型的切实品种

之所以措施的调用能够是

 澳门葡京备用网址 44

泛型类型的字段要初叶化成default(类型)

 澳门葡京备用网址 45

 

泛型类的编译

泛型类只在实例化为新的连串(此处教导用、值等,3遍引用编写翻译能够让以往都不用再编写翻译任何的引用类型,一回int编写翻译能够让未来不须要再编译int类型)的才会编写翻译,不然只在第1次出现的时候编写翻译,之后都不再另行编写翻译

 

 

 

 

App.config 应用程序配置文件

c#3.0简介

LINQ

言语集成查询

 澳门葡京备用网址 46

澳门葡京备用网址 47澳门葡京备用网址 48

 澳门葡京备用网址 49

瞩目输出的渴求,ToUpper,调换到大写

 

Lambda表达式

为委托加多的语法糖

格式:(参数…)=>{方法主体}

 澳门葡京备用网址 50

澳门葡京备用网址 51

参数和再次来到值的附和地点:

 澳门葡京备用网址 52

 

出手能够是回去结果的块(即便委托项目为void左边就不必要有再次回到结果)

 澳门葡京备用网址 53

 

动手能够对表面包车型大巴变量实行操作

演示:(委托是System.Linq名字空间里定义的泛型委托)

 澳门葡京备用网址 54

 

class Program
{

        static readonly char[] greeting = new char[] {'H','E','L','L','O',',','W','O','R','L','D','!' };
        
        static void Main(string[] args)
        {
            Console.WriteLine(greeting);

            for (int i = 0; i < greeting.Length; i++)
            {
                greeting[i] = 'A';
            }

            Console.WriteLine(greeting);
}
class Program
{

        static readonly char[] greeting = new char[] {'H','E','L','L','O',',','W','O','R','L','D','!' };
        
        static void Main(string[] args)
        {
            Console.WriteLine(greeting);

            for (int i = 0; i < greeting.Length; i++)
            {
                greeting[i] = 'A';
            }

            Console.WriteLine(greeting);
}

命名空间(逻辑协会)(幸免命名争执)

地点的代码是合法的,并且能健康输出:
HELLO,WORLD!
AAAAAAAAAAAA

上面的代码是法定的,并且能符合规律输出:
HELLO,WORLD!
AAAAAAAAAAAA

第二章 C# 基础语法

可是一旦增多以下代码:
greeting = new char[] { ‘A’,’A’,’A’};
如此编译器将不能编写翻译。

但是若是增多以下代码:
greeting = new char[] { ‘A’,’A’,’A’};
那般编写翻译器将不可能编写翻译。

标记符:是先后中项目和变量的名号,标记代码成分名称,由Unicode字符组成(使用未格式化的Unicode字符,以3个合法的Unicode字符或下划线伊始,用关键字作标记符,必须以@符号初叶(数字不是合法的Unicode字符))

14、结构不允许定义无参构造函数,可是足以在有参数构造函数中用this
调用无参数构造函数,在构造的构造函数中,必须保险组织的兼具变量都被最先化。

14、结构分裂意定义无参构造函数,可是能够在有参数构造函数中用this
调用无参数构造函数,在布局的构造函数中,必须保险协会的有着变量都被开头化。

abstract  as  base  bool  break  byte  case  catch  char  checked chass
 const (常量) continue  decimal  default  delegate  do  double  else 
enum  event  explicit 
extern  false  finally 
fixed  float  for 
foreach  goto  if  implicit  in  in(泛型修饰符)  int  interface 
internal(程序集内部)  is(类型判别)  lock(四线程时候用)  long  namespace 
new(隐藏父类的同名方法)  null  object  operator  out(类型输出参数) 
out(泛型修饰符)  override(重写) 
params(可变参数数组,必须放在参数列表的最后多少个)  private 
protected(保养的,唯有子类能够访问)  public  readonly  ref(引用参数) 
return  sbyte  sealed(密封类,不能够被接续,修饰方法,子类无法被改造) 
short  sizeof  stackal  static  string  struct(结构)  switch  this 
throw(抛出卓殊)  true  try  typeof  uint  ulong  unchecked  unsafe  ushort  using 
virtual(虚拟的,定义虚方法,能够override)  void  volatile  while

struct Point
{
   private Int32 m_x, m_y;
   public Point(Int32 x)
   {
      m_x = x;
   }
}
struct Point
{
   private Int32 m_x, m_y;
   public Point(Int32 x)
   {
      m_x = x;
   }
}

而外参数,私有字段及片段变量使用Camel风杰出,别的均采用帕斯Carl风格

下边包车型地铁代码将不能符合规律编写翻译,会提醒Point.m_y必须在回到前被赋值。

地点的代码将不大概平日编写翻译,会唤起Point.m_y必须在回来前被赋值。

帕斯Carl:类,方法名,属性名,类内的共有字段,接口,自定义的数据类型(枚举,结构)

struct Point
{
    private Int32 m_x, m_y;
    public Point(Int32 x)
    {
        this = new Point();
        m_x = x;
    }
}
struct Point
{
    private Int32 m_x, m_y;
    public Point(Int32 x)
    {
        this = new Point();
        m_x = x;
    }
}

变量:程序运行时期退换的主次成分(变化的因素的容器)

地点的代码是能平常编译执行的,用this调用无参构造函数,那样保障全体的变量都被赋初叶值。

地点的代码是能平常编译实行的,用this调用无参构造函数,那样保障具有的变量都被赋伊始值。

佚名局部变量也是强类型的片段变量(只幸亏格局内部用)开首化的时候必须是强类型,不可能是无类型的

一伍、扩充方法类必须评释为非泛型且为static,方法必须注明为static,访问扩大方法时,要求对扩大方法命名空间增添using引用

16、总部(partial)方法必须注明在分公司(partial)类中,并且分局方法必须为private,要是分公司方法未有方法体,则对分公司方法的调用IL会自动忽略。
一七、评释含有私下认可值参数的章程,有默许值的参数要放在未有暗许值的参数之后,在调用时,能够展现钦定传入参数的值,不传值的参数使用暗中认可值,如:

一5、扩大方法类必须申明为非泛型且为static,方法必须声明为static,访问扩大方法时,要求对扩展方法命名空间加多using引用

16、分公司(partial)方法必须评释在分部(partial)类中,并且分局方法必须为private,借使分局方法未有方法体,则对根据地方法的调用IL会自动忽略。
17、评释含有默许值参数的不二等秘书诀,有私下认可值的参数要放在未有私下认可值的参数之后,在调用时,能够显得钦定传入参数的值,不传值的参数使用默许值,如:

object string(类) 引用类型,其它为值类型

private static void MethodWithDefault(int x = 5, string s = "A",
    DateTime dt = default(DateTime), Guid guid = new Guid())
{
    Console.WriteLine("x = {0}, s = {1}, dt = {2}, guid = {3}",
        x, s, dt, guid);
}
private static void MethodWithDefault(int x = 5, string s = "A",
    DateTime dt = default(DateTime), Guid guid = new Guid())
{
    Console.WriteLine("x = {0}, s = {1}, dt = {2}, guid = {3}",
        x, s, dt, guid);
}

byte 0 – 255

调用:

调用:

sbyte -128 – 127

int n = 0;
MethodWithDefault();
MethodWithDefault(n++);
MethodWithDefault(n++, n++.ToString());
MethodWithDefault(n++, n++.ToString(), DateTime.Now);
MethodWithDefault(x: n++, guid: Guid.NewGuid());
int n = 0;
MethodWithDefault();
MethodWithDefault(n++);
MethodWithDefault(n++, n++.ToString());
MethodWithDefault(n++, n++.ToString(), DateTime.Now);
MethodWithDefault(x: n++, guid: Guid.NewGuid());

decimal (精度高) double(范围大)

输出:

输出:

\b退格 \r换行 \n回车

x = 5, s = A, dt = 0001-01-01 00:00:00, guid = 00000000-0000-0000-0000-000000000000
x = 0, s = A, dt = 0001-01-01 00:00:00, guid = 00000000-0000-0000-0000-000000000000
x = 1, s = 2, dt = 0001-01-01 00:00:00, guid = 00000000-0000-0000-0000-000000000000
x = 3, s = 4, dt = 2016-03-25 10:58:46, guid = 00000000-0000-0000-0000-000000000000
x = 5, s = A, dt = 0001-01-01 00:00:00, guid = 6e2564bc-9202-4c95-aec8-97568706846d
x = 5, s = A, dt = 0001-01-01 00:00:00, guid = 00000000-0000-0000-0000-000000000000
x = 0, s = A, dt = 0001-01-01 00:00:00, guid = 00000000-0000-0000-0000-000000000000
x = 1, s = 2, dt = 0001-01-01 00:00:00, guid = 00000000-0000-0000-0000-000000000000
x = 3, s = 4, dt = 2016-03-25 10:58:46, guid = 00000000-0000-0000-0000-000000000000
x = 5, s = A, dt = 0001-01-01 00:00:00, guid = 6e2564bc-9202-4c95-aec8-97568706846d

TryParse(“”, out )转变战败再次回到结果为0

1八、在章程参数中,将大的值类型参数注解为out时,可以增进代码的推行效用,因为它防止了在开始展览艺术调用时复制值类型实例的字段,out和ref评释的参数,在IL中生成的代码是一样的,都以传递参数的指针。
1九、假若格局的参数用params注明不定长参数,则CLKoleos会自动给该办法增加ParamArrayAttribute属性,在运作时,假设不可能同盟对应参数的主意,CL中华V会去有ParamArrayAttribute属性证明的秘籍中相称。
20、方法中参数的项目最棒使用弱类型,而少用强类型,如:

1捌、在章程参数中,将大的值类型参数注解为out时,能够增长代码的实行功效,因为它幸免了在进展艺术调用时复制值类型实例的字段,out和ref申明的参数,在IL中变化的代码是千篇一律的,都以传递参数的指针。
1玖、借使方式的参数用params表明不定长参数,则CL途锐会自动给该情势增多ParamArrayAttribute属性,在运行时,要是不可能协作对应参数的章程,CL卡晚上的集会去有ParamArrayAttribute属性注解的措施中万分。
20、方法中参数的品类最佳使用弱类型,而少用强类型,如:

Convert.ToSingle()调换为浮点型

public void ProcessBytes(Stream stream)
{ }

public void ProcessBytes(FileStream fs)
{ }
public void ProcessBytes(Stream stream)
{ }

public void ProcessBytes(FileStream fs)
{ }

C#运算符

参数为Stream类型的要比FileStream的好,参数为Stream类型的不贰法门能够拍卖FileStream、NetworkStream和MemoryStream等,而参数类型为FileStream的只好管理FileStream。
反而,方法的回来类型最好是声称成强类型而非弱类型。

参数为Stream类型的要比FileStream的好,参数为Stream类型的不二秘籍能够管理FileStream、NetworkStream和MemoryStream等,而参数类型为FileStream的只好管理FileStream。
反而,方法的回来类型最棒是声称成强类型而非弱类型。

优先级依次

二一、不要选择其余MashalByRefObject派生的类。

二1、不要采纳其余MashalByRefObject派生的类。

1元运算符(正,负,取反,按位求补,加加,减减,点)

2二、无名氏类型能够用来权且表明必要分歧数据类型集结的组合体,如:

22、无名类型能够用来目前评释必要差别数据类型集结的组合体,如:

二元运算符(算术,移位,关系,赋值,逻辑、条件)(is:类型剖断前者是还是不是不后面包车型地铁门类的,承继的也算
是重回true,不然false;as:转变战败重回空值)

var person = new { Name = "Zhangsan", Age = 32 };
    Console.WriteLine(string.Format("Name:{0},Age:{1}", person.Name, person.Age));
var person = new { Name = "Zhangsan", Age = 32 };
    Console.WriteLine(string.Format("Name:{0},Age:{1}", person.Name, person.Age));

安慕希运算符

地点注脚了二个含有一个字段(Name,Age)的类型,属性均是只读的,无名类型仅用于方法内部。

地点注解了多个涵盖1个字段(Name,Age)的体系,属性均是只读的,无名氏类型仅用于方法内部。

里氏替换原则

贰三、dynamic协作ExpandoObject生成对象,能够很方便的为目的加多任性类型的字段和品种,对象的运用能够类型JavaScript中目标的选择,编写翻译器不提供智能感知,能够用IDictionary<String,
Object>泛型强制类型转化。

2叁、dynamic同盟ExpandoObject生成对象,能够很便利的为目的增添放四类型的字段和连串,对象的接纳能够类型JavaScript中指标的使用,编写翻译器不提供智能感知,能够用IDictionary<String,
Object>泛型强制类型转化。

用as 调换记得推断转变结果是或不是null 不是再去实行后续代码

dynamic expando = new ExpandoObject();
expando.Name = "Zhangsan";
expando.Age = 32;
expando.Id = "0001";

Console.WriteLine(string.Format("Name:{0},Age:{1},Id:{2}", expando.Name, expando.Age, expando.Id));
    ((INotifyPropertyChanged)expando).PropertyChanged += (s, ee) => {
     Console.WriteLine("Property:{0} value changed.", ee.PropertyName);
    };
    expando.Name = "Lisi";
    foreach (var pair in (IDictionary<string,Object>)expando)
    {
        Console.WriteLine(string.Format("{0}:{1}", pair.Key, pair.Value));
    }
dynamic expando = new ExpandoObject();
expando.Name = "Zhangsan";
expando.Age = 32;
expando.Id = "0001";

Console.WriteLine(string.Format("Name:{0},Age:{1},Id:{2}", expando.Name, expando.Age, expando.Id));
    ((INotifyPropertyChanged)expando).PropertyChanged += (s, ee) => {
     Console.WriteLine("Property:{0} value changed.", ee.PropertyName);
    };
    expando.Name = "Lisi";
    foreach (var pair in (IDictionary<string,Object>)expando)
    {
        Console.WriteLine(string.Format("{0}:{1}", pair.Key, pair.Value));
    }

短路与 && 之前将来各种剖断 有false就不施行后边的判别了

上述代码输出结果:

以上代码输出结果:

短路或 || 有true 前面就不再决断

Name:Zhangsan,Age:32
    Name:Zhangsan,Age:32,Id:0001
    Property:Name value changed.
    Name:Lisi
    Age:32
    Id:0001
Name:Zhangsan,Age:32
    Name:Zhangsan,Age:32,Id:0001
    Property:Name value changed.
    Name:Lisi
    Age:32
    Id:0001

字符串的不改变性

二四、属性在程序发布时,编写翻译器会将品质表明为内联方法,在调节和测试方式时不会评释为内联方法,内联方法比平日方法的施行效能要高,而任由调节和测试形式如故公布后的先后,字段均举办功效高。
25、全体的轩然大波最佳注解再次回到类型为void,事件在接触时,有比很大可能率事件的订阅者此时撤废订阅,那么就必要对事件的订阅做同步操作,访问报NullReferenceException,此时可比好的做法是用Volatile.Read()的格局去赢得事件的暂且拷贝,如下代码:

二四、属性在先后发布时,编写翻译器会将品质申明为内联方法,在调节和测试形式时不会注脚为内联方法,内联方法比普通方法的推行效能要高,而随意调节和测试方式依然公布后的顺序,字段均举行作用高。
25、全数的风浪最佳评释再次回到类型为void,事件在接触时,有非常的大希望事件的订阅者此时撤消订阅,那么就须要对事件的订阅做同步操作,访问报NullReferenceException,此时相比较好的做法是用Volatile.Read()的方法去赢得事件的暂时拷贝,如下代码:

string.Equals(str1, str2); === str1.Equals(str2); === str1 == str2;

public delegate void OnNewMailDelegate(object sender, EventArgs e);
    public static event OnNewMailDelegate OnNewMail;
    if (OnNewMail != null)
    {
        OnNewMailDelegate temp = Volatile.Read(ref OnNewMail);
        if (temp != null)
        {
            temp(null, null);
        }
    }
public delegate void OnNewMailDelegate(object sender, EventArgs e);
    public static event OnNewMailDelegate OnNewMail;
    if (OnNewMail != null)
    {
        OnNewMailDelegate temp = Volatile.Read(ref OnNewMail);
        if (temp != null)
        {
            temp(null, null);
        }
    }

str.Split();分隔

26、CL福特Explorer允许创设引用泛型类型和值泛型类型,但不容许创建枚举泛型类型。
27、优先采用泛型类型,泛型类型质量更优。
2八、泛型的主要约束,可认为泛型钦定约束,可是约束不能够为以下两种越发种类:System.Object,System.Array
, System.Delegate , System.MulticastDelegate ,System.ValueType ,
System.Enum , System.Void。
如,引用
类型约束,假使不表明为引用类型约束将无法编写翻译,提醒类型无法设置为null:

二6、CL帕杰罗允许成立引用泛型类型和值泛型类型,但不容许成立枚举泛型类型。
二⑦、优先利用泛型类型,泛型类型品质更优。
2八、泛型的首要约束,可认为泛型钦定约束,不过约束不可能为以下二种新鲜类别:System.Object,System.Array
, System.Delegate , System.MulticastDelegate ,System.ValueType ,
System.Enum , System.Void。
如,引用
类型约束,即使不申明为引用类型约束将不能编写翻译,提醒类型不能够安装为null:

DateTime 是结构 是值类型

public sealed class ReferenceCheck<T> where T: class
    {
        private T m_instance;
        public ReferenceCheck()
        {
            m_instance = null;
        }
    }
public sealed class ReferenceCheck<T> where T: class
    {
        private T m_instance;
        public ReferenceCheck()
        {
            m_instance = null;
        }
    }

Array

值类型约束,假使不注解为值类型约束,将无法使用T()暗中同意构造函数。

值类型约束,假若不申明为值类型约束,将不能够使用T()默许构造函数。

全体数组都隐式继承自 System.Array 类

public sealed class ValueCheck<T> where T : struct
    {
        private T m_instance;
        public ValueCheck()
        {
            m_instance = T();
        }
    }
public sealed class ValueCheck<T> where T : struct
    {
        private T m_instance;
        public ValueCheck()
        {
            m_instance = T();
        }
    }

Array.Sort();排序

其次约束,内定T类型必须能转化为TBase类型。

支持约束,钦定T类型必须能转化为TBase类型。

Array.Reverse();反转

public static List<TBase> ConvertIList<T, TBase>(IList<T> list) where T : TBase
        {
            List<TBase> baseList = new List<TBase>();
            if (list != null && list.Count > 0)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    baseList.Add(list[i]);
                }
            }
            return baseList;
        }
public static List<TBase> ConvertIList<T, TBase>(IList<T> list) where T : TBase
        {
            List<TBase> baseList = new List<TBase>();
            if (list != null && list.Count > 0)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    baseList.Add(list[i]);
                }
            }
            return baseList;
        }

数组是引用类型,对数组的更动能够保存下去(值类型操作的是别本)

2玖、和引用类型类似,值
类型能够达成零个或七个接口,但值类型在转移为接口时索要装箱,
这是由于接口是引用,必须指向堆上的目的,使CL奥迪Q5能检核对象的品类的靶子指针,从而判别目标的贴切品种,调用已装箱值类型的接口方法时,CLLAND会跟随对象的项目对象指针找到类型对象的方法表,从而科学调用方法。
30、CL奥迪Q伍依照项目标对象指针找到对象的方法表,假设艺术表中找不到须要调用的法子,会向目的的基类型的法子表中找找,直到找到截至,假若不只怕找到将会报方法不设有的要命。多态的落成就是依照此,借使子类重写了(new)父类的法门,在用父类表明子类的实例时,会间接调用父类的措施,假诺急需调用子类的艺术,能够用子类做强制类型转化调用,而子类覆盖了(override)了父类的情势,会直接调用子类的格局。
3一、类型只好继续多个兑现,借使派生类型无法和基类型建立起IS
A关系,就不要基类,而用接口,接口意味着CAN DO关系。
3二、换行符最佳使用System.Enviroment.NewLine常量,那样能够有限支撑在富有的地点都能科学生运动行。
3三、字符串相比较时,应该总是利用StringComparison.Ordinal可能StringComparison.OrdinalIgnoreCase,忽略语言文化的字符串相比较是最快的方式,字符串比较时应当利用String的ToUpperInvariant或ToLowerInvariant方法,ToUpper和ToLower对知识敏感。

2九、和引用类型类似,值
类型能够兑现零个或四个接口,但值类型在转变为接口时索要装箱,
那是出于接口是引用,必须指向堆上的对象,使CLPRADO能检核查象的门类的靶子指针,从而决断目的的恰到好处品种,调用已装箱值类型的接口方法时,CL奇骏会跟随对象的品种对象指针找到类型对象的方法表,从而科学调用方法。
30、CLOdyssey依据项目标靶子指针找到对象的方法表,假如艺术表中找不到供给调用的不二等秘书诀,会向目的的基类型的格局表中检索,直到找到结束,要是不能找到将会报方法不存在的可怜。多态的兑现就是依据此,要是子类重写了(new)父类的章程,在用父类注脚子类的实例时,会一贯调用父类的不2法门,假如急需调用子类的方式,能够用子类做强制类型转化调用,而子类覆盖了(override)了父类的办法,会一向调用子类的主意。
31、类型只可以继续三个贯彻,如若派生类型无法和基类型建立起IS
A关系,就无须基类,而用接口,接口意味着CAN DO关系。
3二、换行符最佳应用System.Enviroment.NewLine常量,这样能够确定保证在享有的地点都能准确运转。
33、字符串相比较时,应该总是选用StringComparison.Ordinal可能StringComparison.OrdinalIgnoreCase,忽略语言文化的字符串比较是最快的秘诀,字符串比较时应当采纳String的ToUpperInvariant或ToLowerInvariant方法,ToUpper和ToLower对知识敏感。

其叁章 面向对象的程序设计及类的定义

34、SecureString能够用来拍卖敏感字符串,字符串在托管堆中是加密的,假若需求解密要求用非托管代码来管理,如:

3四、SecureString能够用来拍卖敏感字符串,字符串在托管堆中是加密的,假若急需解密须求用非托管代码来拍卖,如:

目的是芸芸众生要实行商讨的任何事物,是对难点领域中东西的充饥画饼(万物皆对象,各个对象都以绝无仅有的,对象具有属性和行为,对象具有状态(属性对应的值),对象都属于有些类,各类对象都以有个别类的实例(指的靶子))(能丰裕量词的都以目的

using (SecureString sc = new SecureString())
            {
                Console.Write("Please input your password:");
                while (true)
                {   
                    ConsoleKeyInfo keyInfo = Console.ReadKey(true);
                    if (keyInfo.Key == ConsoleKey.Enter)
                    {
                        break;
                    }
                    sc.AppendChar(keyInfo.KeyChar);
                    Console.Write("*");
                }
                Console.Write(Environment.NewLine);
                DisplayPassword(sc);
            }

      private unsafe static void DisplayPassword(SecureString sc)
        {
            Console.Write("Your password is:");
            char* pc = null;
            try
            {
                pc = (char*)Marshal.SecureStringToCoTaskMemUnicode(sc);
                for (int i = 0; pc[i] != 0; i++)
                    Console.Write(pc[i]);
            }
            catch
            { }
            finally
            {
                if (pc != null)
                    Marshal.ZeroFreeCoTaskMemUnicode((IntPtr)pc);
            }
            Console.Write(Environment.NewLine);
        }
using (SecureString sc = new SecureString())
            {
                Console.Write("Please input your password:");
                while (true)
                {   
                    ConsoleKeyInfo keyInfo = Console.ReadKey(true);
                    if (keyInfo.Key == ConsoleKey.Enter)
                    {
                        break;
                    }
                    sc.AppendChar(keyInfo.KeyChar);
                    Console.Write("*");
                }
                Console.Write(Environment.NewLine);
                DisplayPassword(sc);
            }

      private unsafe static void DisplayPassword(SecureString sc)
        {
            Console.Write("Your password is:");
            char* pc = null;
            try
            {
                pc = (char*)Marshal.SecureStringToCoTaskMemUnicode(sc);
                for (int i = 0; pc[i] != 0; i++)
                    Console.Write(pc[i]);
            }
            catch
            { }
            finally
            {
                if (pc != null)
                    Marshal.ZeroFreeCoTaskMemUnicode((IntPtr)pc);
            }
            Console.Write(Environment.NewLine);
        }

:是壹种具备同样属性和行事的目的的架空,描述1组一般对象的共性(类是模型,是模板,是图片)

35、用ToString(“X”)输出枚举的1陆进制字符串时,输出的字符是3个人数,由枚举的项目明确,假若枚举是byte/sbyte则输出几个人数,short/unshort则输出二人数,int/unint则输出六位数,long/unlong则输出拾肆位数,要是有要求会在前边补0.

3伍、用ToString(“X”)输出枚举的16进制字符串时,输出的字符是几人数,由枚举的类型分明,假诺枚举是byte/sbyte则输出二位数,short/unshort则输出二位数,int/unint则输出伍个人数,long/unlong则输出二十个人数,借使有要求会在前边补0.

类和对象时期的涉嫌:一.
我们会从同1种对象身上提取共同全数的天性、属性和一道能实施的操作、行为转化为类中的数据成员(属性、字段),和艺术(行为、操作)。

enum ByteColor : byte 
      { 
            White,
            Green,
            Blue,
            Yellow,
            Orange
        }

        enum IntColor : int
        {
            White,
            Green,
            Blue,
            Yellow,
            Orange
        }

        enum LongColor : long
        {
            White,
            Green,
            Blue,
            Yellow,
            Orange
        }

         ByteColor bColor = ByteColor.Blue;
            IntColor iColor = IntColor.Blue;
            LongColor lColor = LongColor.Blue;
            Console.WriteLine(string.Format("Byte:{0}", bColor.ToString("X")));
            Console.WriteLine(string.Format("Int:{0}", iColor.ToString("X")));
            Console.WriteLine(string.Format("Long:{0}", lColor.ToString("X")));
enum ByteColor : byte 
      { 
            White,
            Green,
            Blue,
            Yellow,
            Orange
        }

        enum IntColor : int
        {
            White,
            Green,
            Blue,
            Yellow,
            Orange
        }

        enum LongColor : long
        {
            White,
            Green,
            Blue,
            Yellow,
            Orange
        }

         ByteColor bColor = ByteColor.Blue;
            IntColor iColor = IntColor.Blue;
            LongColor lColor = LongColor.Blue;
            Console.WriteLine(string.Format("Byte:{0}", bColor.ToString("X")));
            Console.WriteLine(string.Format("Int:{0}", iColor.ToString("X")));
            Console.WriteLine(string.Format("Long:{0}", lColor.ToString("X")));

2. 用类进行实例化,为该实例钦点差异的质量,则开创出不一致的目标。

输出:

输出:

3. 类是模板,是图片,一般不专门的职业,真正行事的是实例,是目的。

Byte:02
    Int:00000002
    Long:0000000000000002
Byte:02
    Int:00000002
    Long:0000000000000002

4. 行使对象,调用对象的措施,就能够干活了

3六、假如只是索要将数组的一点因素复制到另三个数组,可挑选System.Buffer.BlockCopy方法,它比Array.Copy方法快,可是Buffer.BlockCopy只扶助基元类型,不提供像Array.Copy提供转型才能。要将一个数组成分可信的复制到另叁个数组,应该运用Array.ConstainedCopy方法,该格局照旧完毕复制,要么抛出分外,总来说之不会破坏目的数组中的数据。

3陆、假设只是索要将数组的一点因素复制到另贰个数组,可挑选System.Buffer.BlockCopy方法,它比Array.Copy方法快,不过Buffer.BlockCopy只扶助基元类型,不提供像Array.Copy提供转型手艺。要将二个数组成分可信赖的复制到另二个数组,应该运用Array.ConstainedCopy方法,该情势照旧完毕复制,要么抛出相当,不言而喻不会毁掉目的数组中的数据。

类和类之间构成了目的模型

37、证明的章程,假诺回去类型为数组,固然再次来到值没有别的因素,提议回去2个含有0个因素的数组,而不要回来null,因为这么能够简化调用者的代码,无须做null判定。

三七、注明的法门,如果回到类型为数组,若是再次来到值没有别的因素,建议回去1个含有0个成分的数组,而不用回来null,因为那样能够简化调用者的代码,无须做null判别。

对象模型中的类是一种自定义的数据类型

3八、大目标(大于8四千)直接存放在大目的堆中(LOH),GC代数直接为二代,能够经过GC.GetGeneration(obj)的办法获得对象在GC中的代数。

3八、大目的(大于八四千)直接存放在大目标堆中(LOH),GC代数直接为2代,能够因而GC.GetGeneration(obj)的法子获得对象在GC中的代数。

面向对象编制程序(Object Oriented
Programming):
概念各样类及它们中间的涉及(三大基本特征:封装,承接,多态

3玖、声爱他美(Karicare)个寄托项目,其实正是声称了3个类,所以委托能够证明在另各州方,在不一致的地点有例外的走访品级,委托内有2个分子_target(Object类型,当委托对象包装四个静态方法时,那么些字段为null,当委托对象包装贰个实例方法时,这几个字段引用的是回调方法要操作的目的,换言之,这一个字段建议要传给实例方法的隐匿this的值)、_methodPtr(IntPtr类型,指向回调方法的地点)、_invocationList(Object类型,平时为null,构造委托链时它引用
3个寄托数组,Delegate.Combine()方法增加委托链),委托对象的+=,-=实际上就是调用Delegate.Combine()和Delegate.Remove()方法。

3玖、声雅培(Abbott)个寄托项目,其实正是声称了多个类,所以委托能够声明在其余地点,在差异的地方有分化的拜访等第,委托内有2个成员_target(Object类型,当委托对象包装多个静态方法时,这些字段为null,当委托对象包装2个实例方法时,这几个字段引用的是回调方法要操作的对象,换言之,这些字段提议要传给实例方法的隐匿this的值)、_methodPtr(IntPtr类型,指向回调方法的地方)、_invocationList(Object类型,平日为null,构造委托链时它引用
三个寄托数组,Delegate.Combine()方法增添委托链),委托对象的+=,-=实际上就是调用Delegate.Combine()和Delegate.Remove()方法。

public
公共变量,不大概防护随便赋值,数据不安全(消除形式:把变量定义为私有的,然后当着国有的习性来进展走访,能够进步多少的安全性)

40、尽量少注解委托,因为系统现已提供了丰盛多的原始类型的委托,无再次回到类型的委托有
Action(),Action<T>(T arg),Action<T一,T二>(T1 arg壹,T2arg二)……Action<T1,T二….T1陆>(T一 arg1,T2arg二,…T16,arg1陆)那16连串型的寄托基本暮春经适用大大多的情事,很少有须求再表明其余委托。
有重返类型的寄托有:
TResult Func<TResult>(),TResult Func<T一,TResult>(T壹arg1),TResult Func<T1,T二,TResult>(T一 arg一,T二 arg2),….TResult
Func<T1,T二,…T1陆,TResult>(T1 arg1,T贰 arg2,….T16arg1六),那1各个等级次序的有重返值的寄托项目基本上能满意平常付出中的大多数场馆。需求自定义委托的图景:
1)须要动用ref,out传递参数
贰)必要使用params传递可变多少的参数

40、尽量少注解委托,因为系统已经提供了充裕多的原始类型的委托,无重临类型的嘱托有
Action(),Action<T>(T arg),Action<T壹,T二>(T一 arg一,T二arg2)……Action<T1,T2….T1陆>(T1 arg一,T二arg贰,…T16,arg1陆)那1六种档期的顺序的寄托基本桃月经适用大好多的意况,很少有亟待再申明其余委托。
有重临类型的委托有:
TResult Func<TResult>(),TResult Func<T一,TResult>(T1arg1),TResult Func<T一,T二,TResult>(T一 arg1,T二 arg贰),….TResult
Func<T壹,T2,…T1陆,TResult>(T一 arg一,T二 arg二,….T1六arg1陆),那1陆类别型的有再次回到值的嘱托项目基本上能餍足平日支出中的大大多地方。须要自定义委托的意况:
1)须求选择ref,out传递参数
2)供给运用params传递可变多少的参数

privarte 私有字段 加 public
公共性质是对民用字段的包裹(属性是关于字段的1对走访方法,二个getter方法,用于获取字段的值,一个setter方法,用于安装字段的值)

四一、自定义Attribute通过重载Match和Equals方法,能够用来同1的档期的顺序的实例,实施同样的措施,具备不相同的出口结果,如下示例:

肆壹、自定义Attribute通过重载Match和Equals方法,可以用于同1的档案的次序的实例,试行同1的诀窍,具有不一致的输出结果,如下示例:

此起彼伏能够减去冗余代码

enum Accounts
        {
            Savings = 0x0001,
            Checking = 0x0002,
            Brokerage = 0x0004
        }

      [AttributeUsage(AttributeTargets.Class)]
        class AccountsAttribute : Attribute
        {
            private Accounts m_accounts;

            public AccountsAttribute(Accounts accounts)
            {
                this.m_accounts = accounts;
            }

            public override bool Match(object obj)
            {
                if (obj == null) return false;

                if (obj.GetType() != this.GetType()) return false;

                AccountsAttribute other = (AccountsAttribute)obj;
                if ((other.m_accounts & m_accounts) != m_accounts) return false;

                return true;
            }

            public override bool Equals(object obj)
            {
                if (obj == null) return false;

                if (obj.GetType() != m_accounts.GetType()) return false;

                AccountsAttribute other = (AccountsAttribute)obj;
                if ((other.m_accounts & m_accounts) != m_accounts) return false;

                return true;
            }

            public override int GetHashCode()
            {
                return (int)m_accounts;
            }

        }

      [Accounts(Accounts.Savings)]
        class ChildAccount
        { }

        [Accounts(Accounts.Savings | Accounts.Checking | Accounts.Brokerage)]
        class AdultAccount
        { }

      private static void CanWriteCheck(Object obj)
        {
            Type type = obj.GetType();
            AccountsAttribute checking = new AccountsAttribute(Accounts.Checking);
            Attribute validAttribute = Attribute.GetCustomAttribute(obj.GetType(), typeof(AccountsAttribute), false);

            if (checking.Match(validAttribute))
            {
                Console.WriteLine(string.Format("{0} types can wirte checks.", obj.GetType()));
            }
            else
            {
                Console.WriteLine(string.Format("{0} types can not wirte checks.", obj.GetType()));
            }
           
        }


         ChildAccount child = new ChildAccount();
            AdultAccount adult = new AdultAccount();
            CanWriteCheck(child);
            CanWriteCheck(adult);
            CanWriteCheck(new Program());
enum Accounts
        {
            Savings = 0x0001,
            Checking = 0x0002,
            Brokerage = 0x0004
        }

      [AttributeUsage(AttributeTargets.Class)]
        class AccountsAttribute : Attribute
        {
            private Accounts m_accounts;

            public AccountsAttribute(Accounts accounts)
            {
                this.m_accounts = accounts;
            }

            public override bool Match(object obj)
            {
                if (obj == null) return false;

                if (obj.GetType() != this.GetType()) return false;

                AccountsAttribute other = (AccountsAttribute)obj;
                if ((other.m_accounts & m_accounts) != m_accounts) return false;

                return true;
            }

            public override bool Equals(object obj)
            {
                if (obj == null) return false;

                if (obj.GetType() != m_accounts.GetType()) return false;

                AccountsAttribute other = (AccountsAttribute)obj;
                if ((other.m_accounts & m_accounts) != m_accounts) return false;

                return true;
            }

            public override int GetHashCode()
            {
                return (int)m_accounts;
            }

        }

      [Accounts(Accounts.Savings)]
        class ChildAccount
        { }

        [Accounts(Accounts.Savings | Accounts.Checking | Accounts.Brokerage)]
        class AdultAccount
        { }

      private static void CanWriteCheck(Object obj)
        {
            Type type = obj.GetType();
            AccountsAttribute checking = new AccountsAttribute(Accounts.Checking);
            Attribute validAttribute = Attribute.GetCustomAttribute(obj.GetType(), typeof(AccountsAttribute), false);

            if (checking.Match(validAttribute))
            {
                Console.WriteLine(string.Format("{0} types can wirte checks.", obj.GetType()));
            }
            else
            {
                Console.WriteLine(string.Format("{0} types can not wirte checks.", obj.GetType()));
            }
           
        }


         ChildAccount child = new ChildAccount();
            AdultAccount adult = new AdultAccount();
            CanWriteCheck(child);
            CanWriteCheck(adult);
            CanWriteCheck(new Program());

面向对象编制程序相对古板语言来讲解决古板语言的数据类型只可以定义属性,不只怕描述行为的标题

出口如下结果:

出口如下结果:

[]意味着可选的 <>表示必填的

Test.Program+ChildAccount types can not wirte checks.
Test.Program+AdultAccount types can wirte checks.
Test.Program types can not wirte checks.
Test.Program+ChildAccount types can not wirte checks.
Test.Program+AdultAccount types can wirte checks.
Test.Program types can not wirte checks.

类成员包罗:字段、常量、属性、方法、索引器、构造函数、析构函数、内部类

4贰、各样AppDomain都有贰个堆,四个是GC堆,三个是Loader堆,GC堆用于存放引用类型的实例,也正是会被垃圾回收机制照望到的东西,Loader堆用于存放类型的元数据,也等于所谓的品类对象,在种种项目对象的终极都蕴涵一个方法表。

4二、每种AppDomain都有二个堆,三个是GC堆,3个是Loader堆,GC堆用于存放引用类型的实例,也正是会被垃圾回收机制照看到的事物,Loader堆用于存放类型的元数据,也正是所谓的种类对象,在每一种品种对象的末尾都包括1个方法表。

用new 调用构造函数创制对象

四3、RuntimeHelpers.PrepareConstrainedRegions();是3个很独特的章程,JIT编写翻译器要是在try块在此以前发现调用了那么些主意,就会付出编写翻译try块关联合中学的catch和finally中的代码,JIT会加载任何程序集,创制任何项目对象,调用任郭东旭态构造函数,并对别的措施开始展览JIT编写翻译,假如别的操作爆发非常,这几个尤其会在线程进入try块在此之前爆发。

四3、RuntimeHelpers.PrepareConstrainedRegions();是2个很奇怪的点子,JIT编写翻译器借使在try块在此以前开掘调用了那个形式,就会提交编写翻译try块关联合中学的catch和finally中的代码,JIT会加载任何程序集,创造任何类型对象,调用任李景胜态构造函数,并对其余方法进行JIT编写翻译,假若别的操作发生万分,那么些万分会在线程进入try块从前发生。

Computer中的内部存款和储蓄器分为两大块

44、GC回收机制:当系统须要新生成3个对象时,CLKoleos开掘脚下可用空间不足以分配一个新的对象,会搁浅当前具备的线程,将0代堆中全部根对象的同步索引字段的岗位为0,然后检查0代堆中持有的根对象,借使根对象有引用别的对象,则将这些目标的同步索引字段地方为一,同时将引用对象的壹块儿索引地方为1,假使开掘目标未有其余引用,则持续检查下三个根,直到全部的根对象检查完结,检查得了后,全部的根对象都仍然标记为0,要么标志为1,那样标识为0的目的就是内需回收的靶子,那样对象被回收后,GC会压缩空间(非真正的缩减,只是对象位移),让具有目的的仓库储存接二连三,将具备幸存的目标的地址位移,代数升为一代,同理,倘若0代堆回收完后,假设空间还不足以分配,则会一连回收1代堆,如若一代回收后,还不足以分配,则再回收二代堆,2代堆借使回收后还不足以分配,则会报OutOfMemoryException的不胜。

4四、GC回收机制:当系统需求新生成三个目标时,CL奥迪Q5开采目前可用空间不足以分配三个新的目标,会因噎废食当前有着的线程,将0代堆中全部根对象的同步索引字段的职位为0,然后检查0代堆中颇具的根对象,如若根对象有引用其余对象,则将以此目标的同步索引字段地点为一,同时将引用对象的1块儿索引地方为壹,假如发现目的未有别的引用,则一连检查下一个根,直到全部的根对象检查得了,检查甘休后,全部的根对象都依旧标识为0,要么标识为壹,那样标志为0的靶子正是亟需回收的对象,那样对象被回收后,GC会压缩空间(非真正的压缩,只是对象位移),让具备目标的存储一连,将富有幸存的靶子的地方位移,代数升为一代,同理,假使0代堆回收完后,如果空间还不足以分配,则会继续回收一代堆,假使一代回收后,还不足以分配,则再回收二代堆,二代堆假若回收后还不足以分配,则会报OutOfMemoryException的百般。

栈内部存款和储蓄器:速度快,内部存款和储蓄器小(存对象的引用,指向堆内部存储器的起首地址)

肆伍、GC有二种格局,1种是职业站情势,专门的学业站形式针对客户端应用程序优化,GC变成的延时相当的低,应用程序线程挂起时间极短,防止用户感到焦虑,在该格局下,GC假定其余应用程序都不会损耗太多的CPU财富,另一种是服务器形式服务器方式,该格局针对服务器端应用程序优化GC,被优化的第一是吞吐量和财富使用。GC假定机器上从不运转别的应用程序(无论客户端如故服务端程序),并假定机器的有所CPU都足以用来增派达成GC,该方式导致托管堆被拆分成多少个区域,每一种CPU1个,起初废品回收时,垃圾回收器在各类CPU上都运维一个特有的线程,每种线程都和其余线程并发回收它和谐的区域,那个职能需求应用程序在多CPU上计算利息运转,使线程能真正的劳作,从而获取属性进步。
应用程序私下认可以专业站形式运维。

四伍、GC有二种形式,壹种是职业站情势,职业站格局针对客户端应用程序优化,GC产生的延时异常低,应用程序线程挂起时间非常的短,制止用户感到担忧,在该格局下,GC假定别的应用程序都不会消耗太多的CPU财富,另1种是服务器形式服务器情势,该形式针对服务器端应用程序优化GC,被优化的入眼是吞吐量和能源采用。GC假定机器上未有运行别的应用程序(无论客户端依旧服务端程序),并假定机器的装有CPU都足以用来提携达成GC,该情势导致托管堆被拆分成几个区域,每种CPU多个,开头废品回收时,垃圾回收器在各样CPU上都运转3个特种的线程,各类线程都和别的线程并发回收它和煦的区域,这些意义须求应用程序在多CPU上计算利息运维,使线程能确实的专门的职业,从而赢得属性进步。
应用程序私下认可以工作站格局运转。

堆内部存款和储蓄器:速度慢,内部存款和储蓄器大(存真正的目的(对象的实在数据))

利用以下配置启用服务器方式:

行使以下配置启用服务器格局:

(你不能够不通晓的.net)

<configuration>
  <runtime>
    <gcServer enabled ="true"></gcServer>
  </runtime>
</configuration>
<configuration>
  <runtime>
    <gcServer enabled ="true"></gcServer>
  </runtime>
</configuration>

const 常量(常量在编写翻译的时候初步化)(只幸亏概念的时候早先化

除此之外那二种形式,GC还有二种子情势,并发(暗许)或非并发,在出现方式中,垃圾回收器有1个附加的后台线程,它能在应用程序运营时并发标志对象,1个线程因为分红对象变成第0代跨越预算时,GC首先挂机全数线程,再剖断要回收哪代,假如回收第0代或第壹代,那么任何符合规律实行,不过只要回收第3代,就会增大第0代的深浅(超越其预算),以便在第0代中分配新目标,然后应用程序的线程复苏运转。
能够使用以下配置配置启用并发情势:

而外那二种格局,GC还有二种子形式,并发(暗中认可)或非并发,在出现方式中,垃圾回收器有多个外加的后台线程,它能在应用程序运维时并发标志对象,3个线程因为分红对象产生第0代赶上预算时,GC首先挂机全部线程,再判定要回收哪代,如果回收第0代或第三代,那么一切如常进行,然则倘使回收第2代,就会增大第0代的轻重(当先其预算),以便在第0代中分红新目的,然后应用程序的线程复苏运维。
能够运用以下配置配置启用并发方式:

readonly 在运营时开首化(只能定义在章程外部)无法对只读的字段举办赋值,

<configuration>
  <runtime>
    <gcConcurrent enabled="true"></gcConcurrent>
  </runtime>
</configuration>
<configuration>
  <runtime>
    <gcConcurrent enabled="true"></gcConcurrent>
  </runtime>
</configuration>

readonly字段只还好概念的时候(编写翻译的时候)或在构造函数上(运营的时候)初始化

四陆、当1个目的注脚析构函数时(在IL显示为Finalize方法),在对象被GC回收时,不是即时放飞对象占用的能源,而时将该目的放置freachable队列中,此时该目的的同步索引位的标识位由0被标识为一(对象复活),对象被提高为一代目的,freachable队列会有三个特地的线程监控,假若队列不会空,线程则会调用freachable队列中的对象的finalize方法,释放能源,此时目的才真正的尚未引用,下次垃圾回收时将回收,所以不会随意的给目标证明析构函数,那样大概影响GC的属性,形成对象急需二回GC技艺回收。

四6、当一个目标证明析构函数时(在IL展示为Finalize方法),在对象被GC回收时,不是当下放飞对象占用的财富,而时将该对象放置freachable队列中,此时该目标的同步索引位的标识位由0被标记为1(对象复活),对象被进级为1代目的,freachable队列会有三个专程的线程监察和控制,假若队列不会空,线程则会调用freachable队列中的对象的finalize方法,释放财富,此时目的才真正的尚未引用,下次垃圾回收时将回收,所以不会随机的给目标注明析构函数,那样可能影响GC的性质,形成对象须要一次GC才干回收。

静态方法只能引用静态字段和字段方法

四7、CL中华V为各样AppDomain分配了二个GC Handle
Table,能够透过GCHandle来决定目标的活着周期,能够通过GCHandle强制对象不被GC回收、不被削减等操作。

四柒、CL奇骏为每种AppDomain分配了一个GC Handle
Table,能够通过GCHandle来决定目标的活着周期,能够经过GCHandle强制对象不被GC回收、不被减去等操作。

get set 都出现 读写; 只有get 只读; 只有set 只写;

4八、跨AppDomain传值,二个进度中得以加载四个AppDomain,并且每一种AppDomain之间是互为隔绝的,借使需求区别的AppDomain传递对象,则要求须求被传送的对象是从马尔斯halByRefObject派生,大概是声称对象为可种类化(Serializable),从马尔斯halByRefObject派生的靶子,跨AppDomain传递时,传递的是贰个代理对象,该目的是用GCHandle封装,在调用实际目的时,代理对象会调用GCHandle里面包车型地铁Target实际地址的代码,表明为可种类化的目的在传递时,是传递的实际值,已经与转移对象的AppDomain没有别的关联,传递的目标假诺未从马尔斯halByRefObject派生或未申明为可连串化,在传递时CL陆风X8将抛出对象未被声称为可系列化。

4八、跨AppDomain传值,多少个历程中得以加载多个AppDomain,并且各个AppDomain之间是相互隔开分离的,要是急需差别的AppDomain传递对象,则要求必要被传送的靶子是从MarshalByRefObject派生,或许是声称对象为可系列化(Serializable),从MarshalByRefObject派生的目的,跨AppDomain传递时,传递的是1个代理对象,该对象是用GCHandle封装,在调用实际目标时,代理对象会调用GCHandle里面包车型地铁Target实际地址的代码,证明为可体系化的目的在传递时,是传递的实际值,已经与转移对象的AppDomain没有别的涉及,传递的对象假若未从马尔斯halByRefObject派生或未证明为可种类化,在传递时CLHaval将抛出对象未被声称为可连串化。

品质本质上是壹对章程

示例:

示例:

措施是类或对象的表现,是目的间传递音信的机制

public sealed class MarshalByRefType : MarshalByRefObject
    {
        public MarshalByRefType()
        {
            Console.WriteLine("{0} ctolr running in {0}.", this.GetType().FullName,
            Thread.GetDomain().FriendlyName);
        }

        public void DoSomthing()
        {
            Console.WriteLine("Executing in {0}.", Thread.GetDomain().FriendlyName);
        }

        public MarshalByValueType MethodWithReturn()
        {
            Console.WriteLine("Executing in {0}.", Thread.GetDomain().FriendlyName);
            MarshalByValueType obj = new MarshalByValueType();
            return obj;
        }

        public NonMarshalableType MethodArgAndReturn(string callingDomainName)
        {
            Console.WriteLine("Calling from {0} to {1}", callingDomainName,
                Thread.GetDomain().FriendlyName);
            NonMarshalableType obj = new NonMarshalableType();
            return obj;
        }
    }

    [Serializable]
    public sealed class MarshalByValueType : Object
    {
        private DateTime m_createTime = DateTime.Now;
        public MarshalByValueType()
        {
            Console.WriteLine("{0} ctor running in {1},Created on{2:D}.",
                this.GetType().FullName, Thread.GetDomain().FriendlyName, m_createTime);
        }
        public override string ToString()
        {
            return m_createTime.ToLongTimeString();
        }

    }

    public sealed class NonMarshalableType : Object
    {
        public NonMarshalableType()
        {
            Console.WriteLine("Executing in {0}.", Thread.GetDomain().FriendlyName);
        }
    }

AppDomain defaultDomain = Thread.GetDomain();
            Console.WriteLine("Default AppDomain's Friendly name is:{0}", defaultDomain.FriendlyName);
            string exeAssembly = Assembly.GetEntryAssembly().FullName;
            Console.WriteLine("Main assembly is:{0}", exeAssembly);
            AppDomain ad2 = null;
            Console.WriteLine("{0} Demo #1", Environment.NewLine);
            ad2 = AppDomain.CreateDomain("Ad #2", null, null);
            MarshalByRefType mbrt = null;
            mbrt = (MarshalByRefType)ad2.CreateInstanceAndUnwrap(exeAssembly, "Test.MarshalByRefType");
            Console.WriteLine("Type={0}", mbrt.GetType());
            Console.WriteLine("Is Proxy = {0}", System.Runtime.Remoting.RemotingServices.IsTransparentProxy(mbrt));
            mbrt.DoSomthing();
            AppDomain.Unload(ad2);
            try
            {
                mbrt.DoSomthing();
                Console.WriteLine("Successful call.");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed call.");
            }

            Console.WriteLine("{0} Demo #2", Environment.NewLine);
            ad2 = AppDomain.CreateDomain("Ad #2", null, null);
            mbrt = (MarshalByRefType)ad2.CreateInstanceAndUnwrap(exeAssembly, "Test.MarshalByRefType");
            MarshalByValueType mbvt = mbrt.MethodWithReturn();
            Console.WriteLine("Is Proxy = {0}", System.Runtime.Remoting.RemotingServices.IsTransparentProxy(mbrt));
            Console.WriteLine("Return object created {0}", mbvt.ToString());
            AppDomain.Unload(ad2);
            try
            {
                Console.WriteLine("Return object created {0}", mbvt.ToString());
                Console.WriteLine("Successful call.");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed call.");
            }

            Console.WriteLine("{0} Demo #3", Environment.NewLine);
            ad2 = AppDomain.CreateDomain("Ad #2", null, null);
            mbrt = (MarshalByRefType)ad2.CreateInstanceAndUnwrap(exeAssembly, "Test.MarshalByRefType");
            NonMarshalableType nmt = mbrt.MethodArgAndReturn(defaultDomain.FriendlyName);
public sealed class MarshalByRefType : MarshalByRefObject
    {
        public MarshalByRefType()
        {
            Console.WriteLine("{0} ctolr running in {0}.", this.GetType().FullName,
            Thread.GetDomain().FriendlyName);
        }

        public void DoSomthing()
        {
            Console.WriteLine("Executing in {0}.", Thread.GetDomain().FriendlyName);
        }

        public MarshalByValueType MethodWithReturn()
        {
            Console.WriteLine("Executing in {0}.", Thread.GetDomain().FriendlyName);
            MarshalByValueType obj = new MarshalByValueType();
            return obj;
        }

        public NonMarshalableType MethodArgAndReturn(string callingDomainName)
        {
            Console.WriteLine("Calling from {0} to {1}", callingDomainName,
                Thread.GetDomain().FriendlyName);
            NonMarshalableType obj = new NonMarshalableType();
            return obj;
        }
    }

    [Serializable]
    public sealed class MarshalByValueType : Object
    {
        private DateTime m_createTime = DateTime.Now;
        public MarshalByValueType()
        {
            Console.WriteLine("{0} ctor running in {1},Created on{2:D}.",
                this.GetType().FullName, Thread.GetDomain().FriendlyName, m_createTime);
        }
        public override string ToString()
        {
            return m_createTime.ToLongTimeString();
        }

    }

    public sealed class NonMarshalableType : Object
    {
        public NonMarshalableType()
        {
            Console.WriteLine("Executing in {0}.", Thread.GetDomain().FriendlyName);
        }
    }

AppDomain defaultDomain = Thread.GetDomain();
            Console.WriteLine("Default AppDomain's Friendly name is:{0}", defaultDomain.FriendlyName);
            string exeAssembly = Assembly.GetEntryAssembly().FullName;
            Console.WriteLine("Main assembly is:{0}", exeAssembly);
            AppDomain ad2 = null;
            Console.WriteLine("{0} Demo #1", Environment.NewLine);
            ad2 = AppDomain.CreateDomain("Ad #2", null, null);
            MarshalByRefType mbrt = null;
            mbrt = (MarshalByRefType)ad2.CreateInstanceAndUnwrap(exeAssembly, "Test.MarshalByRefType");
            Console.WriteLine("Type={0}", mbrt.GetType());
            Console.WriteLine("Is Proxy = {0}", System.Runtime.Remoting.RemotingServices.IsTransparentProxy(mbrt));
            mbrt.DoSomthing();
            AppDomain.Unload(ad2);
            try
            {
                mbrt.DoSomthing();
                Console.WriteLine("Successful call.");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed call.");
            }

            Console.WriteLine("{0} Demo #2", Environment.NewLine);
            ad2 = AppDomain.CreateDomain("Ad #2", null, null);
            mbrt = (MarshalByRefType)ad2.CreateInstanceAndUnwrap(exeAssembly, "Test.MarshalByRefType");
            MarshalByValueType mbvt = mbrt.MethodWithReturn();
            Console.WriteLine("Is Proxy = {0}", System.Runtime.Remoting.RemotingServices.IsTransparentProxy(mbrt));
            Console.WriteLine("Return object created {0}", mbvt.ToString());
            AppDomain.Unload(ad2);
            try
            {
                Console.WriteLine("Return object created {0}", mbvt.ToString());
                Console.WriteLine("Successful call.");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed call.");
            }

            Console.WriteLine("{0} Demo #3", Environment.NewLine);
            ad2 = AppDomain.CreateDomain("Ad #2", null, null);
            mbrt = (MarshalByRefType)ad2.CreateInstanceAndUnwrap(exeAssembly, "Test.MarshalByRefType");
            NonMarshalableType nmt = mbrt.MethodArgAndReturn(defaultDomain.FriendlyName);

主意具有具名,方法的拜访等级、可选修饰符、重返值、名称、任何措施参数(具名是艺术分别于任何的类成员)

输出:

输出:

public(大4档期的顺序中都可以访问) private(只万幸当下类内访问)
protected(只可以在后续的子类中访问(出现在父类))
internal(只还好时下先后集内访问)

Default AppDomain's Friendly name is:Test.exe
Main assembly is:Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

 Demo #1
Test.MarshalByRefType ctolr running in Test.MarshalByRefType.
Type=Test.MarshalByRefType
Is Proxy = True
Executing in Ad #2.
Failed call.

 Demo #2
Test.MarshalByRefType ctolr running in Test.MarshalByRefType.
Executing in Ad #2.
Test.MarshalByValueType ctor running in Ad #2,Created onWednesday, April 27, 201
6.
Is Proxy = True
Return object created 15:09:38
Return object created 15:09:38
Successful call.

 Demo #3
Test.MarshalByRefType ctolr running in Test.MarshalByRefType.
Calling from Test.exe to Ad #2
Executing in Ad #2.

未经处理的异常:  System.Runtime.Serialization.SerializationException: 程序集“Te
st, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“Test.NonMar
shalableType”未标记为可序列化。
   在 Test.MarshalByRefType.MethodArgAndReturn(String callingDomainName)
   在 Test.Program.Main(String[] args) 位置 z:\文稿\Visual Studio 2013\Projects\
Sample\Test\Program.cs:行号 312
Default AppDomain's Friendly name is:Test.exe
Main assembly is:Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

 Demo #1
Test.MarshalByRefType ctolr running in Test.MarshalByRefType.
Type=Test.MarshalByRefType
Is Proxy = True
Executing in Ad #2.
Failed call.

 Demo #2
Test.MarshalByRefType ctolr running in Test.MarshalByRefType.
Executing in Ad #2.
Test.MarshalByValueType ctor running in Ad #2,Created onWednesday, April 27, 201
6.
Is Proxy = True
Return object created 15:09:38
Return object created 15:09:38
Successful call.

 Demo #3
Test.MarshalByRefType ctolr running in Test.MarshalByRefType.
Calling from Test.exe to Ad #2
Executing in Ad #2.

未经处理的异常:  System.Runtime.Serialization.SerializationException: 程序集“Te
st, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“Test.NonMar
shalableType”未标记为可序列化。
   在 Test.MarshalByRefType.MethodArgAndReturn(String callingDomainName)
   在 Test.Program.Main(String[] args) 位置 z:\文稿\Visual Studio 2013\Projects\
Sample\Test\Program.cs:行号 312

protected internal(可以在目前程序集内访问,也能够在跨程序集的子类中走访)

4玖、调控台UI程序、NT
Service应用程序、Window窗体应用程序、WPF应用程序都以自寄宿(Self-hosted即自个儿容纳CL揽胜)应用程序,他们都有托管EXE文件,Windows用控管EXE文件伊始化进程时,会加载垫片(一般名称叫mscoree.dll),垫片会基于EXE文件中的CL科雷傲头文件音信判定使用哪个版本的CLRAV四,把CL揽胜加载进进度后,CLLX570会查找Main方法,然后调用Main方法,那样应用程序才真的的运作起来。

4九、调节台UI程序、NT
Service应用程序、Window窗体应用程序、WPF应用程序都是自寄宿(Self-hosted即本人容纳CLR)应用程序,他们都有托管EXE文件,Windows用控管EXE文件先导化进度时,会加载垫片(一般名叫mscoree.dll),垫片会基于EXE文件中的CLEvoque头文件音讯推断使用哪个版本的CLLX570,把CL昂Cora加载进进程后,CLRubicon会查找Main方法,然后调用Main方法,这样应用程序才真的的运行起来。

类假如未有访问修饰符,暗中同意是internal;
类内的积极分子假如没有访问修饰符,暗中同意是private

50、反射创立对象时,除了数组和寄托不可能动用Activtor.CreateInstance方法创造外,其它对角均能使用该办法创造,数组要求动用Array.CreateInstance,创设委托则须要使用MethodInfo.CreateDelegate方法。构造泛型类型的实例,要求首先获得开放类型的引用
,然后再调用Type的MakeGenericType方法,并向其传递二个数组,如:

50、反射创造对象时,除了数组和寄托不可能应用Activtor.CreateInstance方法创设外,其它对角均能利用该办法成立,数组须求采纳Array.CreateInstance,创设委托则供给运用MethodInfo.CreateDelegate方法。构造泛型类型的实例,供给首先获得开放类型的引用
,然后再调用Type的MakeGenericType方法,并向其传递1个数组,如:

在命名空间中定义的因素不能够显式地声名 private、protected、protected
internal

//以下代码生成一个Dictionary<string,int>类型
Type openType = typeof(Dictionary<,>);
Type closedType = openType.MakeyGenericType(typeof(string),typeof(int32));
object obj = Activtor.CreateInstance(closedType);
Console.WriteLine(obj.GetType());
//以下代码生成一个Dictionary<string,int>类型
Type openType = typeof(Dictionary<,>);
Type closedType = openType.MakeyGenericType(typeof(string),typeof(int32));
object obj = Activtor.CreateInstance(closedType);
Console.WriteLine(obj.GetType());

 

程序输出:Dictionary~2[System.String,System.Int32]

先后输出:Dictionary~2[System.String,System.Int32]

OO:面向对象

5壹、能够采纳系列化和反种类化来实现目标的深拷贝,如下代码:

51、能够使用种类化和反类别化来兑现目的的深拷贝,如下代码:

OOP:面向对象编制程序

private static object DeepClone(object original)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Context = new StreamingContext(StreamingContextStates.Clone);
                formatter.Serialize(ms, original);
                //重置流的位置为起始位置
                ms.Position = 0;
                return formatter.Deserialize(ms);
            }
        }
private static object DeepClone(object original)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Context = new StreamingContext(StreamingContextStates.Clone);
                formatter.Serialize(ms, original);
                //重置流的位置为起始位置
                ms.Position = 0;
                return formatter.Deserialize(ms);
            }
        }

OOA:面向对象分析

52、假如急需使项目可类别化,须求给目的注明Serializable性情,在项目里面,就算有不想被体系化的质量,能够用Non塞里alized性格来声称,借使类型发生版本更动,应该将新增添的字段设置为OptionalField特性,防止反连串化时代风尚中尚无该字段而抛出SerializableException的可怜。

5贰、假设急需使项目可类别化,需求给目的表明Serializable个性,在档期的顺序里面,若是有不想被连串化的属性,能够用NonSerialized本性来声称,就算类型发生版本更换,应该将猛增的字段设置为OptionalField天性,幸免反体系化时代时尚中尚无该字段而抛出SerializableException的可怜。

OOD:面向对象设计

53、能够给目标中的方法阐明On塞里alizing、OnSerialized,OnDeSerializing,OnDeSerialized性情来声称方法,用于在对象序系列化时(OnSerializing)、连串化为(OnSerialized)、反类别化时(OnDeSerializing)、反类别化后(OnDeserialized)更改目的的属性,在体系化时格式化器首先调用标识了OnSerializing注解的点子,然后再种类化,类别化完毕,再调用OnSerialized申明的章程。反系列化时格式化器首先调用OnDeserializing注明的艺术,然后反体系化,反种类化完结后,再调用On塞里alized注明的格局。

伍三、能够给目标中的方法申明OnSerializing、OnSerialized,OnDeSerializing,OnDeSerialized性子来声称方法,用于在对象序种类化时(OnSerializing)、体系化为(OnSerialized)、反连串化时(OnDe塞里alizing)、反连串化后(OnDeserialized)退换目的的性质,在系列化时格式化器首先调用标识了OnSerializing证明的点子,然后再种类化,类别化完毕,再调用OnSerialized注解的主意。反体系化时格式化器首先调用OnDeserializing评释的诀窍,然后反连串化,反种类化完结后,再调用OnSerialized注明的章程。

OOAD:面向对象的类别分析与统一计划

[Serializable]
        public sealed class Circle
        {
            private double m_radius;
            [NonSerialized]
            private double m_area;

            public Circle(double raidus)
            {
                this.m_radius = raidus;
            }

            [OnSerializing]
            private void Serializing(StreamingContext context)
            {
                //此处可以添加在序列化时需要做的运算
                Console.WriteLine("On Serializing.");
            }

            [OnSerialized]
            private void Serialized(StreamingContext context)
            {
                //此处可以添加在序列化完成时做的运算。
                Console.WriteLine("After serialization.");
            }

            [OnDeserializing]
            private void Deserializing(StreamingContext context)
            {
                //此处可以添加在反序列化时做的运算
                Console.WriteLine("On Deserializing.");
            }
            [OnDeserialized]
            private void Deserialized(StreamingContext contex)
            {
                //此处可以添加在反序列化完成后做的运算,比如计算圆的面积
                this.m_area = Math.PI * m_radius * m_radius;
                Console.WriteLine("After Deserialization.");
            }

            public override string ToString()
            {
                return string.Format("Circle's area is:{0} where radius is:{1}.", Math.PI * m_radius * m_radius, m_radius);
            }
        }
[Serializable]
        public sealed class Circle
        {
            private double m_radius;
            [NonSerialized]
            private double m_area;

            public Circle(double raidus)
            {
                this.m_radius = raidus;
            }

            [OnSerializing]
            private void Serializing(StreamingContext context)
            {
                //此处可以添加在序列化时需要做的运算
                Console.WriteLine("On Serializing.");
            }

            [OnSerialized]
            private void Serialized(StreamingContext context)
            {
                //此处可以添加在序列化完成时做的运算。
                Console.WriteLine("After serialization.");
            }

            [OnDeserializing]
            private void Deserializing(StreamingContext context)
            {
                //此处可以添加在反序列化时做的运算
                Console.WriteLine("On Deserializing.");
            }
            [OnDeserialized]
            private void Deserialized(StreamingContext contex)
            {
                //此处可以添加在反序列化完成后做的运算,比如计算圆的面积
                this.m_area = Math.PI * m_radius * m_radius;
                Console.WriteLine("After Deserialization.");
            }

            public override string ToString()
            {
                return string.Format("Circle's area is:{0} where radius is:{1}.", Math.PI * m_radius * m_radius, m_radius);
            }
        }

装进(索引器(访问数组成员))

5四、类别化和反体系化的历程。
序列化:
  为了简化格式化器的操作,FCL在System.Runtime.Serialization命名空间提供了二个FormatterServices类型,该品种只含有了静态方法,且不能实例化,以下步骤描述了格式化器怎样自动类别化应用了SerializableAttribute天性的靶子
  一、格式化器调用FormatterServices的GetSerialiableMembers方法:
  

54、种类化和反系列化的进程。
序列化:
  为了简化格式化器的操作,FCL在System.Runtime.塞里alization命名空间提供了一个FormatterServices类型,该项目只含有了静态方法,且不能够实例化,以下步骤描述了格式化器怎么样自动系列化应用了SerializableAttribute特性的目的
  1、格式化器调用FormatterServices的GetSerialiableMembers方法:
  

static 不用创造对象能够直接待上访问 用static修饰的变量可能属性
通过类名来访问 属于类 对持有目标的话 保留同一个父本(版本)

public static MemberInfo [] GetSErializableMembers(Type type,StreamingContext context);
public static MemberInfo [] GetSErializableMembers(Type type,StreamingContext context);

sealed 密封的 用sealed修饰的章程 变量 类
无法被持续(拒绝被持续)(用 sealed修饰3个类 这一个类无法再有子类
用sealed修饰的不二诀窍 不可能被子类重写)

  那个点子运用反射获取项目标public和private实例字段(标志了NonSerializedAttribute脾性的除了那些之外)。方法再次回到由MemberInfo对象构成的数组,个中各类成分都对应三个可类别化的实例字段。
  贰、对象被系列化,System.Reflection.MemberInfo对象数组传递给FormatterServices的静态方法GetObjectData:

  这一个主意运用反射获取项目标public和private实例字段(标志了NonSerializedAttribute天性的不外乎)。方法重临由MemberInfo对象构成的数组,个中每个成分都对应一个可体系化的实例字段。
  二、对象被系列化,System.Reflection.MemberInfo对象数组传递给FormatterServices的静态方法GetObjectData:

构造函数无法写重返值类型 普通方法必须有重临值类型(未有重回值写void)

public static object[] GetObjectData(Object obj,MemberInfo [] members);
public static object[] GetObjectData(Object obj,MemberInfo [] members);

形参

  那一个办法重临一个object数组,其中每种成分都标志了被序死化的目的中的1个字段的值。那么些object数组和MemberInfo数组是相互的,换方之,object数组中的成分0是MemberInfo数组桐月素0所标志的老大成员的值。
  三、格式化器将次第集标志和类别的完全名写入流中。
  四、格式化器然后遍历二个数组中的成分,将各种成员的名目和值写入流中。
反连串化:
  一、格式化器从流中读取程序集标记和总体类型名称,要是程序集当前尚未加载到AppDomain中,就加载它,如若程序集不能够加载,就抛出三个SerializationException极度,对象要是不能够反种类化,也抛出塞里alizationException格外,如若程序集已加载,格式化器将顺序集标志新闻和等级次序全名传给FormatterServices的静态方法GetTypeFromAssembly:

  那一个措施再次回到三个object数组,当中每一种成分都标记了被序死化的靶子中的2个字段的值。那个object数组和MemberInfo数组是互相的,换方之,object数组中的成分0是MemberInfo数组凉月素0所标记的11分成员的值。
  三、格式化器将次第集标记和类其他完好名写入流中。
  四、格式化器然后遍历一个数组中的成分,将种种成员的名目和值写入流中。
反类别化:
  壹、格式化器从流中读取程序集标记和总体类型名称,假如程序集当前一向不加载到AppDomain中,就加载它,假使程序集不能够加载,就抛出3个SerializationException相当,对象假使不能够反类别化,也抛出塞里alizationException非常,假诺程序集已加载,格式化器将次第集标记音信和类型全名传给Formatter瑟维斯s的静态方法GetTypeFromAssembly:

措施中的变量必供给开端化赋值

public static Type GetTypeFromAssembly(Assembly assem,string name);
public static Type GetTypeFromAssembly(Assembly assem,string name);

值参数

  那个主意再次来到二个Type对象,它象征要反类别化的不行目的类型。
  2、格式化器调用FormatterServices的静态方法GetUnInitializedObject:

  这么些点子重回2个Type对象,它表示要反系列化的不胜目的类型。
  二、格式化器调用Formatter瑟维斯s的静态方法GetUnInitializedObject:

ref(引用参数) 定义和引用的时候都要写ref 把变量名(地址)传进去
使用前务供给起始化赋值(当有些方法须要修改值类型数据时,ref参数常常是适用的)

public static object GetUnInitializedObject(Type type);
public static object GetUnInitializedObject(Type type);

out(输出参数)弥补return只可以回去二个值的阙如 调用艺术此前不供给鲜明的被赋值,再次来到此前必须要赋值

  这几个点子为三个新目标分配内部存款和储蓄器,但不为对象调用构造器。不过,对象的有所字段都被开首化为0或null
  叁、格式化器今后要协会3个MemberInfo数组,具体做法和目前相同,都以调用FormatterServices的GetSerializableMembers方法,这些点子再次回到种类化好、须要反种类化的1组字段
  4、格式 化器遵照流中包括的数量创制三个object数组
  5、将新分配对象、MemberInfo数组以及并行Object数组(当中积攒字段值)的引用
传给FormatterServices的静态方法PopulateObjectMembers:

  这么些方法为2个新对象分配内部存款和储蓄器,但不为对象调用构造器。然则,对象的全部字段都被开始化为0或null
  三、格式化器以往要协会多少个MemberInfo数组,具体做法和日前同样,都以调用FormatterServices的GetSerializableMembers方法,那几个法子重临连串化好、须要反连串化的1组字段
  四、格式 化器依照流中包蕴的数目成立三个object数组
  5、将新分配对象、MemberInfo数组以及并行Object数组(在那之中包罗字段值)的引用
传给FormatterServices的静态方法PopulateObjectMembers:

ref 侧重修改 out 侧重输出

public static object PopulateObjectMembers(Object obj,MemberInfo []members,Object[] data);
public static object PopulateObjectMembers(Object obj,MemberInfo []members,Object[] data);

params(可变参数数组) 必须放在最终

  那些法子遍历数组,将各种字段初步化成对应的值。到此甘休,对象的反种类化固然成功了。\

  那几个格局遍历数组,将各个字段伊始化成对应的值。到此甘休,对象的反体系化纵然成功了。\

类中的每叁个分子都足以分成实例成员(定义在类类内,未有static修饰符修饰的)、静态成员(定义在类内
使用static修饰(静态成员属于类 不属于特定的对象
必供给由此类名去做客
)防止了创办实例的费用)两类

5五、反系列化时,格式化器是用的反光机制来成功的,而反射的快慢是极慢的,假如急需幸免反射,能够让急需连串化、反体系化的目标达成System.Runtime.Serialization.ISerializable

5五、反连串化时,格式化器是用的反射机制来实现的,而反射的快慢是比较慢的,若是需求幸免反射,能够让急需种类化、反系列化的对象完成System.Runtime.塞里alization.ISerializable

静态类的持有成员都不可能不是静态的

静态方法能够直接待上访问静态成员 不得以一贯访问实例成员(通过对象去访问)

实例方法能够平昔访问静态成员

静态成员无需初叶化(选拔数据类型的暗中认可值)

主意重载(同一类内)同名方法参数列表差异(重临值不是剖断重载的标准)

重写:父类中的方法能够被子类进行重写,从而有不一致于父类的得以完成

第贰步:把父类中的方法(允许子类重写)用virtual修饰;第一步:在子类中使用ovverride重写从父类中一连的虚方法。

new
潜伏父类的同名方法(有意隐藏)是一种静态绑定机制,由对象定义时间调节制
定义的是什么样品种 就实行定义的类中的方法 看等号左边 左侧是概念
左侧是实例化(在创设类库时很有用 能够做版本调控)

ovverride 是一种动态绑定机制,由运转时的目的说了算,看等号的右手

构造函数 类里面非凡的1种办法 名与类名同样 没有回来值
能够早先化成员变量(this 引用类当前的实例)

this 指向类自己、调用自个儿

构造函数是用new调用的

持有品种都合并自System.Object

GetType(检核对象的品类(重临Type类型))、ReferenceEquals(比较引用)、Equals(检查相等性)、GetHashCode(获得散列值)、ToString(将对象作为字符串使用)

typeof 获取对象的类型新闻(传的是项目名称)

Equals(对于字符串 把引用相等 形成了值非凡(对于引用类型,调用
ReferenceEquals)) 和 ReferenceEquals(推断引用是不是等于)

值类型包罗轻易数据类型 枚举 结构

引用类型涵盖 类 接口 数组

第4章 引用类型和值类型

类是对象的模板 对象是类的实例

枚举:1组已命名的整形常量
是强类型常量值列别,是一组描述性的名目(种种成分的功底项目是整形的
暗中同意值从0初叶 依次递增一)

结构(值类型)(也得以有构造函数(只能声名有参的)) 类是引用类型

不同:  类                          结构

引用类型                    值类型

        能够被接续                  无法被合并

        可以有暗中同意构造函数          不可能有私下认可构造函数

        能够增多无参的构造函数      只好够加上有参的构造函数

        创设对象必须用new           创立对象能够不要new

        类中得以给字段赋值          结构中给字段赋值是荒唐的

同样:都能够分包字段 方法 都得以落成接口

概念结构变量能够不要new

值类型直接存款和储蓄在栈中

Simple Type; Struct Type; Enum Type

三角形箭头指向父类

值类型指向System.ValueType(全数值类型的父类)

引用类型指向引用类型(存款和储蓄了对值的引用)

值类型和引用类型最后都指向System.Object

把值类型变量赋值给Object类型的时候,会发生自动装箱(boxing)
把Object变量赋值给2个与对象类型一样的值类型变量时, 供给展开拆箱

System.Collections;集合

System.Collections.Generic;集合的泛型

对值类型调用ToString()方法可以制止装箱

第五章 封装、继承、多态

继续:好处:升高代码重用性,落成多态

Inherit(继承):子类和父类存在is-a关系;

当有的类之间且有同1的天性和表现时,反这1部分性质和行为抽象到1个父类中:(分歧子类之间且有一致的功用,并且职能的贯彻方式也完全相同时,将该情势在父类中贯彻,进步程序代码的可重用性和可维护性;分化子类之间且有雷同的效果,但功用的贯彻情势不相同时,将该方式放在父类中声称,但不提供切实的兑现)

承继有传递性:(直接父类)(能够赢得直接父类的诀窍)

后续的单根性:2个类的直白父类唯有三个

base 在子类中代表它的父类; 在子类中调用父类的构造函数

接轨中 若是父类写了带参数的构造函数
则私下认可无参的构造函数就被带参娄的构造函数覆盖了,不设有了;子类中构造函数默许会调用父类中私下认可的构造函数(解决措施:一.
在父类中增添私下认可无参数的构造函数; 二.
在子类的构造函数中内定调用父类中留存的构造函数)

有持续时的数目起先化顺序:成立子类对象的时候,在施行子类构造函数时,如若有父类,会先调用父类的构造函数,然后调用子类的构造函数(先实例化父类的数量成员,然后再实例化子类的布局成员)

子类承继父类,父类派生子类  子类也叫派生类 父类也叫基类

有连续关系时,试行子类构造函数时事先触发推行父类的构造函数

base 调用父类的不二等秘书技 调用父类的构造函数

父类未有无参构造函数 子类必须指明调用哪个构造函数

new 静态绑定的1种机制

版本调控:承袭景况下是一个C#机制
能够对类实行修改(成立新本子)不会奇怪地改造代码的意义

开创密封类的理由:优化:密封二个类防止了与虚方法有关的种类开拓,那允许编写翻译器实行一定的优化
安全性:将类密封消除了由持续产生污染的或许性(方法和质量也能够应用sealed修饰(被音信包的点子和性质差异目的在于子类中继续)

封装encapsulation

包裹机制:属性(字段)、 索引器(数组的拜访)、 方法、
访问修饰符(有用情势:代码隐藏)

当必需公开字段的拜访时,推荐使用常量、枚举和只读字段

public、 private、 protected、 internal

花色(命名空间下)的暗中认可访问修饰符为internal

项目成员的暗中认可访问修饰符为private

内部类

多态(polymorphism(pao li mao fei ze
mu)):
类的子类表现出的行事能够各差别样,那种自身称为类的多态性

多态利用虚方法 把子类方法都重写(vartual(启用多态)override(重写)
动态绑定(看new的是哪些目的))

多态使用意况:三个顺序有1组对象(它们是例外的靶子,但它们都有共性),检查第三个档案的次序,并且施行合适的不二等秘书籍

第5章 抽象方法和抽象类

抽象类(用来约束子类的行为(强制落成多态))

用abstract声名,不可能一贯实例化(不可能new);

是用来作为基类的,用来提供三个派生类可共享的基类的公家定义
位天类承接档期的顺序的上边;

抽象类能够包涵抽象的成员
(抽象属性、抽象方法(未有方法体,用abstract修饰的方法))能够包罗非抽象的分子,以至足以分包虚方法;

子类必须兑现抽象方法,除非子类也不无抽象性

数码成员也得以抽象

泛泛方法必须用override重写

提供一层层约定,约束子类的行事(强制约束)

提供一些共性的一言一动

throw new NotImplementedException()未兑现的老大

虚方法                          抽象方法

用virtual修饰              用abstract修饰

要有方法体,哪怕是一个分行  不相同意的方法体

能够被子类override          必须被子类override

而外密封类都得以写          只可以在抽象类中

里氏替换原则:

子类的靶子能够替换其父类

父类的靶子不能替换子灰

父类的不贰诀窍都要在子类中落实或然重写

父类的可访问性不能够比子类低

虚构成员或抽象成员不可能是私有的

接口:

接口是1种规格表明定义了类必须贯彻的行事

接口定义了类之间怎么样心优秀定义和预期的行为进行互相的契约,显式定义了类之间应当怎么样开始展览互动

接口正是一组抽象成员的集合

接口类似天抽象基类:继承接口的其他非抽象类型都不能够不达成接口的装有成员

无法直接实例化接口

接口可以涵盖事件、索引器、方法和质量

接口不含有方法的得以落成 也无法包含字段

类和布局可从八个接口承接

接口自个儿可从八个接口承继

贰个类同时承袭类和接口时必须把类写在最前面

接口成员都以隐式公共的和浮泛的(不能够内定访问修饰符)

 

知足is-a用延续 不满意is-a还保有类似的职能

接口更得于程序的恢宏,抽象类使程序等级次序结构更清楚

不同点

抽象类                              接口

用abstract定义                 用interface定义

只得继续三个类                  能够达成四个接口

非抽象派生类必须兑现抽象方法    完毕接口的类达成全体成员

亟需override完结抽象方法       直接实现

相同

无法实例化  包蕴未落到实处的主意    派生类必须兑现未兑现的法门

theftproof(防盗的)   burglarproof(防盗的)

面向接口编制程序(传递接口)

第八章 委托和事件

委托 delegate(最后(本质)是类) 使程序能够在运作时动态调用不一致的艺术

它所调用的法子的称呼 该方法的参数 该办法的重临值

一类格局:具备一样的参数与再次来到值的措施

public delegate int(重返值类型) Call(委托名称)(int num一, int
num贰);委托和格局必须有所同等的参数和再次回到值

概念委托项目

[做客修饰符] delegate 再次回到类型 委托名 (形参表);

扬言委托对象

寄托名 委托实例名;

开创委托对象(分明与哪些措施开始展览绑定)

寄托实例名 = new 委托名(有些类的秘技);

应用委托调用方法

寄托实例名(实参表);

寄托项目一般声名在命名空间内 也能够创设在类内部

信托是壹种数据类型,与类的品级相同(一般定义在命名空间之内)(除非与某些类关系10分一体 写到类里面)

措施与格局之间 类型与品种之间 要保留空行 单行注释写前边

办法内逻辑用空行隔断

委托链

事件是享有类型成员身份、有限制的调用以及赋值等非常性状的嘱托

发送事件的类称为“发行者”,也叫做“事件源”

选拔事件提类称为“订户”,也叫做“接收者”

[修饰符] event 委托名 事件名;

事件实际就是壹种特有的寄托对象

delegate void MyEventHandler();

事件的扬言

class

事件的订阅就是向委托的调用列表中增加方法,是经过事件加上运算符 +=
来完毕的

事件名 += new 委托名(方法名);

要先推断事件目的是还是不是空的

事件:

概念委托(今后针对事件处理函数)

基于My伊夫ntHandler委托注解事件

概念事件的艺术(奉行事件管理函数)

订阅事件(向事件的委托链中登记格局(事件管理函数))

EventArgs(是富含事件数量的类的基类)

可怜管理

try块(可能出现相当的代码)catch块(出现非凡时对非凡的拍卖)

老大指运营时的错误finally(无论有未有异常最终都会实施)善后专业(财富的清理和刑满释放解除劳教)throw(抛出分外)是吧catch块现身的百般继续往上抛

温馨写完的代码 本身测了没有别的难题之后再交由测试

System.Exception(异常)

System.SystemException(公共语言运营时引发那些)

System.ArgumentException:System.ArgumentNullException

System.ArithmeticException:System.DivideByZeroException |
System.OverflowException

System.Data.DataException

System.FormatException

System.IO.IOException

System.IndexOutOfRangeException

| System ApplicationException(用户程序引发那些)

throw new Exception(用于抛出新的百般)

第八章 集合 范型

System.Collections.Generic;(存集合 泛型)

Ienumerable(实现了那些接口就可以foreach遍历)

<T>(T代表Type类型) | <K,V>(代表泛型)

Icollection 接口是System.Collections
中最基础的接口,定义了汇聚类型援助的行为

ArrayList(是1个可动态维护长度的集合(动态数组))(Count(个数))(.Remove(对象名)
| .RemoveAt(索引))

Hashtable(字典)

Queue(队列:先进先出的数据结构(FIFO))

SortedList

Stack(酒店(后进先出(LIFO)))

Idictionary<K, V> 是Hashtable的泛型版

泛型接口

选拔非泛型类达成泛型接口(泛型接口必须钦定数据类型,失去了泛型接口的意义)

利用泛型类落成泛型接口

概念1个泛型类 后面能够用where限制T的档次

where : struct 值类型

where : class 引用类型 类 接口 委托 数组

where : new() 必必要包蕴无参数的结构函数 与别的约束共同使用时,
必须最终钦赐

where : <基类名> 是钦定类或它的派生类

where : <接口名称> 可钦点四个接口约束,约束接口也足以是泛型的

where : U T 要么是U类型 要么是U类型的子类

IComparable[<>],Icomparer[<>] 相比较接口

信托名 = () => {方法体};(一条语句能够简轻巧单{}和return);

Lambda表达式 =>(gos to(分隔符))
左边是参数列表定义(无参数的写括号; 贰个参数能够省略小括号)
右边是方法体的概念方法体的多条语句用大括号括起来

using System;

 

namespace 泛型委托

{

    class Program

    {

        static void Main(string[] args)

        {

            //调用TestMethod

            //法一

            //Call call = Say;

            //TestMethod(call);

            TestMethod(Say);

            Console.WriteLine(“——————————-“);

 

            //法二

            //call = delegate(int num) { return num * 10; };

            //TestMethod(call);

            TestMethod(delegate(int num) { return num * 10; });

            Console.WriteLine(“——————————-“);

 

            //法三

            //call = x => x * 10;

            //TestMethod(call);

            TestMethod(x => x * 10);

            Console.WriteLine(“——————————-“);

 

            Console.ReadKey();

        }

 

        private static int Say(int num)

        {

            return num * 10;

        }

 

        public static void TestMethod(Call call)

        {

            int re = call(10);

            Console.WriteLine(re);

        }

    }

 

    public delegate int Call(int num);

}

泛型类便是二个模板类(泛型参数)

Action 无参数 无重临值的信托

Action<T…> 有n个参数 无重临值的信托(0 <= n <= 1陆)

Func<T…> 有n个参数 有钦点再次回到值类型的寄托(0 <= n <= 1陆)

Binary 二进制

DirectoryComputer目录结构

DriveInfo计算机驱动器的详细消息

File、FileInfo

Environment.CurrentDirectory(物理路线)

Exists(检验文件是还是不是存在)

文本操作

成立文件流

[创建读写]

试行读写操作

[闭馆读写]

关闭文件流

FileMode枚举 Create(创造新的 已存在就改写) Open(展开)
CreateNew(创制新的 已存在报错) Append

FileAccess

FileShare(None(读占))

StreamWriter创立写入器,写入叁个流

大文件读写

Using 语句

实现Idisposable接口的类能够用using语句自动释放财富

常用的有(File Font等)

四个对象用’,’分隔

 

System.Text.Encoding.Default.GetString(bytes(字节数组))字节数组直接转成字符串

System.Text.Encoding.UTF8.GetBytes(info(字符串))将字符串调换到字节数组

写入必写:fs.Flush() 清空缓冲区,确定保证写入文件

优点:

XML文书档案的故事情节和组织完全分离

互操作性强:作为纯文本格式的公文,可以1本万利也超过防火墙,在不一致操作系统上的例外种类里头通讯

专门的工作统壹:XML具备合并的正式语法

支撑多样编码

可扩展性强

使用:

数据交流(Json)

Web服务

内容管理

Web集成

参数配制

结点的品质 结点的剧情

XmlDocument 表示最近XML整个文档

DocumentElement属性 获取根节点(Element(成分))

ChildNodes 获取全体子节点

Load() 读取全方位XML的组织

XmlNode 目的表示XML文件的单个节点(不分根结点依旧子结点)
子节点都以XmlNode

Load() 读取全方位XML的结构

InnerText属性 当前节点的值

Name属性 当前结点名称

ChildNodes属性 当前节点的全数子节点

TreeView控件 每一次都要清空节点 不然会助长

Tag属性 能够绑定与指标关系的用户定义数据

bookNode.Attributes[“”].value;

SelectSingleNode 选择唯1的叁个结点

SetAttribute(“属性”, “值”) 增添属性

AppendChild() 括号中增添到调用都的子结点的终极

Save()保存

RemoveChild() 删除节点

系列化/反种类化(serialization)

GUI图形用户分界面

[Serializable]特色标识的才方可种类化(想要系列化 他的父类也要标志)

System.Runtime.Serialization;命名空间下

BinaryFormatter(二进制格式化器)

SOAP:轻便对象访问协议

[NonSerialized]不被系列化

System.Runtime.Serialization.Frmatters.Soap;

System.Xml.Serialization

XmlSerializer xs = new XmlSerialiser(类型)

自定义体系化需求让类落成Iserializable接口

自定义构造函数 传对象(完结接口的一样)(反种类化时用)

Procss进程

Thread线程 进度的贰个实践单元,四个进度能够涵盖若干个线程

线程是CPU调解和分红的为主单位

各样进程都有二个主线程

suspended  轮询

Process.GetProcesses(“”)钦点Computer上的进度列表

ListView控件 帮助视图(View属性 有八种视图)(Details(彰显多列))

ListViewItem ListView的数目项

LargeImageList(大Logo列表)

Details 要安装列的集合

多线程

System.Threading 命名空间

Thread类

IsAlive属性 指令当前线程执行情况

IsBackround 提示有些线程是还是不是为后台线程

Priority属性

Start方法 运转线程

Join方法 一般出现在Abort之后

Sleep方法

Abort方法 引发ThreadAbortException 初始甘休此线程

调用Sleep方法的是类的自个儿,而不是类的实例

休眠的是该语句所在的线程,而不是别的线程

Highest AboveNormal Normal BelowNormal Lowest(优先级)

Main 方法是主线程

同一时半刻间唯有1个进度能跻身代码临界区

在非创立控件的线程中做客控件,那是C#中区别意的

各样控件上都有二个方式叫Invoke(在具备控件的基础窗口句柄的线程上,用钦点的参数列表试行钦赐委托)

IP(Internet Protocol(Internet网络协议))

21 FTP协议

2三 远程登入

25 SMTP(Simple Mail Transfer Protocol(简单邮件传输协议))

伍三 域名服务器(DNS)

80 HTTP协议

OSI
开放系统互连参考模型(物理层、数据链路层、网络层(IP协议)、传输层(TCP协议)、会话层、表示层、应用层)

TCP/IP
是壹组网络通讯协议的总称,它标准了网络上的享有通讯道具,特别是二个主机与另3个主机

System.Net;

IPAddress IP地址的更换、管理等功用

Dns 本地或远程域名等职能

IPHostEntry Internet主机相关音讯

IPEndPoint 网络地址表示为IP地址和端口号

套接字

套接字是支撑TCP/IP协议的网络通讯的基本操作单元(能够看作是不一致该机间的长河张开双向通讯的端点,构成了单个
主机内及想个网络间的编制程序分界面)

Socket(套接字)

Network Management Software(互连网使用)

套接字 分同步 异步两种

一同在经过Socket举办连接、接收、发送操作时,客户机或服务器在吸收到对方响应前会处于阻塞状态。它适用于数据管理不太多的地方

异步在经过
Socket进行连接、接收、发送操作时,客户机或服务器不会处在阻塞情势,而是使用callback(回调函数)机制举办三番五次、接收和发送管理,那样的能够在调用发送或收到的办法后一贯回到,并继续推行下边包车型大巴程序管理

System.Net.Sockets

常用的多少个类:TcpClient(用于连接、发送和接收数据)
TcpListener(用于监听是还是不是有传出的连日请求)

UdpClent UDP(用户数量报业协会议)

Socket类

面向连接的套接字之间的连日进程能够分为多个步骤:服务器监听,客户端请求,连接确认

属性:

ReceiveBufferSize 接收缓冲区大小

SendBufferSize 发送缓冲区大小

方法:

Colse 关闭TCP连接并释放与TcpClient关联的能源

Connect 将利用主机名和端口号将客户端连到远程TCP主机

GetStream 重返用于发送和接收数据的NetworkStream

Buffer(缓冲区)

TcpListener 具备侦听进入的TCP连接的办法

方法

AcceptSocket 再次来到与经过客户端通讯的套接字

AccepTcpClient 接受的总是请求

Start 初始侦听进入的接二连三请求

Stop 关闭侦听器

程序集:.exe .dll

次第会集构:程序集清单、类型元数据、IL代码、能源

AssemblyInfo.cs用于配置程序集的(在Properties文件夹下)

元数据:完整地描述类型(类 接口 结构 枚举 委托)的力量
是.NET平台的完全上首要因素

Extends(继承)

Field (源数据)

特性纵使用来项目(类、接口、结构等)、成员(属性、方法等)、程序集或模块的代码注明(最要害目标便是自描述)

[CL SCompliant] 强制被讲明项遵守CLS

[DllImport]
允许.NET代码调用肆意非托管的C或C++基类库,包括操作系统中的API

[Obsolete] 过时的 带true就会产生编译错误

[Serializable] 可种类化

[NonSerialized] 不可类别化

[WebMethod] 可通过HTTP请求调用

Attribute 全部属性的基类

自定义特性类要在最后缀上Attribute

GetType() typeof()

反射(reflection) 反射用于在运营时通过编制程序情势得到类型音讯

Assembly

AsseblyName

EventInfo

MemberInfo

MethodInfo

ParameterInfo

PropertyInfo

Type t = Type.GetType(“类型名称”);

t.GetMethod();获取相应品种的持有国有措施

t.Get菲尔德s();获取相应品种的有所公共字段

t.GetProperties();获取相应品种的保有国有性质

t.GetInterfaces();获取相应档案的次序的贯彻或继续的具备接口

t.BaseType;获取第一手父类

t.IsAstract;(是还是不是画个饼来解除饥饿的)

t.IsSealed(是否密封的)

t.IsGenericTypeDefinition(是还是不是泛型定义)

t.IsClass(是或不是类)

t.IsInterface(是或不是接口)

末尾绑定:是壹种创制三个给定类型的实例并在运营时调用其成员,而不要求在编译时知道它存在的一种手艺

反射正是1种晚期绑定(开支越多的系统财富开支使得应用程序能够在运营时获得一些不敢问津的音信)

Assembly ass = Assmbly.LoadFile(“程序集路线”);加载程序集

Type t = ass GetType(“MyAssembly.Car”);

ass.CreateInstance(“钦命项目”);(使用系统激活器创立类的实例)成立对象(通过反射创立的靶子都以object类型)

Activator(System命名空间下)(使用暗许的构造函数成立类的实例)

Instance(实例)

MethodInfo m = t.GetMethod(“方法名”);

m.Invoke(, )多少个参数 3个是程序集对象
二个是object类型的数组(方法再次回到值也是object类型的)

 

 

 

版权评释:本文版权归小编和新浪共有,应接转发,但未经作者同意必须保留此段申明,且在篇章页面明显地方给出最初的小说连接,不然保留追究法律权利的职责。

作者:黯淡の青春    博客地址:

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website