对她调用成员,是微软公司披露的面向对象的、运行于.NET

初识C#

C#是微软公司发布的面向对象的、运行于.NET
Framework之上的尖端程序设计语言。与Java有强烈不同,借鉴Delphi的表征,与COM(组件对象模型)直接集成,是微软公司.NET windows网络框架的台柱。
C#大凡平等种语言,.net是一个平台。C#不光可以支付基于.net的应用程序,也可付出基于WinForm的主次。.
net 是 Microsoft 的 XML Web 服务平台,XML Web 服务能使应用程序在
Internet 上传和共享数据。  
特点

  • 强类型语言,安全稳定性;
  • 事件驱动、完周全向对象的可视化编程语言;
  • 便捷的面向组件编程的协理;
  • VB简单的可视化操作以及C++的大周转功用的做;
  • 托管代码和废物回收 (garbage collection);

    // .NET ~ C# ~ ASP.NET
    C#是.net平台下的同样种出语言,用于开发桌面应用程序
    asp.net是付出web程序的技巧
    .net是阳台,该平台下涵众多艺使:asp.net ado.net winform WCF

.NET框架
CLR:公共语言运行库,Common Language
Runtime,.NET框架的主干零部件,在操作系统的顶层并当运行期调用基类库(BCL,
Base Class Library)管理程序的进行。

  • 内存管理机制
  • 渣回收机制GC (Garbage Collector)
  • JIT编译器

CTS:公共项目系统,Common Type
System,紧要特点是拥有连串且无冕自公共的基类object。

原创作品,转载请注明出处! 以下总括参阅了:MSDN文档、《C#尖端编程》、《C#本质论》、前辈们的博客等资料,如有免得法的地点,请帮就提出!以免误导!

基本功学习

4独基础命名空间

// .NET框架中的基础类库,用于实现一些基本的类。
using System; .NET应用程序中使用的大多数基本类型
using System.Collections.Generic; 处理集合的泛型类型
using Syatem.Text; 字符串处理和编码相关的类型
using System.Linq; 提供支持使用语言集成查询(LINQ)进行查询的类和接口,用于对集合进行查询
  1. 结构 – 类

struct 是值类型,隐式密封的、不可知于接续,但可以实现接口。struct
成员默认是
public,有构造函数(实例、静态),没有析构函数,不允许字段初步化。
class 是援引类型,单继承,可实现接口。class 成员默认是 private。

  • 数据成员:字段、常量;
  • 函数成员:属性、方法、事件、索引器、构造函数、析构函数、操作符;
  1. 字段 – 属性 – 索引
    字段 – private,属性 – public;
    属于性
    是点名的一样组2个门当户对的、称为访问器 (get 和 set)
    的措施。属性是函数成员,访问器只好被隐式调用,执行代码,但非为数存储分配内存。公有属性提供对个人字段的受控访问。
    索引 是相同组 get 和 set
    访问器,类似性,目录是函数成员;索引平日用于访问四只数据成员,类似数组利用寻引运算符;索引不克宣称也
    static。访问器只好给隐式调用,好重载,参数列表必须不同。
  • 目没知名称,但 this 是须的;
  • 参数列表中至少须阐明一个参数;

    ReturnType this[参数列表] {

     get {...}
     set {...}
    

    }

  1. 静态构造函数 –
    (普通的)实例构造函数
    实例构造函数初叶化类的每个新实例,static
    构造函数初步化类层次之色。static
    构造函数不可知访问类的实例成员,日常用于开始化类的静态字段,静态构造函数被系统自动调用。静态字段先于实例成员叫起始化,类只好有一个
    static 构造函数,不能带来参数、不可能有看修饰符、也未克使 this 访问器。

[1]. 构造函数中无可以调用虚方法

[2]. 构造函数起始化器关键字:this,base,控制类吃构造函数的实践各种

[3].
静态构造函数只会受执行同一潮(在创设第一单实例或引用任何静态成员此前,且由.NET自动调用)

[4].
静态构造函数在程序域(AppDomain)的层级确保单独会面执行同样蹩脚,且线程安全

[5]. 静态构造函数分外适于在单个形式被(或只是需要单一对象的地方)

至于双方的有血有肉音讯参见:http://www.cnblogs.com/jiagoushi/p/3775046.html

  1. 继承
    单继承。
    a. 重载:同一个好像内之函数,函数称呼相同、参数列表不同;
    b. 重写(覆盖):父子类里的函数,签名相同、再次来到路相同;父类用 virtual
    标识,子类用 override 标识;
    c. 隐藏:默认或经 new 显式隐藏。base.数据成员/函数名
    显式访问于躲的成员。
  • 字段:名称相同,类型相同; 
  • 函数:签名相同(函数誉为、参数列表(个数、顺序、类型、修饰符));
  1. 泛类 abstract – 接口 interface (抽象类 – 自底向上,接口 –
    自到向下)
    a. 抽象类可给来一些成员的一部分贯彻,接口无法包含成员贯彻;
    b.
    抽象类的纸上谈兵成员好被类有实现,接口的积极分子必须给实现类似全体兑现;
    c. 一个类似只可以连续一个浮泛类(类单继承),然则可兑现四只接口;
    d. 看似是本着目的的空洞,抽象类是对类的空洞,接口是指向表现之悬空
    e. 从规划角度,抽象类和接口设计的思维过程不同(相反):

接口
引用类型,接口可以延续接口,类与协会得以兑现接口。接口允许看修饰符
public、protected、internal、private,接口成员不允看修饰符,默认
public
static。接口注解不克包含数据成员,只可以分包 属性、方法、事件、索引。
类 A 实现接口 IA,将类 A 的靶子引用转换为接口 IA 的援:

  • 强制类型转换:IA ia = (IA)objA;不过若类 A 未实现接口
    IA,则弃来怪。
  • as 运算符:IA ia = objA as IA;若类 A 未兑现接口 IA,返回null、不撤废来异常。

兑现接口的接近可以打她的基类继承实现代码。类实现 2 独接口,2
独接口包含同名方法,类的纯实现即可以餍足 2 单接口 或
显式实现每一个接口。同时可独家取各一个接口的独立引用。
图片 1

  • 接口正常实现:接口方法无包含实现代码,实现在相近级另外方被;
  • 接口显式实现:接口方法包含实现代码,没有类似级另外计;

流动:接口的显式实现成员只可以让相应的接口引用访问,需要强制转换操作。

  1. 密封类 – 抽象类 – 静态类
    a. 密封类:sealed,只好于当独立的好像,不可知被延续,可实例化; 
    b. 抽象类:abstract,只可以为连续,不可实例化;
    c. 静态类:static,静态类是密封的。不克给持续,不可实例化;
  2. 装箱 – 拆箱
    a. 装箱:隐式转换,把值类型打包到Object引用类型的一个实例中;
    b. 拆箱:显式转换,从目的被提值类型;
    implicitexplicitisas

[1]. implicit – 隐式转换,explicit – 显式转换;

public static implicit/explicit operator 目的项目(源类型 源类型变量)
注:用户从定义转换仅针对于类和布局。is-as
不可知用来用户从定义转换。is-as 不能重载。 

[2]. is:检查对象类型兼容性并判断是否得逞转移,重返bool,不摒弃来相当;

  • 适应范围:引用转换、装箱转换、拆箱转换,if(obj is Type) Type t =
    (Type)obj; 

[3]. as:类似强制转换,检查对象类型兼容性并回转换结果,不放弃来大,失利时回来null;

  • 适应范围:引用转换、装箱转换,Type t = obj as Type; if(null !=t){…}
  • true/成功:obj 是 Type 类型或者 obj 是 Type 类型的子类型;

对 is,CLR 对目的类型检查了点儿蹩脚:is操作首先检查obj是否以及Type类型兼容。若兼容,在if语句内举办转换时CLR再检查obj是否也一个Type引用并易。对于
as,CLR 对目的类型检查了同一坏:as操作检查兼容性并一向换,效能高、性能好。
参考:is – as
详解

  1. object sender – EventArgs e
    a. object sender:保存触发事件的靶子的援,指向发送通知之对象;
    b. 伊夫(Eve)ntArgs e:伊芙ntArgs
    是带有事件数量的近乎的基类,在事变触发时传递数据,不过 伊芙ntArgs
    不分包其他数,所有的轩然大波参数近似都得由 伊夫ntArgs 类派生;
  2. 变体
    变体分为 协变 – 抗变
    两种植,针对援类型:
    a.
    协变:covariance,父=子,out,只好作为方法的重回值或性质get的访问器;
    b. 抗变:contravariance,子=父,in,只可以当作方法的参数;
  3. 但空类型 ? – 空接合运算符 ??
    a.
    可空类型允许创制普通值类型的变量并标该行之有效。可空类型是本着平常值类型的
    private 封装,与常见值类型可以相互转换。 Type
    ?
    nullableType; 其问号语法是经过 System.Nullable<T>
    利用泛型实现,? 是System.Nullable<T>的缩写。不克创立引用类型的可空类型。2独单纯念属性:
    -**HasValue:bool 类型,标识是否有效;  **Value:变量值;(普通值类型的价、可空类型的值、null)
    b. 空接合运算符允许在可空类型的变量为 null
    时回来一个吃定值。单元运算符,左右两边数据类型必须同或会隐藏转换。首先检测左侧的价,若为Null,则通表明式取值为右的价值,否则也左的价。 
  • string str = null; Console.Write(str ??
    “abc”); 将输出:”abc”
  • string str = “s”; Console.Write(str ?? “abc”);
    将输出:”s”
  1. 泛型
    列是实例对象的沙盘,泛型类型是种的沙盘。
    类别参数的牢笼用 where 子句列出:where 参数:constraint, constraint, …
  • 构造函数约束 new() 必须在最终;
  • 主约束(class/struct)至多一个,且必须在第一各个; 
  • 接口约束好爆发差不四只;

特爆发 Type 类型或派生于 Type 类型的实参才会用来为律的参数。

  1. 字符串

平整字符串:在双引号中的零个或多单字符组成,并且可含蓄简单转义字符序列。(”str”)

逐字字符串:由 @
字符后及一般的双挑起号字符串。(@”str”)

  • 将 \
    当作 普通字符 处理、而非转义字符,但有有效性(@”xxx\abc” +
    “\\”);
  • 不过随心所欲换行(常用于SQL字符串),但是换行符、缩进、空格都盘算以字符串长度之内;
  • 当str中,用半单连的英文双引号表示一个英文双引号(注意是必于str中);

注:C#中Environment.NewLine表示为眼前环境定义的换行字符串(非Unix平台为字符串“\r\n”,Unix平台为字符串“\n”),推荐使用。 

IsNullOrEmpty:判断字符串是否也null或者string.Empty;

IsNullOrWhiteSpace:判断字符串是否为null、空(string.Empty)如故只出于空白字符组成;

第一,确认string.Empty为空字符串,即string.Empty =
“”;对于”
“、”\t”这样的独自由空白字符组成的字符串,IsNullOr惠特eSpace可以一向判,而IsNullOrEmpty需要str.Trim().Length搭配使用。

委托 – 事件

 a. 委托 delegate:对函数的卷入,一种引用方法的类型
(引用类型),代表一律近乎模式,具有相同参数列表和归路;
 b. 事件
event:委托的同一栽新鲜情况,事件的门类是托,事件是托项目标变量,事件不是序列,事件是成员(变量)且让隐式自动启化为null;
  以”+=”扩充委托的实例/静态方法,利用”-=”移除了委托的实例/静态方法。事件让触发时,执行为信托的艺术(调用委托来挨家挨户调用调用列表中之不二法门)。此处引用大话设计情势中的例证:
  public delegate void CatShoutEventHandler(object sender, EventArgs
e);
  public event CatShoutEventHandler CatShout;
寄是面向对象、类型安全之还如果可靠受控、安全的。当委托给调用时,它调用有序方法列表中的各国一个艺术。委托是定位的,委托对象吃成立后即不谋面还吃改变。调用空委托会抛来好,通过将信托以及null相比较判断委托的调用列表是否也空,进而判断委托是否为null。
泛型委托
  public delegate TR
FunHandler<T1, T2, TR>(T1 p1, T2 p2)
匿名格局 -> 兰姆da表明式
匿名格局,anonymous
method,可以防止成立以独立的签方法,允许以创制并开始化委托或也委托扩展方法时噙小段的内联inline代码。
 
delegate(参数列表){语句块};
兰姆(Lamb)da表明式避免冗余音信、简化匿名形式的语法。
总结从 委托事件 到
观看者格局
;  

 

增加方法

容为现有项目”添加”方法,而不管需创造新的派生类型、重新编译或坐其余办法修改原始类型。类A需要新增一个主意,但类A是封的要么源代码不可见,即未克修改类A,此时扩张方法允许在其他一个类B中采取类A的公有可用成员贯彻类A需要新增的道。

  • 增加方法必须是静态的,所在类也非得是静态的;
  • 深受增添类型必须作为第一单参数,必须用 this 修饰; 

    public static class ExtendMyClass {
       public static 再次来到路 Function(this MyClass mc) {
          // 调用MyClass的公家成员贯彻增产方法
       }
     }

调用:mc.Function();,假诺没有this,只可以以ExtendMyClass.Function(mc);形式调用。
扩大方法还好组合泛型类,允许用(扩张)类吃的静态方法关联到不同之泛型类及。扩张接口时,利用扩张方法相比较持续接口(会强制要求兑现接口下的有所办法)更有利于。但是,扩展方法的先行级总是比让扩展类型我遭到定义之同名实例方法没有,且为增加类型的子类不克继承其父类型的壮大方法。

  • 拿静态方法转成扩大方法,扩张方法本质上是静态方法;
  • 编排协理类似;
  • 呢 Linq 服务,实现链式编程;

参考云扩张方法的接头
C#扩大方法
奇思妙想之扩张方法层层

 

反射

[1]. 类Assembly中Load, LoadFrom, LoadFile方法相比

 

枚举 ~ 枚举数 ~
可枚举类型

枚举
enum,值类型,成员是整数值常量,可以显式为那多少个赋值开端化,但非可知运用修饰符。枚举可用于实现各标志,注意补加
[Flags] 特性。
但枚举类型是实现了GetEnumerator()方法的类,再次来到用于(读取并回)集合中数据项之枚举数,枚举数是好依次再次回到集合中数项之近乎对象。
参考迭代器学习连串自打定义类实现foreach
[-1-]. IEnumerable / IEnumerator
非泛型枚举数和可枚举类型,枚举数类平时讲明也接近中之镶嵌套类。
· IEnumerator
Current:当前职对应之数项;
MoveNext():下转移职,初阶地点也-1;
Reset():复位;
· IEnumerable
IEnumerator GetEnumerator(): 
[-2-]. IEnumerable<T> /
IEnumerator<T>
泛型枚举数和而枚举类型,类型安全。
总结IEnumerable / IEnumerator
学习 – sqh

1..落实多态性的个别种方法:继承抽象类、实现接口

实际就是是协变的选拔,通过把对象提升转型为基类或接口类型,对她调用成员,可实现多态性,即运行时调用的凡指向承诺对象的落实版本成员。这有限种植方法的区分:

  • 承抽象类:会就此掉唯一1糟的持续机会,但足延续任何成员(包括字段),自由度高
  • 心想事成接口:必须贯彻有成员,不可知包含字段,但好兑现五只接口
  • 虚幻类可供成员的求实实现,而接口就承担注脚,不克提供任何实现代码

注意:

  • 接口一旦被定义就是不应更叫更改,否则持有实现该接口的型且必须就修改。
  • 而肤浅类则足以每一天补充加新的分子,不影响他的子类,还会提供新的附加功能。

多态性示例:(协变与逆变)

//可以返回Stream的任何子类类型
Stream Method1(bool boo)
{ }
//可以接收Stream的任何子类类型的参数
void Method2(Stream stream)
{ }

关键字/修饰符/运算符

  1. object 类
     C#受到有着的类(型)都一向/直接接轨自System.Object类(型),值类型数据好隐式转换为Object类型;object是引用类型,关键字object就是System.Object的别称。
    ■ 静态方法
     [1]. public static bool Equals(object objA, object objB){}
       调用实例方法Equals(object obj),判断是否等;
     [2]. public static bool ReferenceEquals(object objA, object
    objB){}
       判断多只目标是否引用相等;
    ■ 实例方法
     [1]. public virtual bool Equals(object obj){}
       方法需要再行写用于落实基于值来判断指标是否等;
     [2]. public virtual int GetHashCode(){}:获取对象的Hash值;
     [3]. public Type GetType(){}
       获取当前实例的Type,查询对象的正负数据来规定目的的运作时路;
     [4]. public virtual string ToString(){}:获取当前实例的字符串音信,对象的字符串表明情势;
    ■ 于保障模式
     [1]. protected virtual void Finalize(){}
       类或派生类可以看,允许 Object 在“垃圾回收”机制回收 Object
    往日尝释放资源并举行外清理操作;
     [2]. protected object
    MemberwiseClone(){}:创制当前实例的表层副本;
  2. partial
     a. 将看似定义在多单代码文件被;
     b.
    用于创设有主意(定义申明与方法实现),不克暴发看修饰符,再次回到值必须也
    void;
  3. internal
    恍如以及好像成员的造访修饰符,同一程序集权限。类默认是 internal,类成员默认是
    private。
    protected internal:受保障之里边成员,同一程序集 or 子类权限。
    参考:internal –
    举例参考

    镶套类:嵌套是指类阐明的职,而未是近似实例的岗位。
    镶套类具有成员访问级别,默认 private,可见性具体地:
    ·  嵌套类型的成员对查封类型的分子有完全看权限;
    ·
     封闭类型的分子只可以看嵌套类型的public和internal成员,不可知顾private和protected成员;
     嵌套类型的目的看封闭类型,需要维护封闭类型的援。
  4. using
     a. using 指令:命名空间提醒符
     b. using 别名:类型别名指示符
      一个.cs文件引用了少于个不同的命名空间,但少只空中都不外乎一个一样名字的色,使用别名更简短。
      using aClass = NameSpaceA.MyClass;
      using bClass = NameSpaceB.MyClass;
     c. using语句:资源的包和管理 -> 隐式的 try…finally 块
      定义一个限制,在界定截止时自动处理对象,自动调用这多少个仿佛实例的 Dispose
    方法。资源大凡一个落实 System.IDisposable 接口的好像依旧结构。
  5. 异常:try…catch…finally
    结构化卓殊处理语法,标记出会处理十分的代码和指令:
      ■  try:包含可能相会丢来好的代码;
      ■  catch:抛来深后只要实施的代码,catch块可六只;
      ■  finally:始终一定会尽之代码,释放资源;
    try 块是得的,catch 和 finally 必须至少暴发一个。所有的杀类都派生于
    System.Exception 类。
    相当嵌套的处理:假设这些现身在 Method2 计中,但是这 catch
    块没有匹配的非常处理程序, 系统沿着调用栈向上搜索到
    Method1,假如找到匹配的 catch 块,系统先返栈顶 Method2 处执行那finally 块,然后把 Method2 自调用栈中 pop(),最后执行 Method1 的照应
    catch 块和 finally 块。

    public void Method2() public void Method1()
    { {
       try{ try{
         … Method2();
       } }
       catch{…} catch{…}
       finally{…} finally{…}
    } }

  ■  throw:显式抛出相当;
– throw
Exception;极度抛来后,非凡实例可以被 catch 块捕获。
– throw;此种植只可以于 catch
块内,捕获后重新重新抛出。

  1. String、StringBuffer 与
    StringBuilder
    String是字符串常量、定长,StringBuffer与StringBuilder是字符串变量、可变长、避免暴发额外的现变量;StringBuffer线程安全,StringBuilder是非线程安全,三者的行进度
    StringBuilder > StringBuffer > String。具体分详见:
    参考:String – StringBuffer –
    StringBuilder
    .
    string – String
    String是.NET Framework中的类,string是C#中的类,C#的string映射为.NET
    Framework的String;string是C#面临的要紧字,可以用作String或System.String的号;
  2. const 与 readonly
    const只会以表明语句中起头化,readonly可以在宣称语句或构造函数中伊始化,const是编译时常量、在内存中绝非存储地点,readonly是运行时常量、在内存中起囤积地点;const是静态的,readonly能够是静态字段也堪是实例字段。
  3. typeof 与 GetType
    typeof:一初次运算符, typeof(classA) 再次来到作为其的参数的外项目的System.Type 对象,无法重载。
    GetType:System.Object的方法, obj.GetType(); 能够调用 typeof
    运算符,对自由档次的擅自对象都灵验。
  4. var
    揆类型,弱化类型的定义,可代表任何项目,然则 var 并无更改 C#
    强类型性质。类似object,但object是援类型,效用比var低。
    var
    用于地点局部变量,不可知用来字段,使用时必伊始化且无法重复赋类型不同的价值; 

9.Marshal.SizeOf和sizeof

参考:http://www.cnblogs.com/jxnclyk/archive/2010/06/09/1754438.html,同时考虑内存对齐的问题,特别是结构体中包含引用对象时,最好使用Marshal.SizeOf。

2.不要成立可变的值类型(结构、枚举),若使反,请用一个术来回到一个初实例。要随时检点勤的装箱与拆箱对性的熏陶

常用函数

  1. Convert.ToInt32 –
    int.Parse(Int32.Parse)- int.TryParse – (int)
     a. Convert.ToInt32与int.Parse类似,Convert.ToInt32
    内部调用了int.Parse,Convert.ToInt32
    可以变的门类相比多,int.Parse只可以换数字型的字符串;
     b.
    int.TryParse与int.Parse类似,但未会合弃来大,再次回到值为bool以指示解析是否中标,从而可以不去丰盛至极处理代码的麻烦,out参数为转移输出值;
     此四者都得说啊用类型转换为
    int,eg:举例参考.
    流动:所有预定义的简约类型均含静态方法
    Parse,将字符串解析为相应的数据值。
  2. Split
     String类的搁方法,分割函数,参数可以呢单个字符、多独字符、字符串。
    参考:Split –
    常用举例参考
    Split的不等重载方法.
  3. Trim
     String类的内置方法,用于去字符串前后的指定字符,另外还有TrimStart()和TrimEnd()方法。
    参考:Trim –
    举例参考
    .
  4. DateTime
    · 与字符串string的换
     DateTime.Parse(timeString);
     Convert.ToDateTime(timeString);
     if
    (DateTime.TryParse(timeString, out datetime)) {
         DateTime dm = datetime;
       }
    · DateTime

x. xxx、

 

3.独自以能一眼看出变量的品种时,才使用var声明

集合类数量存储和摸索

取名空间:using
System.Collections;
     using System.Collections.Generic;
跟 ArrayList 对应之泛型集合是
List,与 HashTable 对应之泛型集合是
Dictionary。
ArrayList:是Array的纷繁版本,动态数组,实现了ICollection和IList接口,针对任意档次、任意长度,非类安全型的;
声明: ArrayList mAList = new ArrayList();
现实地属性方法类似List,此处不再赘言。 
HashTable:每个元素都是一个存储在DictionaryEntry对象被的键值对。keyvalue键值对全为object类型,匡助任何项目标keyvalue键值对,非类安全型的;线程安全之;
声明: Hashtable ht = new Hashtable();
遍历哈希表元素:
foreach(DictionaryEntry de in ht)
哈希表排序:
 ArrayList KeysAList = new ArrayList(ht.Keys);
 KeyAList.Sort();

  1. 泛型List
    声明: List<T> mList = new List<T>();
    特性方法:
     - mList.Count:对链表mList元素计数
     - mList.Add(T item):添泰铢素
     - mList.Insert(int pos, T item):指定地点插入元素
     - mList.AddRange(List list):链接2个List
     - mList.Contains(T
    item):测试List是否带有元素item
     - mList.Item(int idx):索引器,通过点名索引获取或设置元素
     - mList.Remove(T item):删除指定的素
     - mList.RemoveAt(int pos):删除指定地点的要素(推荐)
     - mList.RemoveRange(int b, int n):删除从b开始的n个元素
     - mList.Clear():清空List
     - mList.Reverse():反转List
     - mList.Sort():排序List
  2. 泛型Dictionary
    在C#受到,Dictionary提供高速的依照键值的因素查找。Dictionary<[key],
    [value]>,键必须唯一且无克也空引用null,值若为援类型则可以为空。
    声明: Dictionary<T1, T2> mDict =
    new Dictionary<T1, T2>();

属性方法:
 - mDict.Count:对字典mDict元素计数
 - mDict.Add(T1 key, T2 value):添英镑素(键, 值)对
 - mDict.ContainsKey(T1
key):字典是否包含键为key的因素
 - mDict.ContainsValue(T2
value):字典是否带有值为value的元素
 - mDict.Remove(T1 key):移除键为key的要素
 - mDict.Clear():清空Dict
 - 遍历字典元素
   1. By KeyValuePair
    foreach (KeyValuePair<T1, T2> kvp in
mDict) 或 foreach(var kvp in mDict)
   2. By Key
    Dictionary<T1, T2>.KeyCollection keyCol = mDict.Keys;
    foreach (T1 key in keyCol)  或  foreach(T1 key in
mDict.Keys) 
   3. By Value
    Dictionary<T1, T2>.ValueCollection valueCol =
mDict.Values;
    foreach (T2 value in valueCol)  或  foreach(T2 value in
mDict.Values)
 - mDict[key] = value:通过索引器读写键值对
 - mDict.TryGetValue(T1 key, out
value_T2):获取和指定的键相关联的价。通过键取值,包括个别单参数,一个是使询问的键,另一个凡是抱的价,注意值前边使用out关键字。
流淌:“判断键存在”和“依据键取值”两步转化为同一步,键的哈希值只算同一潮,效能高。
以下五只集合类,可以进一步参考Stack –
Queue –
SortedList
.

  1. SortedList
    System.Collections.SortedList类表示按键排序的键/值对的汇,可以按键或索引访问,是数组和哈希表的整合。
    声明: SortedList sList = new SortedList();
    遍历排序列表元素:
     foreach(DictionaryEntry de in sList)
    泛型SortedList

  2. 堆栈 Stack
    System.Collections.Stack类表示对象的LIFO集合,处理顺序多变。
    声明: Stack st = new Stack();
    性能方法:
     - st.Peek:取栈顶元素,但非以这一个移除;
     - st.Push(object obj):栈顶入栈;
     - st.Pop():出栈,移除并回到位于Stack栈顶处的靶子;
    泛型Stack

  3. 队列 Queue
    System.Collections.Queue类表示对象的FIFO集合,顺序处理集合中的目标。
    声明: Queue qu = new Queue();
    性方法:
     - qu.Peek:取队首元素,但不将这移除;
     - qu.Enqueue(object obj):队尾入队;
     - qu.Dequeue():出队,移除并回到位于Queue启幕处于的对象;
    泛型Queue

汇合与多线程

当起多独线程并发访问集合时,应该为此System.Collections.Concurrent命名空间代替上述命名空间受到的呼应项目,线程安全的集合类可由三只线程同时做客:

  • ConcurrentDictionary
  • ConcurrentQueue
  • ConcurrentBag

关于集合类的事无巨细内容参见:http://www.cnblogs.com/wjcx-sqh/p/6049314.html

参考

[1].
经典.Net面试题
[2]. .Net面试题系列0-9

4.定义值类型时,它的高低不要过16字节,否则影响属性(频繁复制时),要么改变呢使引用类型,要么被其按ref引用传递

用技术

有关循环和try{}..catch{}的嵌套使用

foreach(var item in items)
{
    try
    {
        try{}
        catch(Exception ex)
        {
            Logger.LogInfo(null, "xxx 执行异常或失败");
            throw; // 将异常抛到外层
        }

    }
    catch(Exception ex)
    {
        Logger.LogError(null, "[{0}] 处理异常!" + ex.Message, item);
        continue; // or break; or return false; 视情况而定
    }
}

文本再一次命名情势

  • Copy + Delete
  • File.Move(srcFileName,
    destFileName);
  • FileInfo.MoveTo(destFileName);
  • vb.net中My.Computer.FileSystem.RenameFile()

    Computer MyComputer = new Computer();
    MyComputer.FileSystem.RenameFile(FilePath, newFileName); 

累加引用:Microsoft.VisualBasic.dll,再长using
Microsoft.VisualBasic.Devices;

文件查找

// 查找方法1
DirectoryInfo Dir = new DirectoryInfo(directory);
FileInfo[] files = Dir.GetFiles(DateTime.Now.ToString("yyyyMMdd") + "*.xml");
// 查找方法2
string[] files = Directory.GetFiles(directory, DateTime.Now.ToString("yyyyMMdd") + "*.xml");

ADO.Net 与
ASP.Net

ADO.Net 是用以和数据库举办相互的面向对象类库,紧要涉及:

  • SqlConnection类:连接和治本数据库链接
  • SqlCommand对象:发出针对数据库的SQL指令(增删改查)
  • SqlDataSet对象:数据在内存中的代表形式
  • SqlData里德(Reade)r类:从数据库读取只进流的数记录
  • SqlDataAdapter类:填充(fill)DataSet对象
  • SqlTransaction对象:数据库事务

ASP.Net
是.Net技术框架下之B/S(网页方向)框架技术,作为同一种成立动态Web页的雄强的劳务器端技术,紧要涉及:

  • Request对象(HttpRequest类):Page对象的积极分子有,封装客户端的呼吁音讯
  • Response对象(HttpResponse类):Page对象的成员有,封装HTTP音信、响应客户浏览的网页
  • Cookie对象:记录客户端属性消息,存放于客户端,实现状态管理

在意,ASP.Net 不是同栽语言。

 

5.值类型数组之间未可知直接互动转换,可以经平等次等中转换为Array来达到目的,如:

(int[])(Array)new uint[32]
然应注意或当不同之CLR实现着显现各异!

6.数组与List

  • 如元素数量稳定,且非涉转型,则运用数组效能又胜。
  • 于要素数量可能爆发变化的情况下,就非该运用频繁组,而该运用List
  • 甭管数组仍旧List,元素个数也无可以太多,避免成为占内存超越85000字节的好目的,因为十分目的将会晤叫分配至独门的积举行拍卖,在回收大目标时效率相比逊色。

7.字符串操作

  • 字符串字面量、字符串常量,直接用”+”相连效率高,因为:string str = "srf"+"ttt"+"ccc";会合一直编译成string str = "srftttccc";,同样适用于字符串常量。
  • 尽量避免对变量的装箱:字符串+变量,较好之做法是:字符串+变量.ToString()
  • 多次操作字符串时用StringBuilder,并制订丰裕深之容量,而string.Format("{0}{1}{2}",str1,str2,str3);其间也是用StringBuilder

8.类型转换

字符串转另外基元类型:

  • 默认十进制:用Parse()、TryParse(),如:int.TryParse("24");,其中TryParse效率更强
  • 指定基数进制形式来分析:Convert.ToInt32("0xFF",16);
  • 自从字节数组中提取一截,转为基元类型:BitConvert.ToInt32(Byte[] arr, int startIndex);

从今定义类型中的威胁转换:
由基类强制转换为子类时,安全的做法是使”as”,若目的也null或项目不般配转换战败,均会回来null,而非相会掀起错误,如基类Person,它的子类Man、Women

Person person = new Man();//自动向基类隐式转换,但person的运行时类型仍为Man
Women women = (Women)person; //错误
Women women = person as Women; //women为null ,因为男人不能转换为女人

然要小心”as”只好动用被援类型或者只是为null类型。若目标或也基元类型,则当通过”is”操作符来过滤

if(!(person is int))
{
    Women women = person as Women;
}

子类与子类之间的横向转换,应该定义转换操作符(关键字implicit、explicit)

9.收获一个只是空类型Nullable的价值,安全简单的做法是故”??”,如 int j = i ?? 0;,普通做法:

if(i.HasValue()) { int j = i.Value; }

10.常量const同就读字段readonly的界别:

  • const是编译期常量,它总是静态的,编译时直用实际值填充。而readonly是一个运行时常量。
  • const只好修饰基元类型、枚举类型、字符串类型,而readonly没有限制。
  • const一经讲明就亟须起头化,且之后就是无法再度变动。而readonly可显式先导化,也但是不开始化,它的价值好因而构造函数来改(即每个实例有谈得来的readonly只读字段值)
    注意:除了构造函数之外,都无法转移readonly的价,对于引用类型是无能为力改观其的援,即其不得不引用同一对象。但该对象自我是可于改动的。

11.枚举类型

  • 枚举类型可以为自byte到ulong的基元类型,定义枚举时当一味为它们定义一个零值,因为宣称一个枚举变量而无起初化时之默认值将是0
  • 除外0值,要么都非也成员显式赋值,要么即使举赋值(如以了Flags特性的标志枚举),否则不赋值的分子用抵它前边一个成员的值加1,因为枚举成员的值默认是依顺序依次个加1
  • 本着枚举应用[Flags]特点,可以定义一个标志枚举,它的成员值平常初叶化为2的次幂,之后虽得透过按位运算来判断、合并枚举成员了。
  • 概念一个枚举来专门负责表示状态的音信,这样使代码更易精通。如用枚举成员on、off来取代true、false或0、1

12.设欲,应该为项目重载常用的运算符和于运算符,如重载”>”以促成person1>person2

13.假使该类型有泛型版本,则应采用泛型版本,因为泛型类型效能又强(避免了装箱、拆箱、类型转换)

14.相等性

  • 值类型:对于价值很是的有限单值类型变量A、B,”A==B”和”A.Equals(B)”都回来true,而Object.ReferenceEquals(A,B)连回到false。
  • 引用类型:Object.ReferenceEquals(A,B)比的是援引是否当,而默认的A.Equals(B)也是相比较的援,需要重载Equals()方法来落实引用类型中的”值相等性相比较”(如:当person1.ID == person2.ID时,person1.Equals(person2)回true,来代表他们等)
  • 小心1:重写了Equals()方法,最好也同由重新写GetHashCode()方法,因为对不同的目的,默认的GetHashCode()重回的值将永生永世不同,而即使把对象作为Dictionary<TKey,电视alue>的TKey时,依照TKey取值时,会冲目标的HashCode来相比。所以待重新GetHashCode(),使得Equals()方法再次来到true时,GetHashCode()重临的价也同样,这样字典才会健康工作。
  • 留意2:重写了Equals()、GetHashCode()方法,同时也应该实现IEquatable接口,该接口的分子bool
    Equals(T t1)比Object的Equals(object obj)类型又安全、更敏捷。
  • 注意3:对于字符串,即便它们呢是目的,但当半单字符串所蕴涵的字面值一样不时,运行时拿只是当内存中开创一个该字面值的字符串对象,也就是说有字面值一样的字符串对象还用引用和一个地址。

15.ToString()方法

应当总是为从定义类型又写Object的ToString()方法,最好还要实现IFormattable接口,该接口的ToString(string format, IFormatProvider formatProvider)提供了冲参数来输出特定的格式化格局。如:

public string ToString(string format, IFormatProvider formatProvider)
{
    switch(format)
    {
        case "CH":
                return this.ToString();
        case "EN":
                return string.Format("{0}{1}",FirstName,LastName);
        ......
    }
}
//调用
Console.WriteLine(person.ToString("EN",null));

16.目的的浅拷贝与深拷贝

  • 浅拷贝:使用Object基类的实例方法MemberwiseClone()来博对象的一个浅拷贝副本。
  • 深拷贝:通过序列化与相反体系化来丰盛拷贝一个靶。
    常备做法,如下:接口ICloneable唯一成员是object
    Clone(),实现该接口就是为讲明该种的贯彻好给拷贝

[Serializable]
class Person : ICloneable
{
    public string ID {get;set;}
    public int Age {get;set;}
    public Work work {get;set;} 
    //实现ICloneable接口的Clone()
    public object Clone()
    {
        return this.MemberwiseClone();
    }
    //自定义深拷贝方法
    public Person DeepClone()
    {
        using (Stream objectStream = new MemoryStream())
        {
            IFormatter formatter = new BinaryFormatter();
            formatter.Serialize(objectStream, this);
            objectStream.Seek(0, SeekOrigin.Begin);
            return formatter.Deserialize(objectStream) as Person;
        }
     }
}

17.集合的遍历

  • for循环:采纳索引器,for循环的长是遍历过程遭到得修改集合的素。
  • foreach循环:采纳迭代器,遍历过程被无法对聚集增删元素操作,因为迭代器只针对旧版本的联谊举行遍历,每一遍迭代都相会进展版本判断,若集合有变化,将吐弃来非常。- –

    • foreach循环的长处是语法更精简,且迭代完毕后自动调用Dispose()(foreach循环内部使用了try…finally)

18.挑正确的集结:详解请参见《C#高等编程》,书被针对聚集讲的好细致

  • 线性:集合的每个元素如故凡1对准1之,大部分常用集合都是线性集合
  • 非线性:1对多、多对1、多对多(树、集HashSet、图)
  • 间接存取:具有索引器,元素按索引器排列,访问、查找速度快,在结尾添加删减速度也急速,但当中去、插入元素效用低(需要走后的有因素)。(数组、List、字符串、结构)
  • 逐条存取:即线性表,可动态扩充或减弱,通过对地点之援来搜索元素,删除、插入元素效率高,但寻找效率不如(需要遍历查找)(Stack、Queue、Dictionary<TKey、电视机alue>、LinkedList等)
  • 多线程集合类:位于System.Collections.Concurrent命名空间中,如ConcurrentBag对许被List、ConcurrentDictionary<TKey,电视alue>、ConcurrentStack、ConcurrentQueue

贯彻自定义集合类时,不要连续自置的集合类,而应该自行实现相应的泛型接口:
IEnumerable:提供迭代效率
ICollection:提供常用操作
IList

19.泛型

  • 免为于定义泛型定义静态成员,在不同的型中共享静态成员没有意义。
  • 记呢泛型参数设定必要之羁绊,因为约下方可使泛型参数成为一个翔实的”对象”,可以看到格类型的实例成员,而未做约束之言语就是一个object对象
  • 必备日常用default(T)为泛型类型变量指定默认值,如T param = default(T);

20.委托

预定义的委托项目能满意大部分司空眼惯需求,大家从没必要声明自己的寄托项目。

  • Action,Action<T1,…,T16>:接受0只或多独输入参数,无重回值
  • Func,Func<T1,…,T16,TResult>:接受0只或多独输入参数,带返值,类型是TResult
  • Predicate:表示定义一组条件并认清参数是否符合条件
    具备一定用途的信托:
  • 事件委托:

public delegate void EventHandler(object sender, EventArgs e);
public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
  • 线程中之嘱托:

public delegate void ThreadStart(); //无参数
public delegate void ParameterrizedThreadStart(object obj); //参数对象obj
  • 异步回调委托:
    public delegate void AsyncCallback(IAsyncResult ar);

21.对于只有所以相同糟,且主体报告句数量较少之艺术,应该运用拉姆da表明式,它一般用于注册于寄、或作任何格局的参数(参数类型是匹配的委托项目)

22.亮委托的真面目:

  • 寄是一个近乎
  • 委托保存着对注册情势的援(方法指针),多播委托保存着一样组方法指针
  • 施行委托,将如约顺序调用方法指针指向的措施
  • 对一个托实例用”=”赋值一个初的形式指针时,将会面调用构造函数实例化一个新的嘱托对象
  • 用在实例化一个寄对象后后,应该时时牢记使用”+=”、”-=”来多、删除新的章程指针
  • 委托类的法:Invoke()默认调用、在线程池中启用一个初线程调用BeginInvoke()、截止EndInvoke()

23.风波呢是寄托,加了event关键字是为着限制委托:

  • 禁绝了在蕴藏类外部对信托事件目的下”=”赋值,确保不会合给埋或赋值为null
  • 禁绝了于含蓄类外部对信托事件目的的直调用,事件之调用应该是含有类的责任
  • 参数1是触发者对象的援,参数2凡是伊芙ntArgs或其派生类的目的(可含蓄部分以在事变触发时需要利用的数)

24.当委托以及拉姆(Lamb)da小心闭包对象

(特别是在循环体中之循环变量,对于C#5.0之foreach则不用顾虑)

  • 当Lambda表达式引用了一些变量时,编译器就碰面自动创制一个闭包对象(如TempClass),该对象的积极分子包含一个对准有些变量的援(如TempClass.i)、和一个与兰姆da表明式等价的不二法门(如TempClass.add,该措施有对片变量的援)。
  • 只要拖欠闭包对象吃的点子成员TempClass.add最终被与给了信托(如MyDel),而委托平时在一部分变量的效率域之外才行。
    也就是说,委托中注册之计有了针对性有的变量的援,形成了诸如JavaScript中之闭包一样的效力,执行委托方时,局部变量的值将是行值,而不是为寄注册形式时之有些变量值。

public static void Main()
    {
        Action act=new Action(()=>Console.WriteLine("Begin"));
        for (int i = 0; i < 5; i++)
        {
            act += () => Console.WriteLine(i.ToString());
        }
        act(); //Begin 5 5 5 5 5  因为委托方法持有了对i的引用,当前i的值为5
        Console.ReadKey();
    }
public static void Main()
    {
        Action act=new Action(()=>Console.WriteLine("Begin"));
        for (int i = 0; i < 5; i++)
        {
            int temp = i; //每次都用一个新的temp变量来保存当前的i值
            act += () => Console.WriteLine(temp.ToString());
        }
        act(); //Begin 0 1 2 3 4
        Console.ReadKey();
    }

25.赋值为null,大部分情下非克提前垃圾回收。

  • 不曾必要将从未由此之实例成员显式赋值为null,因为编译器会忽视该语句。
  • 唯有对之后着实没有由此底静态字段显式赋值为null才来必要,但假若管无相会重就此到其(或者说勿会合还就此到它的包含类)。
  • 拿一个目的赋值为null,它的静态成员不会师跟着变为null,因为静态成员跟类的实例无关,它谋面直接留在内存中,除非显式赋值为null。

继承还有很多别方面的,如连串化与反连串化,分外处理等,由于篇幅有限,只可以当下一样首再公布了

相关文章