• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

[读书笔记]《C#本质论》读书笔记

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

 

 

【Note】局部变量名采用的是camel大小写形式,而且不包含下划线

【Note】隐式类型var
匿名类型的一个实例赋给一个隐式类型的变量:
var patent=
new { Title = "Bifocals",
YearOfPublication = "1784"};


【Note】可空修饰符
如 int? count = null;


【Note】默认情况下unchecked,即赋值溢出时采取截断,可以选择checked来引发异常

 


【Note】交错数组

声明一个交错数组: (内部数组都要实例化)
int[][] cells={
new int[]{1,0,2,0},
new int[]{1,2,0},
new int[]{1,2},
new int[]{1}
};

【Note】数组的Length属性问题

正常数组的Length是取得数组所有元素的总数
交错数组是取得内部包含的数组的数目
上面的cells.Length就等于4

int[,] array1 = new int[2, 3]; // 定义一个 2 X 3 的数组


int allLen = array1.Length; // 获取所有维度的元素数 6

int d1Len = array1.GetLength(0); // 获取第一个维度的元素数 2

int d2Len = array1.GetLength(1); // 获取第二个维度的元素数 3

【Note】一些数组的静态方法
string[] stringArray = new string[] {.....};
System.Array.Sort(stringArray ); //升序排序
System.Array.BinarySeach((stringArray ,"匹配内容") //该方法调用之前必须先Sort
System.Array.Reverse((stringArray) //将数组内的元素反序
System.Array.Clear(stringArray,0,stringArray.Lengh) //将数组内的元素置为默认值

【Note】数组的一些实例方法
Length
GetLength()
Rank //获取整个数组的维数
Clone()

【Note】数组的定义以及取值
int[,] xxx = new int[3,4];
int sss = xxx[0, 0];

int[][] fff = new int[3][]; //交错数组

*foreach遍历 交错数组是一个一个的数组 普通多维数组是一个一个的值

【Note】空接合运算符
例: fileName??"default.txt"

【Note】C#的命名空间必须显式导入,不能像java那样使用通配符 import javax.swing.*;
即C#不会导入任何嵌套的命名空间


【Note】函数参数
传入功能(传值) 传入传出功能(传引用ref) 传出(out)

【Note】参数数组
(1)要在方法声明的最后一个参数声明前面添加params,不能在非最后一个参数前面加
(2)最后个参数要声明为数组
实参可以逗号隔开,也可以以数组的形式

例: static void temp( params string[] par){} //声明方法
temp("sdfs", "sadasd"); //调用方法

【Note】函数声明的可选参数
例: static int function(string str1, string str2 = "str2Value")

* 默认值只能是常量


【Note】函数调用的命名参数
例: public void functions(string str1,string str2="str2Value,string str3="str3Value"") //函数声明
function(str1:"myValue" , str3:"myValue");//函数调用

 

【Note】属性支持为set和get添加访问修饰符
(该修饰符必须比该属性的修饰符 严格,比如属性是private,set和get就不能是public)

【Note】属性和方法调用不允许作为ref和out参数值使用


【Note】对象初始化器
Employee employee1= new Employee("Inigo","Montoya")
{Title="title" , Salary="Not enough"};


【Note】集合初始化器
List<Employee> employees = new List<Employee>()
{ new Employee("Inigo","Montoya"),
new Employee("Inigo","Montoya")
};

【Note】构造器初始化器

class myClass
{
public myClass(){ //其他代码 }

public myClass(string str):this(){ //其他代码 }

}

* 在构造函数内部是调用不了其他构造函数的,不像普通函数的重载

【Note】将匿名类型的实例赋给隐式类型的局部变量
var par = new { value1 = "par_value1", value2 = "par_value2" };
var par2 = new { par.value1, value2 = "par2_value2" };

System.Console.WriteLine(par2.value1);

最终输出par_value1

【Note】静态类
编译器会自动在CIL代码中将静态类标记为abstract和sealed。
* abstract说明不能实例化
* sealed说明不能被继承
* 仅包含静态成员
* 不能包含实例构造函数,但仍可声明静态构造函数
* 不能显式指定任何其他基类。
* 静态类不能实现接口(接口不能包含静态方法,而静态类不能包含实例方法)
* 静态类的成员不能有protected或protected internal访问保护修饰符。

【Note】扩展方法

1.定义一个静态类以包含扩展方法。该类必须对客户端代码可见。

2.将该扩展方法实现为静态方法,并使其至少具有与包含类相同的可见性。

3.该方法的第一个参数指定方法所操作的类型;该参数必须以 this 修饰符开头。

4.在调用代码中,添加一条 using 指令以指定包含扩展方法类的命名空间。

5.按照与调用类型上的实例方法一样的方式调用扩展方法。
(使用扩展方法最好的途径是通过继承来特化一个类型。如果扩展方法的签名跟类型已有方法的签名一样,那么扩展方法就会被覆盖。通过调用代码很难判断一个方法是不是扩展方法,如果对源代码没有控制权。问题就更加严重)

【Note】const
* const字段自动成为static字段
*const 字段只能在该字段的声明中初始化

【Note】readonly
* 与const不同,readonly只能用于字段,被声明的字段只能在构造器中修改,或者直接在声明时指定
* 与const不同,readonly字段可以是实例字段,也可以是静态字段,每个实例字段的值可以不同
*关键区别 const 字段为编译时常数,而 readonly 字段可用于运行时常数,如下例所示:
public static readonly uint timeStamp = (uint)DateTime.Now.Ticks;
*如果将readonly用于数组,只会冻结地址,而不会冻结内容

【Note】分部类
partial class className{} (原来的类也要加上partial)
*分部类不允许对编译好的类(其他程序集的类)进行扩展,只能运用与同一程序集

【Note】分部方法
在原来的类提供声明,在新增的类提供实现
* 分部方法只能是void,不能使用out,可以使用ref
*由于上面的规则,使得分部方法不必实现也不会产生任何影响

【Note】基类和派生类之间的转型
派生类可以隐式转换成基类,隐式转换不会为基类实例化一个新的实例,相反同一个实例会被引用为基类型


【Note】private
“派生类不能访问基类的private成员”
*假如派生类同时是基类的一个嵌套类,就不成立了

【Note】protect
基本规则:要从一个派生类中访问一个对象的受保护的成员,必须在编译的时候确定受保护的成员是派生类的一个实例
例: public class PadItem
{
protected string Name;


public class Contact: PadItem
{
void Load(PadItem padItem)
{
padItem.Name=... //这里出错
}

}

【Note】C#多重继承的一般解决方案————聚合
public class A {} //需要被继承的类


public class B //需要被继承的类
{
protect int first ;
}

public class C : A //C作为基类,直接继承A
{
private B BIntence { get ; set ;}

public int FIRST
{ get{return B.first} set{B.first=value}}
}


【Note】virtual
基类: virtual修饰方法
派生类: override 修饰方法

* virtual不能与static同时使用,因为当一个方法被声明为Static时,编译器会在编译时保留这个方法的实现(它属于类),而当一个方法被声明为Virtual时,直到你使用ClassName variable = new ClassName();声明一个类的实例之前,它都不存在于真实的内存空间中

* 不要在构造器中调用会影响所构造对象的任何虚方法,与C++不同(C++构造期间的virtual方法总是调用基类的实现),C#是根据设计原则:总是调用派生得最远的虚方法,即使构造函数尚未完全执行

 

【Note】C#规定只能使用下面这些限定符中的一个:
override virtual static abstract sealed
代表的含义分别为:
重载函数、虚拟函数、静态函数、抽象函数、密封函数(不可派生)


【Note】new实现的重载
在C#的角度看,new唯一的作用就是消除编译的警告
new跟override区别: new的重载没能实现多态


【Note】abstract类
次要特征:不可实例化
主要特征:类包含抽象成员
基类方法用abstract修饰
派生类用override修饰重载
*抽象方法是隐式的虚方法,其实现只能由派生类实现,而vertuial标记的虚方法可以由基类实现


【Note】is
public static void Save(object data)
{
if (data is string )
{
data=Encrypt((string)data); //加密数据
}
}

*在使用is之前,可以优先考虑多态性,比如在上面的例子中,从一个通用的基类派生,然后将这个基类类型作为Save()方法的一个参数调用,就可以避免显式地检查string

* as是强制转换类型,is是判断类型,假如一个对象object可以as成string,但他不一定is string判断的时候是true,as只能作用与引用类型,转换失败不引发异常

【Note】接口
* 区别:通过基类来共享成员签名,而接口只是共享成员签名
* 命名规范:采用Pascal大小写规范,第一个字母I开头
* 不包含实现,不包含字段,可以包含属性
* 所有成员不能有修饰符,CLI默认是public
* 接口不能包含static
* 接口不能显方用abstract修饰,因为CIL默认了abstract

 


【Note】接口的显式实现和隐式实现
* 显式实现不能添加修饰符,成员名称前面要添加接口名和一点作为前缀
* 显式实现的访问:实现接口的类的对象不能直接访问实现的方法,要先转换成接口对象,由接口对象来访问
* 隐式实现 修饰符只能是public,可选属性是virtual,如果没virtual,则该成员默认为sealed
* 总之,采用显式实现,接口方法就不作为实现接口的类的类成员,采用隐式实现,接口对象和实现接口的对象都能看见


【Note】接口设计的原则
(1)接口成员书不是核心的类功能?
如果接口方法单纯只是辅助方法,那就采用显式实现,若改接口方法是该类的主要功能,就采用隐式实现

(2)接口成员名作为类成员是否恰当?
名称是否产生歧义?总之一个接口成员在类中的用途不是很明确,就采用显式

(3)是否已经有一个同名的类成员?


【Note】接口的继承
interface IFirstface
{
int getNum();
}

interface ISecondface : IFirstface
{
int getNum2();
}

class Myclass : ISecondface
{
int IFirstface.getNum() //!!这里必须引用最初声明它的那个接口
{
return 1;
}

int ISecondface.getNum2()
{
return 2;
}

}

方法引用问题:
Myclass my = new Myclass();
ISecondface Is = my;
Is.getNum(); //!!派生的接口可以访问所有接口成员
Is.getNum2();

【Note】扩展方法在接口的应用
* 不要跟分部方法混淆了


【Note】通过接口来实现多重继承
下面例子是使用了 聚合和接口的方法:

class A{}

interface IB //IB确保B类和复制到C类的成员有
{ //一致的签名
string Str
{
get;
set;
}
}
class B:IB
{
public string Str
{
get { return "getStr";}
set { }
}

}

class C : A, IB
{

private B _B;

public string Str
{
get { return _B.Str; }
set { _B.Str = value; }
}
}

但是添加到B类的新成员不会同时添加到C类上,这还没有做到与“多重继承”同义

解决办法:
如果被实现的成员是方法(不是属性)的情况,
可以采用扩展方法对IB进行扩展,
这样凡是实现了IB的类都有了扩展的新方法

【Note】版本控制
* 扩展功能的办法 从一个原有的接口派生出一个新的接口


【Note】抽象类跟接口的比较
-----------------------------------------
抽象类:不能脱离它的派生类来实例化。抽象类构造器只能由它门的派生类调用
接口:不能实例化,不能有构造器
--------------------------------------------
抽象类:定义了实现类必须实现的抽象成员签名
接口:接口的所有成员要在实现类实现,不能只实现部分成员
-------------------------------------------
抽象类:扩展性比接口号,不会破坏任何版本的兼容性。在抽象类中,可以添加附加的非抽象成员,它们可以由所有派生类继承
接口:如果添加更多的成员扩展成员,会破坏版本兼容性
-----------------------------------------------
抽象类:可以包含存储在字段中的数据
接口:不能存储任何字段。只能在派生类中指定字段。解决办法就是在接口中定义属性,但不能包含实现
--------------------------------------------
抽象类:可以包含实现的virtual成员,所以能为派生类提供一个默认的实现
接口:所有成员自动成为virtual成员,而且不能包含任何实现
-----------------------------------------
抽象类:会占用之类唯一一个基类选项(单继承)
接口:最然不允许默认实现,但是实现接口的类可以继续相互派生

【Note】结构体
--------------------------
一个良好习惯:
应该确保值类型不变的。属性只有get而没有set。如果确实要修改,应该通过一个方法返回新的实例。 *思考为什么?*
-----------------------------------

* suruct跟类差不多,可以有字段,属性,方法,可以定义含参构造器,但是不能显式定义无参构造器(有时候根本不会调用构造器,比如定义数组的的时候,会直接采用默认值初始化,若可以自定义默认构造器,那么有时调用,有时不调用,所以初始化不统一了,因此C#禁止struct自定义默认构造器)
* 不能声明一个字段的同时进行初始化,原因同上
* 支持含参构造器,要求必须对所有字段初始化,否则编译报错
* 值类型都是密封的
* 值类型继承链:object->ValueType->struct
* 值类型还可以实现接口

【Note】必须要拆箱成为基础类型,例int 装箱成object,那只能拆箱成int,不能double之类的其他类型

【Note】lock语句不能用于值类型
假如用了值类型,那么就会装箱成堆的一个引用,与原来在栈中的引用对比总是不同的

【Note】说明值类型(struct)不可变的重要性
----------------------------------
IAngle是声明方法MoveTo的接口
Abgle是实现IAngle接口的类
其中MoveTo在Angle中改变其字段value的值,而不是返回一个新值的新实例
--------------------------------------

Angle angle = new Angle(25);
object objectAngle = angle;

((Angle)objectAngle).MoveTo(26);
输出:(Angle)objectAngle.value //25


((IAngle)angle).MoveTo(26)
输出:((Angle)angle).value // 25


((IAngle)objectAngle).MoveTo(26)
输出:((Angle)objectAngle).value //26

【Note】避免拆箱
* 拆箱指令不包括将数据复制回栈的动作
* 接口是引用类型,当通过接口访问已装箱的值时,拆箱和复制就可以避免

【Note】枚举之间的转换

MyEnum mm = MyEnum.A;
MyEnum2 mm2 = (MyEnum2) (int) mm;

----------
下面枚举数组的转换:
MyEnum[] mm= (MyEnum[])(Array) new MyEnum2[42];
这里利用了CLR的赋值兼容性比C#宽松的事实,
先转换成数组,在转换成第二个枚举,
前提是两个枚举具有相同的基础类型


【Note】枚举作为标记使用
[Flags]
enum MyEnum
{
A = 1<<0,
B= 1<<1
}
MyEnum mm = MyEnum.A | MyEnum.B;
Console.WriteLine(mm);
输出: A,B

如果没有 [Flags]特性,就会输出3

【Note】重写object的成员
* 重写ToString()
* 重写GetHashCode()
* 重写Equals(),必须同时重写GetHashCode()

【Note】重载运算符没看

【Note】类型封装
* 没有任何访问修饰符的类会被定义成internal(排除嵌套类,它默认是private)
* 命名空间中的类型声明可以只可以具有 public 或 internal 访问,默认internal
* 嵌套类可以使用public,internal,private,protected,protected internal
----------------------
嵌套类修饰符:
public:如果包容类是internal,则成员只在内部可见,如果是public,那么就可以从程序集外部访问

internal:成员只能从当前程序集访问

private:成员只能从包容类访问

protected:成员可以从包容类,以及派生的任何之类中访问,不管程序集是哪个

protected internal:成员可以从同一程序集的任何地方访问,并且可以从包容类型的任何派生类中访问,即使派生类不在同一程序集中


【Note】命名空间
可以嵌套定义:
namespace aaaa
{
namespace bbbb
{

}
}
也可以直接这样
namespace aaaa.bbbb
{

}
在CLR中是一样的

【Note】垃圾回收
* 在一些关键代码运行之前,可以先调用System.GC的Collect()方法,显著减少GC运行的可能性

* 弱引用(System.WeakReference)
private WeakReference Data;
public FileStream GetData()
{
FileStream data = (FileStream)Data.Target;
if (data != null)
{
return data;
}
else
{
//重新加载数据到弱引用Data
data = (FileStream)Data.Target;
return data;
}
}
上面代码要注意:
这里要先将弱引用Data的数据先赋给data先,
从而避免在"检查null"和"访问数据"两个动作之间,
垃圾回收器将弱引用清除


【Note】终接器
* 声明定义:~类名(){ }
* 终接器不负责回收内存,它主要职责是释放像数据库连接和文件句柄之类的资源

【Note】使用using进行确定性终结
* 终接器的调用是不确定性的,所以它只能作为后备机制
* 实现IDisposeable接口
public coid Dispose()
{
Close();
System.GC.SuppessFinalize(this);
//SuppessFinalize的作用是将this从终结队列(f-reachable)
//中移除,移除之后才能真正成为垃圾
}
* 使用using代码块,或者try/finally

【Note】资源利用和终结的指导原则
* 最好避免重写Finalize方法(总结方法),这会推迟垃圾回收,如果是数组,那么数组里面每一个对象都要执行一次终结方法
* 有终接器的对象应该实现IDisposeable来支持确定性终结
* 终接器应避免任何未处理的异常
* 像Dispose(),close()这样的方法应该调用System.GC.SuppessFinalize(this)使垃圾更快清理
* 资源清理方法应该足够简单,着重清理引用的资源,不要再引用其他对象
* 若基类实现了Dispose(),派生类应该调用基类的实现
* 调用Dispose()之后,对象不能再使用,出了调用Dispose(),Dispose()可以多次调用

【Note】延迟初始化
* 可以在属性的get里面判断为null的时候才进行成员初始化
*新方法:采用System.Lazy<T>

【Note】异常处理的指导原则
* 只捕捉你能处理的异常
* 不要隐藏你不能完全处理的异常
* 尽可能的少用Ststem.Exception
有些异常如OutOfMemoryException和StankOverflowException,这些异常不能捕捉到不处理,在CLR4中会采取关闭应用程序作为最佳操作,所以捕捉到应该保存易丢失数据,然后马上关闭程序,或者throw语句重新引发异常。
* 避免在调用栈较低的位置报告或记录异常(不记录异常的原因是 怕高级的栈重复引发异常导致重复记录)
* 在一个catch块中使用throw而不是throw <异常对象>(否则栈追踪不到原始位置)
* 重新引发不同的异常要小心
不仅会重置引发点,还会隐藏原始异常

【Note】模版接口使得类可以重复实现一个接口
class tempClass: IContainer<Address>,IContainer<Phone>
改进措施: 使用IContainer<object>

【Note】泛型类/接口的构造器
* 构造器跟普通类或者接口的构造器就行了,不能添加<T>,否则编译不能通过
* 在构造器赋值过程中,由于不知道T的具体类型,所以可以采用default()方法赋初值


【Note】Tuole 元组
* Tuple<int,string> temp= new Tuple<int,string>(20,"str");
* Tuple<int,string> temp= Tuple.Create(20,"str");
如果参数很多就用工厂方法create(),否则new一个元组太长了


【Note】接口约束

情景:在一个泛型类里面,因为要对T类型的对象排序,所以将对象转换成IComparable<T>对象,一般情况可以运作,但是如果传进来的T类型没有实现接口的话,必然出错。跟C++不同,C#不支持在类型参数上调用运算符(+,-,*等),它们是静态的,不能表现为接口或者基类约束的形式.

接口约束: class tempClass<T> where T:System.IComparable<T>

【Note】基类约束
* class tempClass<T> where T:基类名

【Note】struct/class约束
* class tempClass<T> where T:struct (这里约束T必须为值类型)
* struct/class约束不能与基类约束一起使用,因为那是没意义的


【Note】构造器约束
* class tempClass<T> where T:new() (这里约束T必须实现默认构造器)
* 不能约束含参构造器

【Note】含有约束的继承
* 约束可以由一个派生类进行继承,但是派生类必须显式地写出所有的约束,这样的设计是为了提高程序员使用派生类时的认知度,避免发现有约束时,却不知道约束从哪里来

* 相反情况:重写一个虚泛型方法,或者创建一个显式接口方法实现时,约束是隐式继承的,显式写出来反而编译出错

【Note】不允许的约束
* 泛型 不能提出对运算符的要求
比如方法签名(T first,T second),不能进行first+second运算
因为没有办法限制一个类必须有一个static方法,例如,接口不能指定static方法

* 泛型约束不支持OR条件
class tempClass<T> where T:IComparable<T>||Ifrmattable(这是错的)

* 不能约束 类型参数是委托或者枚举类型


【Note】泛型方法中的转型
有时候应该避免使用泛型
如下面代码:
public static T Deserialize<T>( Stream stream,Iformatter formatter)
{
return (T)formatter.Deserialize(stream);

}

执行formatter.Deserialize(stream)会返回一个object
在泛型方法里面执行转型,假如没有约束来验证转型的有效性,
那么级一定要非常小心了

但是真正调用的时候是下面情况:

string greeting=
xx.Deserialize<string>(stream,formatter)

上面代码看起来好像是强类型的
但实际上已经进行了隐式转换

如果改成:
string greeting=
(string)xx.Deserialize(stream,formatter)

这样应该更好描述代码所发生的事情


【Note】协变与逆变(主要应用与接口和委托)
参考文章:
http://www.cnblogs.com/artech/archive/2011/01/13/variance.html

例:
public delegate TResult Func<in T, out TResult>(T arg);

简单理解:
协变:父类引用子类
逆变:子类引用父类

在委托中,返回值用out 参数是属于输入值,用in
...

下面提起几个泛型协变和反变容易忽略的注意事项:

1. 仅有泛型接口和泛型委托支持对类型参数的可变性,泛型类或泛型方法是不支持的。
2. 值类型不参与协变或反变,IFoo<int>永远无法变成IFoo<object>,不管有无声明out。因为.NET泛型,每个值类型会生成专属的封闭构造类型,与引用类型版本不兼容。
3. 声明属性时要注意,可读写的属性会将类型同时用于参数和返回值。因此只有只读属性才允许使用out类型参数,只写属性能够使用in参数。

推理:
如果一个接口需要对T协变,那么这个接口所有方法的参数类型必须支持对T的反变
推理的例:
nterface IFoo<in T>
{

}

interface IBar<out T>
{
void Test(IFoo<T> foo);
}

如果一个接口需要对T进行协变或反变,那么这个接口所有方法的返回值类型必须支持对T同样方向的协变或反变


【Note】委托的声明
* C#编译器不允许定义一个直接或间接通过System.Delegate派生的(System.MuticastDelegate是System.Delegate的系统派生的子类)

* 使用delegate关键字声明一个委托数据类型
public delegate void MyFirstDelegateHander(int par1,string par2);

* 若委托是声明在一个类里面,那它便是一个嵌套类了

* 例如上面定义的MyFirstDelegateHander委托,是一个引用类型,但是不必使用new来实例化,直接传递函数名称,而不是实例化,这是C#2.0开始支持的委托推断


【Note】匿名方法与委托
* xxxHander xx= delegate(int first,int second){ return "asdasd"}
这里的delegate声明了一个委托字面量

*匿名方法允许省略参数列表,甚至委托类型发生了变化,只要返回类型与委托的返回类型兼容
delegate{ return "xxxx"}


【Note】系统定义的委托:Func<> Action<>(.net3.5开始存在)


【Note】Lambda
前提背景:delegate bool ComparisonHaander(int first,int second)

(int first,int second)=>{ return first<second}

还可以省略参数类型:
( first, second)=>{ return first<second }

无参数的情况:
Func<string> getUserInput=()=> {..return "input value"}

linq中:

表达式Lambda:
dx.tb_attachment.Where(item => item.a_id==1);

语句Lambda:
dx.tb_attachment.ToList<tb_attachment>().Where(item => { int a; return item.a_id == 1; });

【Note】Lambda表达式不是clr内部固有构造,它们的实现是由C#编译器编译时生成的
在clr中,匿名方法会被转换成一个单独的有编译器生成的静态方法

【Note】Lambda表达式使用外部变量(闭包)
如果匿名函数使用了外部变量,那么当这个委托执行的时候依然可以使用,这种现象称之为闭包(在clr中会定义一个闭包,外部变量和匿名函数都将定义成为这个闭包的实例成员)


【Note】表达式树(没看懂什么意思)

1.Lambda表达式作为数据使用
dx.tb_attachment.Where(item => item.a_id==1);
这里表达式会转换成sql语句发送到数据库,让数据库筛选得到数据再返回

2.表达式叔作为对象图使用(??????)

3.Lambda表达式和表达式树的比较(???)

4.解析表达式树(???)


【Note】多播委托来实现Observer模式
* 声明在发布者类里面的委托是嵌套类,其他类里面是不能使用TemperatureChangeHandler的
public delegate void TemperatureChangeHandler(float newTemperature);

* 调用一个委托之前谨记要判断委托是否为null
判断方法:
TemperatureChangeHandler localOnChange = OnTemperatureChange;
if (localOnChange!=null)
{
localOnChange(value);
}
要先将委托复制到一个局部变量,防止判空和调用委托之间所有订阅者被移除(由一个不同线程),否则为空的时候会出错

* 委托虽然是个引用类型,但是增加或者减少一个委托都会重新返回个全新的多播委托


【Note】多播委托一般使用-= 和+=,但是使用了复制符号=之后,会用新的订阅者代替它们,为解决这个问题,需要使用事件;

【Note】多播委托链中一旦其中一个订阅者发生异常中断,后续的订阅者就接收不到通知
解决这个问题,可以在发布者触发委托的时候用try/catch 逐个逐个触发


【Note】还有个情形需要逐个触发委托:如果委托有返回值或者参数有ref 或者out的时候

 

【Note】总结委托存在的问题
1.错误的使用赋值符号(事件订阅的封装性问题)
2.从事件包容者外部触发事件(事件发布的封装性问题)
3.普通委托另一个弊端,就是容易忘记在调用委托之前检查null值

采用event:
public delegate void TemperatureChangeHandler(object sender,TemperatureArgs e);
public event TemperatureChangeHandler OnTemperatureChange = delegate { };

可以解决上述问题:
1.event禁止赋值
2.event不允许在类外部执行触发
3.初始值delegate { },可以不必每次检查null,因为event限制事件的赋值只能发生在类的内部


采用泛型委托版本:
public delegate void EventHandler<T> (object sender,T e) where T:EventArgs;
由于从C#2.0开始内置上述代码,说可以改写成:

public event EventHandler<TemperatureArgs> OnTemperatureChange = delegate { };

【Note】自定义事件
* 可以修改委托的作用域,使它private变成protect
* 可以添加订制的add和remove

【Note】为什么委托定义的返回值通常都为void?

尽管并非必需,但是我们发现很多的委托定义返回值都为void,为什么呢?这是因为委托变量可以供多个订阅者注册,如果定义了返回值,那么多个订阅者的方法都会向发布者返回数值,结果就是后面一个返回的方法值将前面的返回值覆盖掉了,因此,实际上只能获得最后一个方法调用的返回值。可以运行下面的代码测试一下。除此以外,发布者和订阅者是松耦合的,发布者根本不关心谁订阅了它的事件、为什么要订阅,更别说订阅者的返回值了,所以返回订阅者的方法返回值大多数情况下根本没有必要。

【Note】匿名类型和隐式类型
var par = new { value1 = "par_value1", value2 = "par_value2" };
var par2 = new { par.value1, value2 = "par2_value2" };

var par2内部的 par.value1会自动生成一个值为par_value1的字段value1

注意事项:
* 两个匿名类型想要生成的CIL类型相同,就要做到属性名,数据类型,和属性的顺序完全匹配,即,如果这些条件不符合,那么两个不同的匿名类型的实例就不可以从一个转换到另一个
* 匿名类型的实例,是不可变的
* 匿名类型是c#3.0支持"投射"的关键

【Note】匿名类型不能使用集合初始化器

解决方案1:
定义一个方法:
static List<T> CreateList<T>(T t) { return new List<T>(); }

利用方法类型推导:
var myvar = new
{
name = "lihuixian001",
pwd = "123456"

};
var pp= CreateList(myvar);

解决方案2:
使用数组初始化器:
var myVar= new[]
{
new{par1="value1",filed="value2"},
new{par1="value1",filed="value2"}

};
最终得到一个匿名类型构成的一个数组,由于是数组,所以每个项的类型都要相同

【Note】IEnumerable<T>
公开枚举器,该枚举器支持在泛型集合上进行简单迭代

集合类实现IEnumerable<T> 集合类的状态靠实现IEnumerator<T> 的类来维持

* foreach循环内不允许对item赋值,但是可以修改item内部成员都值

【Note】标准查询运算符
实现IEnumerable<T>的类型都会增加一个GrtEnumerator()方法,同时添加using System.Linq可以自动扩展N多方法,对于IEnumerable<T>上的每个方法都是一个标准查询运算符

【Note】LINQ的并行运行(.net4.o)
AsParallel()扩展方法

【Note】LINQ的推迟执行!!!!!!!
* IEnumerable<T>.Where()里面的Lambda表达式并不是数据,而是一个委托,它将发送到数据源那里执行,声明的时候它并没有执行
* 会触发Lambda表达式执行的语句
1. foreach
2.Enumerable的Count函数
3.ToArry()函数

* 调用ToXXX()函数会将查询结果保存起来
例如: IEnumerable<T>.Where().ToList()
这样下次就不用去数据源重新读取数据了


【Note】OrderBy() ThenBy() Join() GroupBy() SelectMany()

【Note】标准查询运算符的查询表达式语法
* “标准查询运算符”是组成语言集成查询 (LINQ) 模式的方法。 大多数这些方法都在序列上运行,其中的序列是一个对象,其类型实现了 IEnumerable<(Of <(T>)>) 接口或 IQueryable<(Of <(T>)>) 接口。

* 某些使用更频繁的标准查询运算符具有专用的 C# 和 Visual Basic 语言关键字语法,利用这些语法,将可以在“查询表达式”中调用这些运算符。 与“基于方法”的查询表达形式相比,查询表达式是一种不同的、可读性更好的查询表达形式。 在编译时,查询表达式子句将被转换为对查询方法的调用。

IEnumerable 用于Linq to object
IQueryable 用于Linq to SQL / Entity Framework比较好

【Note】IComparable<T>
包含CompareTo()方法, 实现比较大小功能

【Note】IComparer<T> 实现排序功能
包含Compare()方法

【Note】ICollection<T>
IList<T>和IDictionary<TKey,TValue>都是从ICollection<T>派生
包含:
Count属性
CoptyTo()方法:允许集合转换成数组

【Note】主要集合类
* List<T>: 列表集合
* Dictionary<TKey,TValue>:字典集合
* SortDictionary<TKEY,TValue>和SortedList<T>:已排序集合
前者按照键排好序,后者是按值
* Stack<T>:栈集合
* Queue<T>:队列集合
* LinkedList<T>:链表

【Note】索引运算符
接口里面可以声明属性
T this[xx类型 index]
{
get;
}


【Note】迭代器
利用:IEnumerable<T>和IEnumerator<T>

 

【Note】使用System.Type访问元数据
1. GetType()(实例方法)
2.无法或者实例,可以用typeof()表达式



【Note】Type类型的实例方法
GetProperties()
GetProperty()
GetField()
例:
FieldInfo info = type.GetField("haha");

info.SetValue(date2, "xiugaile");


【Note】泛型类型上的反射
例:
Type type;

type = typeof(System.Nullable<>);
Console.WriteLine(type.ContainsGenericParameters);
Console.WriteLine(type.IsGenericType);

type = typeof(System.Nullable<DateTime>);
Console.WriteLine(type.ContainsGenericParameters);
Console.WriteLine(type.IsGenericType);

获取泛型类型或者方法上的类型参数
实例方法:GetGenericParameterConstraints() 返回Type数组


【Note】特性
包含前缀的特性
[module:xxx] [return:xxx] [assembly:xxx]

自定义定义一个特性:
public class xxxxAttribute : Attribute
{}

应用一个特性的时候,可以只写[xxxx]或者[xxxxAttribute ]
编译器会自动考虑命名规范,可以加Attribute后缀或者
不加

查找一个特性:
Attribute[] attributes =
(Attribute[])property.GetCustomAttributes(
typeof(CommandLineSwitchRequiredAttribute),
false);

查找特性的方法通常定义在自定义的特性类里面,
作为一个静态方法

* 特性类可以有构造器
构造器的限制,向特性的构造器传递参数的时候,参数
只能是字面量或者类型(比如typeOf(int))

【Note】System.AttributeUsageAttribute限制特性

* [AttributeUsage(AttributeTargets.Property|AttributeTargets.Field)]
public class xxxxAttribute : Attribute
{}
这里限制特性只用于属性`或者字段

* [AttributeUsage(AttributeTargets.Property,具名参数名称=xx)]
具名参数指定成员属性或者字段的默认值

【Note】一些预定义的特性
预定义的特性有影响编译器很运行时的功能

【Note】1.System.Diagnostics.ConditionalAttribute
功能类似与#if/#endif
* 不同于#if/#endif,它标识的代码还是会编译成CIL,取决于调用者所在的程序集的预处理器标识符,而不是被调用者的
* 该特性只能标识于方法或者类
* 若方法包含out参数或者有返回值,就不能标识这个特性
* 只有继承于System.Attribute的类才能标识此特性
* 假如该特性标识于特性,那么被标识的特性符合条件才能通过反射被查找出来
例: #define CONDITION_A
Console.WriteLine("Begin...");
MethodA();
MethodB();
Console.WriteLine("End...");

[Conditional("CONDITION_A")]
static void MethodA()
{
Console.WriteLine("MethodA() executing...");
}

[Conditional("CONDITION_B")]
static void MethodB()
{
Console.WriteLine("MethodB() executing...");
}
【Note】2.ObsoleteAttribute
向调用者发出特定的成员或者类型已过时的警告

【Note】3.SerializableAttribute和NonSerializedAttribute
序列化和反序列化

using (steam = File.Create(doc.Title + ".LHX"))
{
BinaryFormatter bin = new BinaryFormatter();
bin.Serialize(steam, doc);
}

document doc2;
using (steam=File.Open(doc.Title + ".LHX",FileMode.Open))
{
BinaryFormatter xx = new BinaryFormatter();
doc2=(document) xx.Deserialize(steam);
}


自定义序列化
* 为了实现序列化,要实现ISerializable接口,包含一个GetObjectData()方法
* 为了支持反序列化,要实现形式如
public EncryptableDocument(
SerializationInfo info, StreamingContext context)
的构造器

序列化的版本控制
* 为了兼容旧版本,可以用OptionalField特性标记(.net2.0)
* .net2.0之前的版本只能通过实现ISerializable接口只保存并且读取可用的字段

SerializableAttribute在CIL中是个伪特性

【Note】dynamic的原则和行为
* dynamic涉及一个解释机制,当运行时遇到一个dynamic调用时,它将请求编译成CIl,再调用新的调用
* 任何类型都可以转换成dynamic
* 从dynamic转换到一个替代类型是需要基础类型的支持
* dynamic的基础类型可以改变,不同于var隐式类型
* 要到运行时才验证dynamic上指定的签名是否存在
* 任何dynamic成员的调用都是返回一个dynamic对象,像data.ToString()也是返回一个dynamic对象,但是执行时,在dynamic对象调用GetType()是返回编译好的类型
* 用dynamic实现的反射不支持扩展方法
* dynamic本质是一个object,与object区别的关键是它的特殊动态行为会调用时出现

【Note】实现自定义动态对象
* 优先方案是I继承DynamicObject类
* 也可以实现IDynamicMetaObjectProvider接口


【Note】多线程要求:保持线程的原子性,避免死锁,避免造成执行时的不确定性(如多个线程进行竞争的情况)

【Note】yield
* yield 语句只能出现在 iterator 块中,该块可用作方法、运算符或访问器的体。
这类方法、运算符或访问器的体受以下约束的控制:

1.不允许不安全块。

2.方法、运算符或访问器的参数不能是 ref 或 out。

* yield 语句不能出现在匿名方法中
static IEnumerable<Vector> GetVectors()
{
yield return new Vector(1, 1);
yield return new Vector(2, 3);
yield return new Vector(3, 3);
}
上面的函数不能用List<T>返回值
接收的结果要ToList():
List<Vector> vectors = GetVectors().ToList();
类似于linq的延迟绑定

【Note】TPL和PLINQ是.net4.0的,但是引入 Reactive Extension(Rx)的程序集也可以用于.net3.5

class Program
{
static void Main(string[] args)
{
string name = "Thief-X";
Task<string> task = Task.Factory.StartNew<string>(()=>getCount(name));
foreach (char item in BusySymbols())
{
if (task.IsCompleted)
{
Console.Write('\b');
break;
}
Console.Write(item);
}
Console.Write(task.Result);

}
public static string getCount(string str)
{
System.Threading.Thread.Sleep(5000);
return "哈老~!?"+str+",结果出来啦~!!!";
}
public static IEnumerable<char> BusySymbols()
{
string busySymbols = @"-\|/-\|/";
int next = 0;
while (true)
{
yield return busySymbols[next];
System.Threading.Thread.Sleep(100);
next = (++next) % busySymbols.Length;
yield return '\b';
}
}
}
【Note】Task的一些属性
* Status Task状态的枚举值
* IsCompleted
* Id
* AsyncState
提供额外的数据。例如多任务计算List<T>中的值,由于调用List<T>.Add()不是跨多线程的安全操作,所以一个办法就是将包含结果的列表索引存储在AsyncState
* Task.CurrentId

【Note】Task.Factory.StartNew() 使用带参数的委托作为工厂方法的参数
1.定义一个委托:Func<object,string> mmm=getCount
Task<string> task=Task.Factory.StartNew<string>(mmm,name);
2.使用闭包:
Task<string> task=Task.Factory.StartNew<string>(()=>getCount(name));

【Note】ContinueWith()
* ContinueWith()会返回一个task
* 同一个task执行ContinueWith()多次,那么当task执行完成之后,登记在它上面的后续线程都同时并发执行

【Note】task上的异常处理
* Task执行期间的异常都会被禁止,一直到调用某个任务完成
Wait() Result Task.WaitAll() Task.WaitAny()

try
{
task.Wait();
}
catch (AggregateException exception)
(注:AggregateException 是个异常集合)

* 另外一种处理方法:使用ContinueWith()
bool parentTaskFaulted = false;
Task task = new Task(() =>
{
throw new ApplicationException();
});
Task faultedTask = task.ContinueWith(
(parentTask) =>
{
parentTaskFaulted = parentTask.IsFaulted;
}, TaskContinuationOptions.OnlyOnFaulted);
task.Start();
faultedTask.Wait();
Trace.Assert(parentTaskFaulted);
if (!task.IsFaulted)
{
task.Wait();
}
else
{
Console.WriteLine(
"ERROR: {0}", task.Exception.Message);
}

【Note】协作式取消任务(.net)
* 在主线程建立CancellationTokenSource类对象cancelsoure,调用Cancel()可发出退出指令
* 子线程上判断cancelsoure.Token.IsCancellationRequested
* Task.Factory.StartNew(子线程委托,cancelsoure.Token)

CancellationToken上的Register()方法,线程结束时候执行的委托:
cancelsoure.Token.Register(() => { Console.WriteLine("子线程结束了"); });

【Note】长时间的任务

Task.Factory.StartNew()默认是从共享线程那里分配一个线程,但是如果是长时间任务的话,应该指定TaskCreationOptions.LongRunning参数,这样线程池更有可能分配一个专门的线程

【Note】释放一个任务
可以调用一个Dispose()

【Note】并行迭代
* Parallel.For()
Parallel.For(0, iterations, (i) =>
{
sections[i] += PiCalculator.Calculate(
BatchSize, i * BatchSize);
});
pi = string.Join("", sections);

* Parallel.ForEach()
API会使用爬山算法来提高性能

Parallel.ForEach(files, (fileName) =>
{
Encrypt(fileName);
});

【Note】捕捉并行迭代的异常
try
{
Parallel.ForEach()
}
这里将会捕捉到AggregateException,所有异常包含在这个集合

【Note】并行迭代的取消
类似于task

【Note】并行结果和选项ParallelOptions
* parallelOptions.MaxDegreeOfParallelism
最大并行度,1相当于关闭

* parallelOptions.TaskScheduler `任务调度器
对task的执行有完全的控制:
包括任务的执行顺序以及在什么线程执行
比如:先进先出,后进先出顺序之类的

* parallelOptions.CancellationToken取消标志

例:
Parallel.ForEach(
files, parallelOptions,
(fileName, loopState) =>
{
Encrypt(fileName);
});

* 在循环内部,loopState.break()可以中断退出循环并取消进一步迭代
* Parallel.ForEach()返回结果:
IsCompleted 指示所有迭代是否完成
LowestBreakIteration最低迭代的索引

【Note】并行执行LINQ查询


标准查询运算符使用PLINQ:
OrderedParallelQuery<string> parallelGroups = data.AsParallel().OrderBy(item => item);

查询表达式使用PLINQ:
ParallelQuery<IGrouping<char, string>> parallelGroups;
parallelGroups =
from text in data.AsParallel()
orderby text
group text by text[0];

务必小心不要让多个线程不恰当地同时访问并修改相同的内存


【Note】取消PLINQ查询

【Note】.net4.0之前的并行
System.Threading


【Note】变量读写的原子性
一个类型的大小假如不超过一个本地整数,那么该类型是原子性的,比如64位操作系统将保证long型原子性,但是decimal(128位)的就不行了

【Note】Monitor同步

bool lockTaken = false;
try
{
Monitor.Enter(_Sync, ref lockTaken);
_Count++;
}
finally
{
if (lockTaken)
{
Monitor.Exit(_Sync);
}
}
其中_Sync 的定义:
readonly static object _Sync = new object();

【Note】lock
lock (_Sync)
{
_Count++;
}
其中_Sync 的定义:
readonly static object _Sync = new object();

【Note】使用System.Threading.InterLocked同步
代替高带价的Monitor和lock
InterLocked.Exchange(location,value,comparand)

【Note】避免锁定this,typeof(tyoe),和string

【Note】其他一些同步方法:

1.System.Reflection.Mutex类同步
可以多个进程之间同步,好处是可以限制应用程序,对与同一个应用程序只能打开一个

2.WaitHandle
Mutex的基类
.
.
.

【Note】异步编程模式(APM)
基于事件的异步模式(EAP)
Background Worker模式

 

 


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap