C#/.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。

基础学习

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. 伊芙ntArgs e:伊芙(Eve)ntArgs
    是富含事件数量的类的基类,在事件触发时传递数据,然则 伊夫(Eve)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惠特(Whit)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)
匿名模式 -> 兰姆(Lamb)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. 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。

常用函数

  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、

 

集合类数码存储和摸索

命名空间: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

利用技术

关于循环和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信息、响应客户浏览的网页
  • 库克(Cook)ie对象:记录客户端属性音信,存放在客户端,实现情状管理

小心,ASP.Net 不是一种语言。

 

相关文章