C#基础概念

 

1.     面向对象的思想主要包括：继承 多态 封装

●       封装：用抽象的数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型内部。

●       继承：子类拥有父类的所有数据和操作。

●       多态：一个程序中同名的不同方法共存的情况。

  有两种形式的多态– 重载与重写。

 

2.     什么是装箱和拆箱

装箱（boxing)和拆箱(unboxing)机制使得在C#类型系统中，任何值类型、引用类型和object（对象）类型之间进行转换，这种转换称为绑定连接。简单地说，有了装箱和拆箱的概念，对任何类型的值来说最终都可看作是object类型。   1、装箱转换

含义：将一个值类型隐式地转换成一个object类型，或把这个值类型转换成一个被该值类型应用的接口类型，把一个值类型的值装箱，就是创建一个object实例并将值复制给这个object

如：  int I=10;   object obj=I;   也可用显式的方法进行装箱操作： object obj=（object)I;

  2、拆箱转换

  和装箱相反，拆箱转换是指将一个对象类型显式地转换成一个值类型，或将一个接口类型显式地转换成一个执行该接口的值类型。

  过程分两步：

首先，检查这个对象实例，看它是否为给定的值类型的装箱值

然后，把这个实例的值拷贝给值类型的变量。如：

    int I=10;

   object obj=I;

Int j=(int)obj;

 

3.       重载与override

重载是指针对所继承下来到方法，重新设计其处理方式，为将来原本处理方式覆盖过去。

在派生类要覆盖的方法前加override修饰，而基类的同名方法前加virtual修饰。这样就能实现多态。多态指一个程序中同名的不同方法共存的情况。  有两种形式的多态– 重载与重写。

 

4.       值类型和引用类型
●       值类型的变量本身包含他们的数据，而引用类型的变量包含的是指向包含数据的内存块的引用或叫句柄。

●       值类型变量存储在堆栈。每个程序在执行时都有自己的堆栈，其他程序不能访问。

●       引用类型存储在堆。引用类型存贮实际数据的引用值的地址。

●       C#中的引用类型有4种

●      （类、代表、数组、接口）

 

5.       理解委托

代理是C#中的一种新的类型，要把方法作为参数传递给其他方法时，需要用到代理。

方法通过参数获得外界传递给他的数据，并对这些数据进行一定的操作。

C＃通过代理机制来实现，通过参数把一个方法传递给另外一个方法。

代理四步曲：

a．生成自定义代理类：delegate int MyDelegate();

b．用New运算符实例化代理类：

        MyDelegate d = new MyDelegate(MyClass.MyMethod);

c．最后通过实例对象调用方法：int ret = d();

d. 在程序中像调用方法一样应用代理的实例对象调用它指向的方法。      delegate int d(int I);

 

6.       C#中的接口和类

什么是类?类可以这么理解.类就是功能的集合.类也可以看做是实现一种功能的集合或者方法..接口的概念:什么是接口?接口可以理解为,对类的规定,对类的约束,甚至对整个项目的约束. 种模版，定义了对象必须实现的方法，其目的就是让这些方法可以作为接口实例被引用。接口不能被实例化。接口是负责功能的定义，项目中通过接口来规范类，操作类以及抽象类的概念！而类是负责功能的具体实现！在类中也有抽象类的定义，抽象类与接口的区别在于：抽象类是一个不完全的类，类里面有抽象的方法，属性，也可以有具体的方法和属性，需要进一步的专业化。但接口是一个行为的规范，里面的所有东西都是抽象的！一个类只可以继承一个基类也就是父类，但可以实现多个接口

 

7.       net中读写数据库需要用到的类

Connection DataAdapter DataSet Command DataReader

 

8.       理解.net中的垃圾回收机制

如果发现内存不够,则垃圾回收器,将全部对象作为无效对象(被回收对象),然后先将全局变量,static,处于活动中的局部变量,以及当前CG指针指向的对象放入一个表中.然后

会搜索新列表中的对象所引用的对象.加入列表中,其他没有被加入列表的对象都会被回收.

非托管对象要记得释放资源就行了吧.

 

9.       .net的错误处理机制

错误的处理顺序:finally先,catch次之,最后退会try代码..取消此次操作.返回catch中的异常信息.当然,你也可以定制自己的错误处理机制...如果你的异常处理中包含finally块.则此finally无论是否发生异常始终会被执行...

 

10.   c#中的using和new

using 的用途是为某个namespace建立别名，或者引用存在系统中的其它namespace.

New 用来创建实例，或者覆写方法。

 

11.   类和结构的区别

1. 值类型与引用类型

●       结构是值类型：值类型在堆栈上分配地址

●       类是引用类型：引用类型在堆上分配地址

2．继承性

●      结构：不能从另外一个结构或者类继承，本身也不能被继承，虽然没有明确sealed声明，可结构是隐式的sealed .

●       类：完全可扩展的，除非显式声明sealed， 否则类可以继承其他类和接口，自身也能被继承 。

注：虽然结构不能被继承 ，可结构能够继承接口，方法和类继承接口一样 。

3．内部结构的区别：

结构：

●       没有默认的构造函数，可以添加构造函数

●       没有析构函数

●      没有 abstract 和 sealed(因为不能继承)

●      不能有protected 修饰符

●      可以不用new 初始化

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

类：

●       有默认的构造函数

●      有析构函数

●       可以使用 abstract 和 sealed

●      有protected 修饰符

●      必须使用new 初始化

 

12.  CLR

公共语言运行时（Common Language Runtime,CLR）,提供了一个可靠而完善的多语言运行环境。CLR是一个软件引擎，用于加载应用程序、检查错误、进行安全许可认证、执行和清空内存。它属于纯动态运行时的一种，它的主要组成部分是虚拟执行引擎VEE（Virtual Execution Enging），它可以打破语言和平台的限制。

 

13.  C#的优点

 

1.     C#中指针已经消失. 允许对原始指针的有限制的使用.

2.    基于.NET平台的,继承了自动内存管理和垃圾回收的特点.

3.    C#拥有内建的支持来将任何组件转换成一个web service,运行在任何平台上的任何应用程序都可以通过互联网来使用这个服务.

4.     面向对象的

14.  面向对象编程的三大原则

●      继承：都支持类的单一继承，但类可以实现多个接口。所有类都从一个公共的基类继承。

●      封装与可见性：都可决定类成员是否可见。除了C#的internal访问修饰符外，两者可见性机制非常相似

●      多态性：Java和C#都支持某些形式的多态性机制，且两者实现方法非常类似。

 

15.  C#5种类型的可访问性

●       public：成员可以从任何代码访问。

●       protected：成员只能从派生类访问。

●      internal：成员只能从同一程序集的内部访问。

●      protected internal：成员只能从同一程序集内的派生类访问。

●      private：成员只能在当前类的内部访问。

 

16.  C#代码在执行前要编译为中间语言，中间语言的主要特征：

● 面向对象和使用接口

● 值类型和引用类型之间的巨大差别

● 强数据类型

● 使用异常来处理错误

● 使用属性(attribute)

 

17.  C#中引用类型

（类、代表、数组、接口）

18.  对象间可能存在的三种关系

●聚合，一个（较复杂的）对象由其他若干（较简单的）对象作为其构成部分，称作聚合。

●关联，对象之间的静态联系（即通过对象属性体现的联系）称作关联。

●继承。
 

=====================================================================

当初学 C# 时是找个人大概问了一下数据类型和分支语句就开始做项目了。这两天又全面的看了一下相关的基础知识（学而时习之嘛），总结了25个问题：

1.静态成员和非静态成员的区别？
2.const 和 static readonly 区别？
3.extern 是什么意思？
4.abstract 是什么意思？
5.internal 修饰符起什么作用？
6.sealed 修饰符是干什么的？
7.override 和 overload 的区别？
8.什么是索引指示器？
9.new 修饰符是起什么作用？
10.this 关键字的含义？
11.可以使用抽象函数重写基类中的虚函数吗？
12.密封类可以有虚函数吗？
13.什么是属性访问器？
14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？
15.接口可以包含哪些成员？
16.类和结构的区别？
17.接口的多继承会带来哪些问题？
18.抽象类和接口的区别？
19.别名指示符是什么？
20.如何手工释放资源？
21.P/Invoke是什么？
22.StringBuilder 和 String 的区别？
23.explicit 和 implicit 的含义？
24.params 有什么用？
25.什么是反射？

以下是我做的一份参考答案（C# 语言范畴之内），如果有不准确、不全面的，欢迎各位朋友指正！

 
1.静态成员和非静态成员的区别？

---

 

答：

静态变量使用 static 修饰符进行声明，在类被实例化时创建，通过类进行访问

不带有 static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问

一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值

静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等

示例：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example01
{
     class  Program
    {
         class  Class1
        {
             public   static  String staticStr  =   " Class " ;
             public  String notstaticStr  =   " Obj " ;
        }
         static   void  Main( string [] args)
        {
             // 静态变量通过类进行访问，该类所有实例的同一静态变量都是同一个值
            Console.WriteLine( " Class1's staticStr: {0} " , Class1.staticStr);
 
            Class1 tmpObj1  =   new  Class1();
            tmpObj1.notstaticStr  =   " tmpObj1 " ;
            Class1 tmpObj2  =   new  Class1();
            tmpObj2.notstaticStr  =   " tmpObj2 " ;
 
             // 非静态变量通过对象进行访问，不同对象的同一非静态变量可以有不同的值
            Console.WriteLine( " tmpObj1's notstaticStr: {0} " , tmpObj1.notstaticStr);
            Console.WriteLine( " tmpObj2's notstaticStr: {0} " , tmpObj2.notstaticStr);
 
            Console.ReadLine();
        }
    }
}

 

结果：
Class1's staticStr: Class
tmpObj1's notstaticStr: tmpObj1
tmpObj2's notstaticStr: tmpObj2

2.const 和 static readonly 区别？

---

 

答：

const

用 const 修饰符声明的成员叫常量，是在编译期初始化并嵌入到客户端程序

static readonly

用 static readonly 修饰符声明的成员依然是变量，只不过具有和常量类似的使用方法：通过类进行访问、初始化后不可以修改。但与常量不同的是这种变量是在运行期初始化

示例：

测试类：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example02Lib
{
     public   class  Class1
    {
         public   const  String strConst  =   " Const " ;
         public   static   readonly  String strStaticReadonly  =   " StaticReadonly " ;
         // public const String strConst = "Const Changed";
         // public static readonly String strStaticReadonly = "StaticReadonly Changed";
    }
}
 
客户端代码：

using  System;
using  System.Collections.Generic;
using  System.Text;
using  Example02Lib;
 
namespace  Example02
{
     class  Program
    {
         static   void  Main( string [] args)
        {
             // 修改Example02中Class1的strConst初始值后，只编译Example02Lib项目
             // 然后到资源管理器里把新编译的Example02Lib.dll拷贝Example02.exe所在的目录，执行Example02.exe
             // 切不可在IDE里直接调试运行因为这会重新编译整个解决方案！！
 
             // 可以看到strConst的输出没有改变，而strStaticReadonly的输出已经改变
             // 表明Const变量是在编译期初始化并嵌入到客户端程序，而StaticReadonly是在运行时初始化的
            Console.WriteLine( " strConst : {0} " , Class1.strConst);
            Console.WriteLine( " strStaticReadonly : {0} " , Class1.strStaticReadonly);
 
            Console.ReadLine();
        }
    }
}
结果：
strConst : Const
strStaticReadonly : StaticReadonly 

 

修改后的示例：

 

测试类：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example02Lib
{
     public   class  Class1
    {
         // public const String strConst = "Const";
         // public static readonly String strStaticReadonly = "StaticReadonly";
         public   const  String strConst  =   " Const Changed " ;
         public   static   readonly  String strStaticReadonly  =   " StaticReadonly Changed " ;
    }
}
结果

strConst : Const
strStaticReadonly : StaticReadonly Changed

3.extern 是什么意思？

---

 

答：

extern 修饰符用于声明由程序集外部实现的成员函数

经常用于系统API函数的调用（通过 DllImport ）。注意，和DllImport一起使用时要加上 static 修饰符

也可以用于对于同一程序集不同版本组件的调用（用 extern 声明别名）

不能与 abstract 修饰符同时使用

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Runtime.InteropServices;
 
namespace  Example03
{
     class  Program
    {
         // 注意DllImport是一个Attribute Property，在System.Runtime.InteropServices命名空间中定义
         // extern与DllImport一起使用时必须再加上一个static修饰符
        [DllImport( " User32.dll " )]
         public   static   extern   int  MessageBox( int  Handle,  string  Message,  string  Caption,  int  Type);
 
         static   int  Main()
        {
             string  myString;
            Console.Write( " Enter your message:  " );
            myString  =  Console.ReadLine();
             return  MessageBox( 0 , myString,  " My Message Box " ,  0 );
        }
    }
}

结果：
 

4.abstract 是什么意思？

---

 

答：

abstract 修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员

abstract 不可以和 static 、virtual 一起使用

声明为 abstract 成员可以不包括实现代码，但只要类中还有未实现的抽象成员（即抽象类），那么它的对象就不能被实例化，通常用于强制继承类必须实现某一成员

示例：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example04
{
     #region  基类，抽象类
     public   abstract   class  BaseClass
    {
         // 抽象属性，同时具有get和set访问器表示继承类必须将该属性实现为可读写
         public   abstract  String Attribute
        {
             get ;
             set ;
        }
 
         // 抽象方法，传入一个字符串参数无返回值
         public   abstract   void  Function(String value);
 
         // 抽象事件，类型为系统预定义的代理(delegate)：EventHandler
         public   abstract   event  EventHandler Event;
 
         // 抽象索引指示器，只具有get访问器表示继承类必须将该索引指示器实现为只读
         public   abstract  Char  this [ int  Index]
        {
             get ;
        }
    }
     #endregion
 
     #region  继承类
     public   class  DeriveClass : BaseClass
    {
         private  String attribute;
 
         public   override  String Attribute
        {
             get
            {
                 return  attribute;
            }
             set
            {
                attribute  =  value;
            }
        }
         public   override   void  Function(String value)
        {
            attribute  =  value;
             if  (Event  !=   null )
            {
                Event( this ,  new  EventArgs());
            }
        }
         public   override   event  EventHandler Event;
         public   override  Char  this [ int  Index]
        {
             get
            {
                 return  attribute[Index];
            }
        }
    }
     #endregion
 
     class  Program
    {
         static   void  OnFunction( object  sender, EventArgs e)
        {
             for  ( int  i  =   0 ; i  <  ((DeriveClass)sender).Attribute.Length; i ++ )
            {
                Console.WriteLine(((DeriveClass)sender)[i]);
            }
        }
         static   void  Main( string [] args)
        {
            DeriveClass tmpObj  =   new  DeriveClass();
 
            tmpObj.Attribute  =   " 1234567 " ;
            Console.WriteLine(tmpObj.Attribute);
 
             // 将静态函数OnFunction与tmpObj对象的Event事件进行关联
            tmpObj.Event  +=   new  EventHandler(OnFunction);
 
            tmpObj.Function( " 7654321 " );
 
            Console.ReadLine();
        }
    }
}
结果：
1234567
7
6
5
4
3
2
1  

5.internal 修饰符起什么作用？

---

 

答：

internal 修饰符可以用于类型或成员，使用该修饰符声明的类型或成员只能在同一程集内访问

接口的成员不能使用 internal 修饰符

值得注意的是，如果为 internal 成员加上了 protected 修饰符，这时的访问级别为 internal 或 protected。只是看字面意思容易弄错，许多人认为 internal protected 应该是“只有同一个程序集中的子类可以访问”，但其实它表示“同一个程序集中的所有类，以及所有程序集中的子类都可以访问”

示例

Example05Lib 项目的 Class1

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example05Lib
{
     public   class  Class1
    {
         internal  String strInternal  =   null ;
         public  String strPublic;
         internal   protected  String strInternalProtected  =   null ;
    }
}

结果
Example05Lib 项目的 Class2 类可以访问到 Class1 的 strInternal 成员，当然也可以访问到 strInternalProtected 成员，因为他们在同一个程序集里

Example05 项目里的 Class3 类无法访问到 Class1 的 strInternal 成员，因为它们不在同一个程序集里。但却可以访问到 strInternalProtected 成员，因为 Class3 是 Class1 的继承类

Example05 项目的 Program 类既无法访问到 Class1 的 strInternal 成员，也无法访问到 strInternalProtected 成员，因为它们既不在同一个程序集里也不存在继承关系

 
6.sealed 修饰符是干什么的？

---

 

答：

sealed 修饰符表示密封

用于类时，表示该类不能再被继承，不能和 abstract 同时使用，因为这两个修饰符在含义上互相排斥

用于方法和属性时，表示该方法或属性不能再被重写，必须和 override 关键字一起使用，因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员

通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱

恰当的利用 sealed 修饰符也可以提高一定的运行效率，因为不用考虑继承类会重写该成员

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example06
{
     class  Program
    {
         class  A
        {
             public   virtual   void  F()
            {
                Console.WriteLine( " A.F " );
            }
             public   virtual   void  G()
            {
                Console.WriteLine( " A.G " );
            }
        }
         class  B : A
        {
             public   sealed   override   void  F()
            {
                Console.WriteLine( " B.F " );
            }
             public   override   void  G()
            {
                Console.WriteLine( " B.G " );
            }
        }
         class  C : B
        {
             public   override   void  G()
            {
                Console.WriteLine( " C.G " );
            }
        }
         static   void  Main( string [] args)
        {
             new  A().F();
             new  A().G();
             new  B().F();
             new  B().G();
             new  C().F();
             new  C().G();
 
            Console.ReadLine();
        }
    }
}

结果：
类 B 在继承类 A 时可以重写两个虚函数，如图所示：

 

由于类 B 中对 F 方法进行了密封， 类 C 在继承类 B 时只能重写一个函数，如图所示：

 

控制台输出结果，类 C 的方法 F 只能是输出 类B 中对该方法的实现：

A.F
A.G
B.F
B.G
B.F
C.G

7.override 和 overload 的区别？

---

 

答：

override 表示重写，用于继承类对基类中虚成员的实现

overload 表示重载，用于同一个类中同名方法不同参数（包括类型不同或个数不同）的实现

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example07
{
     class  Program
    {
         class  BaseClass
        {
             public   virtual   void  F()
            {
                Console.WriteLine( " BaseClass.F " );
            }
        }
         class  DeriveClass : BaseClass
        {
             public   override   void  F()
            {
                 base .F();
                Console.WriteLine( " DeriveClass.F " );
            }
             public   void  Add( int  Left,  int  Right)
            {
                Console.WriteLine( " Add for Int: {0} " , Left  +  Right);
            }
             public   void  Add( double  Left,  double  Right)
            {
                Console.WriteLine( " Add for int: {0} " , Left  +  Right);
            }
        }
         static   void  Main( string [] args)
        {
            DeriveClass tmpObj  =   new  DeriveClass();
            tmpObj.F();
            tmpObj.Add( 1 ,  2 );
            tmpObj.Add( 1.1 ,  2.2 );
 
            Console.ReadLine();
        }
    }
}

结果：
BaseClass.F
DeriveClass.F
Add for Int: 3
Add for int: 3.3

8.什么是索引指示器？

---

 

答：

实现索引指示器（indexer）的类可以象数组那样使用其实例后的对象，但与数组不同的是索引指示器的参数类型不仅限于int

简单来说，其本质就是一个含参数属性

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example08
{
     public   class  Point
    {
         private   double  x, y;
         public  Point( double  X,  double  Y)
        {
            x  =  X;
            y  =  Y;
        }
         // 重写ToString方法方便输出
         public   override   string  ToString()
        {
             return  String.Format( " X: {0} , Y: {1} " , x, y);
        }
    }
     public   class  Points
    {
        Point[] points;
         public  Points(Point[] Points)
        {
            points  =  Points;
        }
         public   int  PointNumber
        {
             get  
            { 
                 return  points.Length; 
            }
        }    
         // 实现索引访问器
         public  Point  this [ int  Index]
        {
             get
            {
                 return  points[Index];
            }
        }
    }
 
     // 感谢watson hua( http://huazhihao.cnblogs.com/ )的指点
     // 索引指示器的实质是含参属性，参数并不只限于int
     class  WeatherOfWeek
    {
         public   string   this [ int  Index]
        {
             get
            {
                 // 注意case段使用return直接返回所以不需要break
                 switch  (Index)
                {
                     case   0 :
                        {
                             return   " Today is cloudy! " ;
                        }
                     case   5 :
                        {
                             return   " Today is thundershower! " ;
                        }
                     default :
                        {
                             return   " Today is fine! " ;
                        }
                }
            }
        }
         public   string   this [ string  Day]
        {
             get
            {
                 string  TodayWeather  =   null ;
                 // switch的标准写法
                 switch  (Day)
                {
                     case   " Sunday " :
                        {
                            TodayWeather  =   " Today is cloudy! " ;
                             break ;
                        }
                     case   " Friday " :
                        {
                            TodayWeather  =   " Today is thundershower! " ;
                             break ;
                        }
                     default :
                        {
                            TodayWeather  =   " Today is fine! " ;
                             break ;
                        }
                }
                 return  TodayWeather;
            }
        }
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
            Point[] tmpPoints  =   new  Point[ 10 ];
             for  ( int  i  =   0 ; i  <  tmpPoints.Length; i ++ )
            {
                tmpPoints[i]  =   new  Point(i, Math.Sin(i));
            }
 
            Points tmpObj  =   new  Points(tmpPoints);
             for  ( int  i  =   0 ; i  <  tmpObj.PointNumber; i ++ )
            {
                Console.WriteLine(tmpObj[i]);
            }
 
 
             string [] Week  =   new   string [] {  " Sunday " ,  " Monday " ,  " Tuesday " ,  " Wednesday " ,  " Thursday " ,  " Friday " ,  " Staurday " };
            WeatherOfWeek tmpWeatherOfWeek  =   new  WeatherOfWeek();
             for  ( int  i  =   0 ; i  <   6 ; i ++ )
            {
                Console.WriteLine(tmpWeatherOfWeek[i]);
            }
             foreach  ( string  tmpDay  in  Week)
            {
                Console.WriteLine(tmpWeatherOfWeek[tmpDay]);
            }
 
            Console.ReadLine();
        }
    }
}
结果：
X:  0  , Y:  0
X:  1  , Y:  0.841470984807897
X:  2  , Y:  0.909297426825682
X:  3  , Y:  0.141120008059867
X:  4  , Y:  - 0.756802495307928
X:  5  , Y:  - 0.958924274663138
X:  6  , Y:  - 0.279415498198926
X:  7  , Y:  0.656986598718789
X:  8  , Y:  0.989358246623382
X:  9  , Y:  0.412118485241757
Today  is  cloudy !
Today  is  fine !
Today  is  fine !
Today  is  fine !
Today  is  fine !
Today  is  thundershower !
Today  is  cloudy !
Today  is  fine !
Today  is  fine !
Today  is  fine !
Today  is  fine !
Today  is  thundershower !
Today  is  fine !

 

9.new 修饰符是起什么作用？

---

 

答：

new 修饰符与 new 操作符是两个概念

new 修饰符用于声明类或类的成员，表示隐藏了基类中同名的成员。而new 操作符用于实例化一个类型

new 修饰符只能用于继承类，一般用于弥补基类设计的不足

new 修饰符和 override 修饰符不可同时用在一个成员上，因为这两个修饰符在含义上互相排斥

示例：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example09
{
     class  BaseClass
    {
         // 基类设计者声明了一个PI的公共变量，方便进行运算
         public   static   double  PI  =   3.1415 ;
    }
     class  DervieClass : BaseClass
    {
         // 继承类发现该变量的值不能满足运算精度，于是可以通过new修饰符显式隐藏基类中的声明
         public   new   static   double  PI  =   3.1415926 ;
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
            Console.WriteLine(BaseClass.PI);
            Console.WriteLine(DervieClass.PI);
 
            Console.ReadLine();
        }
    }
}
结果：
3.1415
3.1415926  

10.this 关键字的含义？

---

 

答：

this 是一个保留字，仅限于构造函数和方法成员中使用

在类的构造函数中出现表示对正在构造的对象本身的引用，在类的方法中出现表示对调用该方法的对象的引用，在结构的构造上函数中出现表示对正在构造的结构的引用，在结构的方法中出现表示对调用该方法的结果的引用

this 保留字不能用于静态成员的实现里，因为这时对象或结构并未实例化

在 C# 系统中，this 实际上是一个常量，所以不能使用 this++ 这样的运算

this 保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身

示例：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example10
{
     class  Class1
    {
         private   double  c;
         private   string  value;
 
         public   double  C
        {
             get
            {
                 return  c;
            }
        }
         public  Class1( double  c)
        {
             // 限定同名的隐藏成员
             this .c  =  c;
        }
         public  Class1(Class1 value)
        {
             // 用对象本身实例化自己没有意义
             if  ( this   !=  value)
            {
                c  =  value.C;
            }
        }
         public   override   string  ToString()
        {
             // 将对象本身做为参数
             return   string .Format( " {0} Celsius = {1} Fahrenheit " , c, UnitTransClass.C2F( this ));
        }
 
         // 由于好奇，在这做了一个效率测试，想看看到底哪种方式访问成员变量更快，结论：区别不大。。。
         public   string  Test1()
        {
             long  vTickCount  =  Environment.TickCount;
             for  ( int  i  =   0 ; i  <   10000000 ; i ++ )
                 this .value  =  i.ToString();
             return   string .Format( " Have this.: {0} MSEL " , Environment.TickCount  -  vTickCount);
        }
         public   string  Test2()
        {
             long  vTickCount  =  Environment.TickCount;
             for  ( int  i  =   0 ; i  <   10000000 ; i ++ )
                value  =  i.ToString();
             return   string .Format( " Don't have this.: {0} MSEL " , Environment.TickCount  -  vTickCount);
        }
    }
     class  UnitTransClass
    {
         public   static   double  C2F(Class1 value)
        {
             // 摄氏到华氏的转换公式
             return   1.8   *  value.C  +   32 ;
        }
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
            Class1 tmpObj  =   new  Class1( 37.5 );
 
            Console.WriteLine(tmpObj);
 
            Console.WriteLine(tmpObj.Test1());
            Console.WriteLine(tmpObj.Test2());
 
            Console.ReadLine();
        }
    }
}
结果：
37.5  Celsius  =   99.5  Fahrenheit
Have  this .:  4375  MSEL
Don ' t have this.: 4406 MSEL 

11.可以使用抽象函数重写基类中的虚函数吗？

---

 

答：

可以

需使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现

或增加 override 修饰符，表示抽象重写了基类中该函数的实现

示例:

    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    abstract class  DeriveClass1 : BaseClass
    {
        public abstract new void F();
    }
 
    //感谢watson hua(http://huazhihao.cnblogs.com/)的指点
    //是他提醒了我还可以用这种方法抽象重写基类的虚方法
    abstract class DeriveClass2 : BaseClass
    {
        public abstract override void F();
    }

12.密封类可以有虚函数吗？

---

 

答：

可以，基类中的虚函数将隐式的转化为非虚函数，但密封类本身不能再增加新的虚函数

示例：

    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    sealed class DeriveClass : BaseClass
    {
        //基类中的虚函数F被隐式的转化为非虚函数
 
        //密封类中不能再声明新的虚函数G
        //public virtual void G()
        //{
        //    Console.WriteLine("DeriveClass.G");
        //}
    }

13.什么是属性访问器？

---

 

答：

属性访问器（Property Accessor），包括 get 访问器和 set 访问器分别用于字段的读写操作

其设计目的主要是为了实现面向对象（OO）中的封装思想。根据该思想，字段最好设为private，一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问

另外要注意属性本身并不一定和字段相联系

 

14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？

---

 

答：

abstract 修饰符不可以和 static、virtual 修饰符一起使用

abstract 修饰符可以和 override 一起使用，参见第11点

示例：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example14
{
     class  BaseClass
    {
         public   virtual   void  F()
        {
            Console.WriteLine( " BaseClass.F " );
        }
    }
     abstract   class  DeriveClass1 : BaseClass
    {
         // 在这里， abstract是可以和override一起使用的
         public   abstract   override   void  F();
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
        }
    }
}

15.接口可以包含哪些成员？

---

 

答：

接口可以包含属性、方法、索引指示器和事件，但不能包含常量、域、操作符、构造函数和析构函数，而且也不能包含任何静态成员

 

16.类和结构的区别？

---

 

答：
类：

类是引用类型在堆上分配，类的实例进行赋值只是复制了引用，都指向同一段实际对象分配的内存

类有构造和析构函数

类可以继承和被继承

结构：

结构是值类型在栈上分配（虽然栈的访问速度比较堆要快，但栈的资源有限放），结构的赋值将分配产生一个新的对象。

结构没有构造函数，但可以添加。结构没有析构函数

结构不可以继承自另一个结构或被继承，但和类一样可以继承自接口

 

示例：

根据以上比较，我们可以得出一些轻量级的对象最好使用结构，但数据量大或有复杂处理逻辑对象最好使用类。

如：Geoemtry（GIS 里的一个概论，在 OGC 标准里有定义） 最好使用类，而 Geometry 中点的成员最好使用结构

 

17.接口的多继承会带来哪些问题？

---

 

答：

C# 中的接口与类不同，可以使用多继承，即一个子接口可以有多个父接口。但如果两个父成员具有同名的成员，就产生了二义性（这也正是 C# 中类取消了多继承的原因之一），这时在实现时最好使用显式的声明

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example17
{
     class  Program
    {
         // 一个完整的接口声明示例
         interface  IExample
        {
             // 属性
             string  P
            {
                 get ;
                 set ;
            }
             // 方法
             string  F( int  Value);
             // 事件
             event  EventHandler E;
             // 索引指示器
             string   this [ int  Index]
            {
                 get ;
                 set ;
            }
        }
         interface  IA
        {
             int  Count {  get ;  set ;}
        }
         interface  IB
        {
             int  Count();
        }
         // IC接口从IA和IB多重继承
         interface  IC : IA, IB
        {
        }
         class  C : IC
        {
             private   int  count  =   100 ;
             // 显式声明实现IA接口中的Count属性
             int  IA.Count
            {
                 get  {  return   100 ; }
                 set  { count  =  value; }
            }
             // 显式声明实现IB接口中的Count方法
             int  IB.Count()
            {
                 return  count  *  count;
            }
        }
         static   void  Main( string [] args)
        {
            C tmpObj  =   new  C();
 
             // 调用时也要显式转换
            Console.WriteLine( " Count property: {0} " , ((IA)tmpObj).Count);
            Console.WriteLine( " Count function: {0} " , ((IB)tmpObj).Count());
 
            Console.ReadLine();
        }
    }
}
结果：
Count property:  100
Count function:  10000

 

18.抽象类和接口的区别？

---

 

答：

抽象类（abstract class）可以包含功能定义和实现，接口（interface）只能包含功能定义

抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性

分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么”

为外部提供调用或功能需要扩充时优先使用接口

19.别名指示符是什么？

---

 

答：

通过别名指示符我们可以为某个类型起一个别名

主要用于解决两个命名空间内有同名类型的冲突或避免使用冗余的命名空间

别名指示符在所有命名空间最外层定义，作用域为整个单元文件。如果定义在某个命名空间内，那么它只在直接隶属的命名空间内起作用

示例：

 

Class1.cs: 


using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01
{
     class  Class1
    {
         public   override   string  ToString()
        {
             return   " com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1 " ;
        }
    }
}
Class2.cs： 


using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02
{
     class  Class1
    {
         public   override   string  ToString()
        {
             return   " com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02's Class1 " ;
        }
    }
}
主单元（Program.cs）：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
// 使用别名指示符解决同名类型的冲突
// 在所有命名空间最外层定义，作用域为整个单元文件
using  Lib01Class1  =  com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
using  Lib02Class2  =  com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02.Class1;
 
namespace  Example19
{
     namespace  Test1
    {
         // Test1Class1在Test1命名空间内定义，作用域仅在Test1之内
         using  Test1Class1  =  com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
 
         class  Class1
        {
             // Lib01Class1和Lib02Class2在这可以正常使用
            Lib01Class1 tmpObj1  =   new  Lib01Class1();
            Lib02Class2 tmpObj2  =   new  Lib02Class2();
             // TestClass1在这可以正常使用
            Test1Class1 tmpObj3  =   new  Test1Class1();
        }
    }
     namespace  Test2
    {
         using  Test1Class2  =  com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
 
         class  Program
        {
             static   void  Main( string [] args)
            {
                 // Lib01Class1和Lib02Class2在这可以正常使用
                Lib01Class1 tmpObj1  =   new  Lib01Class1();
                Lib02Class2 tmpObj2  =   new  Lib02Class2();
 
                 // 注意这里，TestClass1在这不可以正常使用。
                 // 因为，在Test2命名空间内不能使用Test1命名空间定义的别名
                 // Test1Class1 tmpObj3 = new Test1Class1();
                
                 // TestClass2在这可以正常使用
                Test1Class2 tmpObj3  =   new  Test1Class2();
 
                Console.WriteLine(tmpObj1);
                Console.WriteLine(tmpObj2);
                Console.WriteLine(tmpObj3);
 
                Console.ReadLine();
            }
        }
    }
}

结果：
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01 ' s Class1
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02 ' s Class1
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01 ' s Class1

 

20.如何手工释放资源？

---

 

答：

 .NET 平台在内存管理方面提供了GC（Garbage Collection），负责自动释放托管资源和内存回收的工作。但在以下两种情况需要我们手工进行资源释放：一、由于它无法对非托管资源进行释放，所以我们必须自己提供方法来释放对象内分配的非托管资源，比如你在对象的实现代码中使用了一个COM对象；二、你的类在运行是会产生大量实例（象 GIS 中的Geometry），必须自己手工释放这些资源以提高程序的运行效率

最理想的办法是通过实现一个接口显式的提供给客户调用端手工释放对象，System 命名空间内有一个 IDisposable 接口，拿来做这事非常合适，省得我们自己再声明一个接口了 
示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example20
{
     class  Program
    {
         class  Class1 : IDisposable
        {
             // 析构函数，编译后变成 protected void Finalize()，GC会在回收对象前会调用调用该方法
             ~ Class1()
            {
                Dispose( false );
            }
 
             // 通过实现该接口，客户可以显式地释放对象，而不需要等待GC来释放资源，据说那样会降低效率
             void  IDisposable.Dispose()
            {
                Dispose( true );
            }
 
             // 将释放非托管资源设计成一个虚函数，提供在继承类中释放基类的资源的能力
             protected   virtual   void  ReleaseUnmanageResources()
            {
                 // Do something...
            }
 
             // 私有函数用以释放非托管资源
             private   void  Dispose( bool  disposing)
            {
                ReleaseUnmanageResources();
 
                 // 为true时表示是客户显式调用了释放函数，需通知GC不要再调用对象的Finalize方法
                 // 为false时肯定是GC调用了对象的Finalize方法，所以没有必要再告诉GC你不要调用我的Finalize方法啦
                 if  (disposing)
                {
                    GC.SuppressFinalize( this );
                }
            } 
        }
         static   void  Main( string [] args)
        {
             // tmpObj1没有手工释放资源，就等着GC来慢慢的释放它吧
            Class1 tmpObj1  =   new  Class1();
 
             // tmpObj2调用了Dispose方法，传说比等着GC来释放它效率要调一些
             // 个人认为是因为要逐个对象的查看其元数据，以确认是否实现了Dispose方法吧
             // 当然最重要的是我们可以自己确定释放的时间以节省内存，优化程序运行效率
            Class1 tmpObj2  =   new  Class1();
            ((IDisposable)tmpObj2).Dispose();
        }
    }
}

 

21.P/Invoke是什么？

---

 

答：

在受控代码与非受控代码进行交互时会产生一个事务（transition） ，这通常发生在使用平台调用服务（Platform Invocation Services），即P/Invoke

如调用系统的 API 或与 COM 对象打交道，通过 System.Runtime.InteropServices 命名空间

虽然使用 Interop 非常方便，但据估计每次调用事务都要执行 10 到 40 条指令，算起来开销也不少，所以我们要尽量少调用事务

如果非用不可，建议本着一次调用执行多个动作，而不是多次调用每次只执行少量动作的原则

 

22.StringBuilder 和 String 的区别？

---

 

答：

String 在进行运算时（如赋值、拼接等）会产生一个新的实例，而 StringBuilder 则不会。所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder，不要使用 String

另外，对于 String 我们不得不多说几句：

1.它是引用类型，在堆上分配内存

2.运算时会产生一个新的实例

3.String 对象一旦生成不可改变（Immutable）

3.定义相等运算符（== 和 !=）是为了比较 String 对象（而不是引用）的值

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example22
{
     class  Program
    {
         static   void  Main( string [] args)
        {
             const   int  cycle  =   10000 ;
 
             long  vTickCount  =  Environment.TickCount;
            String str  =   null ;
             for  ( int  i  =   0 ; i  <  cycle; i ++ )
                str  +=  i.ToString();
            Console.WriteLine( " String: {0} MSEL " , Environment.TickCount  -  vTickCount);
 
            vTickCount  =  Environment.TickCount;
             // 看到这个变量名我就生气，奇怪为什么大家都使它呢？ ：）
            StringBuilder sb  =   new  StringBuilder();
             for  ( int  i  =   0 ; i  <  cycle; i ++ )
                sb.Append(i);
            Console.WriteLine( " StringBuilder: {0} MSEL " , Environment.TickCount  -  vTickCount);
 
             string  tmpStr1  =   " A " ;
             string  tmpStr2  =  tmpStr1;
            Console.WriteLine(tmpStr1);
            Console.WriteLine(tmpStr2);
             // 注意后面的输出结果，tmpStr1的值改变并未影响到tmpStr2的值
            tmpStr1  =   " B " ;
            Console.WriteLine(tmpStr1);
            Console.WriteLine(tmpStr2);
 
            Console.ReadLine();
        }
    }
}
结果：
String:  375  MSEL
StringBuilder:  16  MSEL
A
A
B
A

 

 

23.explicit 和 implicit 的含义？

---

 

答：

explicit 和 implicit 属于转换运算符，如用这两者可以让我们自定义的类型支持相互交换

explicti 表示显式转换，如从 A -> B 必须进行强制类型转换（B = (B)A）

implicit 表示隐式转换，如从 B -> A 只需直接赋值（A = B）

隐式转换可以让我们的代码看上去更漂亮、更简洁易懂，所以最好多使用 implicit 运算符。不过！如果对象本身在转换时会损失一些信息（如精度），那么我们只能使用 explicit 运算符，以便在编译期就能警告客户调用端

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example23
{
     class  Program
    {
         // 本例灵感来源于大话西游经典台词“神仙？妖怪？”--主要是我实在想不出什么好例子了
         class  Immortal
        {
             public   string  name;
             public  Immortal( string  Name)
            {
                name  =  Name;
            }
             public   static   implicit   operator  Monster(Immortal value)
            {
                 return   new  Monster(value.name  +   " ：神仙变妖怪？偷偷下凡即可。。。 " );
            }
        }
         class  Monster
        {
             public   string  name;
             public  Monster( string  Name)
            {
                name  =  Name;
            }
             public   static   explicit   operator  Immortal(Monster value)
            {
                 return   new  Immortal(value.name  +   " ：妖怪想当神仙？再去修炼五百年！ " );
            }
        }
         static   void  Main( string [] args)
        {
            Immortal tmpImmortal  =   new  Immortal( " 紫霞仙子 " );
             // 隐式转换
            Monster tmpObj1  =  tmpImmortal;
            Console.WriteLine(tmpObj1.name);
 
            Monster tmpMonster  =   new  Monster( " 孙悟空 " );
             // 显式转换
            Immortal tmpObj2  =  (Immortal)tmpMonster;
            Console.WriteLine(tmpObj2.name);
 
            Console.ReadLine();
        }
    }
}

结果：
紫霞仙子：神仙变妖怪？偷偷下凡即可。。。
孙悟空：妖怪想当神仙？再去修炼五百年！

 
24.params 有什么用？

---

 

答：

params 关键字在方法成员的参数列表中使用，为该方法提供了参数个数可变的能力

它在只能出现一次并且不能在其后再有参数定义，之前可以

示例：

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  ConsoleApplication1
{
     class  App
    {
         // 第一个参数必须是整型，但后面的参数个数是可变的。
         // 而且由于定的是object数组，所有的数据类型都可以做为参数传入
         public   static   void  UseParams( int  id,  params   object [] list)
        {
            Console.WriteLine(id);
             for  ( int  i  =   0 ; i  <  list.Length; i ++ )
            {
                Console.WriteLine(list[i]);
            }
        }
 
         static   void  Main()
        {
             // 可变参数部分传入了三个参数，都是字符串类型
            UseParams( 1 ,  " a " ,  " b " ,  " c " );
             // 可变参数部分传入了四个参数，分别为字符串、整数、浮点数和双精度浮点数数组
            UseParams( 2 ,  " d " ,  100 ,  33.33 ,  new   double [] {  1.1 ,  2.2  });
 
            Console.ReadLine();
        }
    }
}
结果：
1
a
b
c
2
d
100
33.33
System.Double[] 

25.什么是反射？

---

 

答：

反射，Reflection，通过它我们可以在运行时获得各种信息，如程序集、模块、类型、字段、属性、方法和事件

通过对类型动态实例化后，还可以对其执行操作

简单来说就是用string可以在runtime为所欲为的东西，实际上就是一个.net framework内建的万能工厂

一般用于插件式框架程序和设计模式的实现，当然反射是一种手段可以充分发挥其能量来完成你想做的任何事情（前面好象见过一位高人用反射调用一个官方类库中未说明的函数。。。）

示例：

 

using  System;
using  System.Collections.Generic;
using  System.Text;
 
namespace  Example25Lib
{
     public   class  Class1
    {
         private   string  name;
         private   int  age;
 
         // 如果显式的声明了无参数构造函数，客户端只需要用程序集的CreateInstance即可实例化该类
         // 在此特意不实现，以便在客户调用端体现构造函数的反射实现
         // public Class1()
         // {
         // }
         public  Class1( string  Name,  int  Age)
        {
            name  =  Name;
            age  =  Age;
        }
         public   void  ChangeName( string  NewName)
        {
            name  =  NewName;
        }
         public   void  ChangeAge( int  NewAge)
        {
            age  =  NewAge;
        }
         public   override   string  ToString()
        {
             return   string .Format( " Name: {0}, Age: {1} " , name, age);
        }
    }
}
反射实例化对象并调用其方法，属性和事件的反射调用略去

using  System;
using  System.Collections.Generic;
using  System.Text;
 
// 注意添加该反射的命名空间
using  System.Reflection;
 
namespace  Example25
{
     class  Program
    {
         static   void  Main( string [] args)
        {
             // 加载程序集
            Assembly tmpAss  =  Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory  +   " Example25Lib.dll " );
 
             // 遍历程序集内所有的类型，并实例化
            Type[] tmpTypes  =  tmpAss.GetTypes();
             foreach  (Type tmpType  in  tmpTypes)
            {
                 // 获取第一个类型的构造函数信息
                ConstructorInfo[] tmpConsInfos  =  tmpType.GetConstructors();
                 foreach  (ConstructorInfo tmpConsInfo  in  tmpConsInfos)
                {
                     // 为构造函数生成调用的参数集合
                    ParameterInfo[] tmpParamInfos  =  tmpConsInfo.GetParameters(); 
                     object [] tmpParams  =   new   object [tmpParamInfos.Length];
                     for  ( int  i  =   0 ; i  <  tmpParamInfos.Length; i ++ )
                    {
                        tmpParams[i]  =  tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
                         if  (tmpParamInfos[i].ParameterType.FullName  ==   " System.String " )
                        {
                            tmpParams[i]  =   " Clark " ;
                        }
                    }
 
                     // 实例化对象
                     object  tmpObj  =  tmpConsInfo.Invoke(tmpParams);
                    Console.WriteLine(tmpObj);
 
                     // 获取所有方法并执行
                     foreach  (MethodInfo tmpMethod  in  tmpType.GetMethods())
                    {
                         // 为方法的调用创建参数集合
                        tmpParamInfos  =  tmpMethod.GetParameters();
                        tmpParams  =   new   object [tmpParamInfos.Length];
                         for  ( int  i  =   0 ; i  <  tmpParamInfos.Length; i ++ )
                        {
                            tmpParams[i]  =  tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
                             if  (tmpParamInfos[i].ParameterType.FullName  ==   " System.String " )
                            {
                                tmpParams[i]  =   " Clark Zheng " ;
                            }
                             if  (tmpParamInfos[i].ParameterType.FullName  ==   " System.Int32 " )
                            {
                                tmpParams[i]  =   27 ;
                            }
                        }
                        tmpMethod.Invoke(tmpObj, tmpParams);
                    }
 
                     // 调用完方法后再次打印对象，比较结果
                    Console.WriteLine(tmpObj);
                }
            }
 
            Console.ReadLine();
        }
    }
}
结果：
Name: Clark, Age:  0
Name: Clark Zheng, Age:  27  

 

示例下载：http://files.cnblogs.com/reonlyrun/CSharp25QExample07.rar

如果你认为还有哪些概念比较重要或容易混淆，可以在回复中提出，我会及时更新这篇随笔

 转载自：http://www.cnblogs.com/luomingui/archive/2010/03/03/1677718.html

转载于:https://www.cnblogs.com/zhaoshujie/p/9594757.html