C#基础概念二十五问

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

1.静态变量和非静态变量的区别？
2.const和staticreadonly区别？
3.extern是什么意思？
4.abstract是什么意思？
5.internal修饰符起什么作用？
6.sealed修饰符是干什么的？
7.override和overload的区别？
8.什么是索引指示器？
9.new修饰符是起什么作用？
10.this关键字的含义？
11.可以使用抽象函数重写基类中的虚函数吗？
12.密封类可以有虚函数吗？
13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有get和set两个呢？
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修饰符声明的变量称做非静态变量

在类被实例化时创建

通过对象进行访问

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample01
{
classProgram
{
classClass1
{
publicstaticStringstaticStr="Class";
publicStringnotstaticStr="Obj";
}
staticvoidMain(string[]args)
{
//静态变量通过类进行访问，该类所有实例的同一静态变量都是同一个值
Console.WriteLine("Class1'sstaticStr:{0}",Class1.staticStr);

Class1tmpObj1=newClass1();
tmpObj1.notstaticStr="tmpObj1";
Class1tmpObj2=newClass1();
tmpObj2.notstaticStr="tmpObj2";

//非静态变量通过对象进行访问，不同对象的同一非静态变量可以有不同的值
Console.WriteLine("tmpObj1'snotstaticStr:{0}",tmpObj1.notstaticStr);
Console.WriteLine("tmpObj2'snotstaticStr:{0}",tmpObj2.notstaticStr);

Console.ReadLine();
}
}
}
结果：
Class1'sstaticStr:Class
tmpObj1'snotstaticStr:tmpObj1
tmpObj2'snotstaticStr:tmpObj2


2.const和staticreadonly区别？

答：

const

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

staticreadonly

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

示例：

测试类：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample02Lib
{
publicclassClass1
{
publicconstStringstrConst="Const";
publicstaticreadonlyStringstrStaticReadonly="StaticReadonly";
//publicconstStringstrConst="ConstChanged";
//publicstaticreadonlyStringstrStaticReadonly="StaticReadonlyChanged";
}
}

客户端代码：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;
usingExample02Lib;

namespaceExample02
{
classProgram
{
staticvoidMain(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

修改后的示例：

测试类：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample02Lib
{
publicclassClass1
{
//publicconstStringstrConst="Const";
//publicstaticreadonlyStringstrStaticReadonly="StaticReadonly";
publicconstStringstrConst="ConstChanged";
publicstaticreadonlyStringstrStaticReadonly="StaticReadonlyChanged";
}
}
结果

strConst:Const
strStaticReadonly:StaticReadonlyChanged


3.extern是什么意思？

答：

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

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

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

不能与abstract修饰符同时使用

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;
usingSystem.Runtime.InteropServices;

namespaceExample03
{
classProgram
{
//注意DllImport是一个AttributeProperty，在System.Runtime.InteropServices命名空间中定义
//extern与DllImport一起使用时必须再加上一个static修饰符
[DllImport("User32.dll")]
publicstaticexternintMessageBox(intHandle,stringMessage,stringCaption,intType);

staticintMain()
{
stringmyString;
Console.Write("Enteryourmessage:");
myString=Console.ReadLine();
returnMessageBox(0,myString,"MyMessageBox",0);
}
}
}
结果：



4.abstract是什么意思？

答：

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

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample04
{
#region基类，抽象类
publicabstractclassBaseClass
{
//抽象属性，同时具有get和set访问器表示继承类必须将该属性实现为可读写
publicabstractStringAttribute
{
get;
set;
}

//抽象方法，传入一个字符串参数无返回值
publicabstractvoidFunction(Stringvalue);

//抽象事件，类型为系统预定义的代理(delegate)：EventHandler
publicabstracteventEventHandlerEvent;

//抽象索引指示器，只具有get访问器表示继承类必须将该索引指示器实现为只读
publicabstractCharthis[intIndex]
{
get;
}
}
#endregion

#region继承类
publicclassDeriveClass:BaseClass
{
privateStringattribute;

publicoverrideStringAttribute
{
get
{
returnattribute;
}
set
{
attribute=value;
}
}
publicoverridevoidFunction(Stringvalue)
{
attribute=value;
if(Event!=null)
{
Event(this,newEventArgs());
}
}
publicoverrideeventEventHandlerEvent;
publicoverrideCharthis[intIndex]
{
get
{
returnattribute[Index];
}
}
}
#endregion

classProgram
{
staticvoidOnFunction(objectsender,EventArgse)
{
for(inti=0;i<((DeriveClass)sender).Attribute.Length;i++)
{
Console.WriteLine(((DeriveClass)sender)[i]);
}
}
staticvoidMain(string[]args)
{
DeriveClasstmpObj=newDeriveClass();

tmpObj.Attribute="1234567";
Console.WriteLine(tmpObj.Attribute);

//将静态函数OnFunction与tmpObj对象的Event事件进行关联
tmpObj.Event+=newEventHandler(OnFunction);

tmpObj.Function("7654321");

Console.ReadLine();
}
}
}
结果：
1234567
7
6
5
4
3
2
1


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

答：

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

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

示例

Example05Lib项目的Class1

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample05Lib
{
publicclassClass1
{
internalStringstrInternal=null;
publicStringstrPublic;
}
}
结果
Example05Lib项目的Class2类可以访问到Class1的strInternal成员



Example05项目的Program类无法访问到Class1的strInternal成员




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

答：

sealed修饰符表示密封

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

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

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample06
{
classProgram
{
classA
{
publicvirtualvoidF()
{
Console.WriteLine("A.F");
}
publicvirtualvoidG()
{
Console.WriteLine("A.G");
}
}
classB:A
{
publicsealedoverridevoidF()
{
Console.WriteLine("B.F");
}
publicoverridevoidG()
{
Console.WriteLine("B.G");
}
}
classC:B
{
publicoverridevoidG()
{
Console.WriteLine("C.G");
}
}
staticvoidMain(string[]args)
{
newA().F();
newA().G();
newB().F();
newB().G();
newC().F();
newC().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表示重载，用于同一个类中同名方法不同参数（包括类型不同或个数不同）的实现

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample07
{
classProgram
{
classBaseClass
{
publicvirtualvoidF()
{
Console.WriteLine("BaseClass.F");
}
}
classDeriveClass:BaseClass
{
publicoverridevoidF()
{
base.F();
Console.WriteLine("DeriveClass.F");
}
publicvoidAdd(intLeft,intRight)
{
Console.WriteLine("AddforInt:{0}",Left+Right);
}
publicvoidAdd(doubleLeft,doubleRight)
{
Console.WriteLine("Addforint:{0}",Left+Right);
}
}
staticvoidMain(string[]args)
{
DeriveClasstmpObj=newDeriveClass();
tmpObj.F();
tmpObj.Add(1,2);
tmpObj.Add(1.1,2.2);

Console.ReadLine();
}
}
}
结果：
BaseClass.F
DeriveClass.F
AddforInt:3
Addforint:3.3


8.什么是索引指示器？

答：

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

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

示例：


usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample08
{
publicclassPoint
{
privatedoublex,y;
publicPoint(doubleX,doubleY)
{
x=X;
y=Y;
}
//重写ToString方法方便输出
publicoverridestringToString()
{
returnString.Format("X:{0},Y:{1}",x,y);
}
}
publicclassPoints
{
Point[]points;
publicPoints(Point[]Points)
{
points=Points;
}
publicintPointNumber
{
get
{
returnpoints.Length;
}
}
//实现索引访问器
publicPointthis[intIndex]
{
get
{
returnpoints[Index];
}
}
}

//感谢watsonhua(http://huazhihao.cnblogs.com/)的指点
//索引指示器的实质是含参属性，参数并不只限于int
classWeatherOfWeek
{
publicstringthis[intIndex]
{
get
{
//注意case段使用return直接返回所以不需要break
switch(Index)
{
case0:
{
return"Todayiscloudy!";
}
case5:
{
return"Todayisthundershower!";
}
default:
{
return"Todayisfine!";
}
}
}
}
publicstringthis[stringDay]
{
get
{
stringTodayWeather=null;
//switch的标准写法
switch(Day)
{
case"Sunday":
{
TodayWeather="Todayiscloudy!";
break;
}
case"Friday":
{
TodayWeather="Todayisthundershower!";
break;
}
default:
{
TodayWeather="Todayisfine!";
break;
}
}
returnTodayWeather;
}
}
}
classProgram
{
staticvoidMain(string[]args)
{
Point[]tmpPoints=newPoint[10];
for(inti=0;i<tmpPoints.Length;i++)
{
tmpPoints[i]=newPoint(i,Math.Sin(i));
}

PointstmpObj=newPoints(tmpPoints);
for(inti=0;i<tmpObj.PointNumber;i++)
{
Console.WriteLine(tmpObj[i]);
}


string[]Week=newstring[]{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Staurday"};
WeatherOfWeektmpWeatherOfWeek=newWeatherOfWeek();
for(inti=0;i<6;i++)
{
Console.WriteLine(tmpWeatherOfWeek[i]);
}
foreach(stringtmpDayinWeek)
{
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
Todayiscloudy!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisthundershower!
Todayiscloudy!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisthundershower!
Todayisfine!



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

答：

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

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

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample09
{
classBaseClass
{
//基类设计者声明了一个PI的公共变量，方便进行运算
publicstaticdoublePI=3.1415;
}
classDervieClass:BaseClass
{
//继承类发现该变量的值不能满足运算精度，于是可以通过new修饰符显示隐藏基类中的声明
publicnewstaticdoublePI=3.1415926;
}
classProgram
{
staticvoidMain(string[]args)
{
Console.WriteLine(BaseClass.PI);
Console.WriteLine(DervieClass.PI);

Console.ReadLine();
}
}
}
结果：
3.1415
3.1415926


10.this关键字的含义？

答：

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

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

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

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample10
{
classClass1
{
privatedoublec;
privatestringvalue;

publicdoubleC
{
get
{
returnc;
}
}
publicClass1(doublec)
{
//限定同名的隐藏成员
this.c=c;
}
publicClass1(Class1value)
{
//用对象本身实例化自己没有意义
if(this!=value)
{
c=value.C;
}
}
publicoverridestringToString()
{
//将对象本身做为参数
returnstring.Format("{0}Celsius={1}Fahrenheit",c,UnitTransClass.C2F(this));
}

//由于好奇，在这做了一个效率测试，想看看到底哪种方式访问成员变量更快，结论：区别不大。。。
publicstringTest1()
{
longvTickCount=Environment.TickCount;
for(inti=0;i<10000000;i++)
this.value=i.ToString();
returnstring.Format("Havethis.:{0}MSEL",Environment.TickCount-vTickCount);
}
publicstringTest2()
{
longvTickCount=Environment.TickCount;
for(inti=0;i<10000000;i++)
value=i.ToString();
returnstring.Format("Don'thavethis.:{0}MSEL",Environment.TickCount-vTickCount);
}
}
classUnitTransClass
{
publicstaticdoubleC2F(Class1value)
{
//摄氏到华氏的转换公式
return1.8*value.C+32;
}
}
classProgram
{
staticvoidMain(string[]args)
{
Class1tmpObj=newClass1(37.5);

Console.WriteLine(tmpObj);

Console.WriteLine(tmpObj.Test1());
Console.WriteLine(tmpObj.Test2());

Console.ReadLine();
}
}
}
结果：
37.5Celsius=99.5Fahrenheit
Havethis.:4375MSEL
Don'thavethis.:4406MSEL


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

答：

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

示例:

classBaseClass
{
publicvirtualvoidF()
{
Console.WriteLine("BaseClass.F");
}
}
abstractclassDeriveClass:BaseClass
{
publicnewabstractvoidF();
}

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

答：

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

示例：

classBaseClass
{
publicvirtualvoidF()
{
Console.WriteLine("BaseClass.F");
}
}
sealedclassDeriveClass:BaseClass
{
//基类中的虚函数F被隐式的转化为非虚函数

//密封类中不能再声明新的虚函数G
//publicvirtualvoidG()
//{
//Console.WriteLine("DeriveClass.G");
//}
}

13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有get和set两个呢？

答：

如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后也应只有一个。如果基类中有get和set两个属性访问器，那么继承类中可以只有一个也可以同时有两个属性访问器


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

答：

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


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

答：

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



16.类和结构的区别？

答：
类：

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

类有构造和析构函数

类可以继承和被继承

结构：

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

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

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



示例：

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

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

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample16
{
interfaceIPoint
{
doubleX
{
get;
set;
}
doubleY
{
get;
set;
}
doubleZ
{
get;
set;
}
}
//结构也可以从接口继承
structPoint:IPoint
{
privatedoublex,y,z;
//结构也可以增加构造函数
publicPoint(doubleX,doubleY,doubleZ)
{
this.x=X;
this.y=Y;
this.z=Z;
}
publicdoubleX
{
get{returnx;}
set{x=value;}
}
publicdoubleY
{
get{returnx;}
set{x=value;}
}
publicdoubleZ
{
get{returnx;}
set{x=value;}
}
}
//在此简化了点状Geometry的设计，实际产品中还包含Project（坐标变换）等复杂操作
classPointGeometry
{
privatePointvalue;

publicPointGeometry(doubleX,doubleY,doubleZ)
{
value=newPoint(X,Y,Z);
}
publicPointGeometry(Pointvalue)
{
//结构的赋值将分配新的内存
this.value=value;
}
publicdoubleX
{
get{returnvalue.X;}
set{this.value.X=value;}
}
publicdoubleY
{
get{returnvalue.Y;}
set{this.value.Y=value;}
}
publicdoubleZ
{
get{returnvalue.Z;}
set{this.value.Z=value;}
}
publicstaticPointGeometryoperator+(PointGeometryLeft,PointGeometryRigth)
{
returnnewPointGeometry(Left.X+Rigth.X,Left.Y+Rigth.Y,Left.Z+Rigth.Z);
}
publicoverridestringToString()
{
returnstring.Format("X:{0},Y:{1},Z:{2}",value.X,value.Y,value.Z);
}
}
classProgram
{
staticvoidMain(string[]args)
{
PointtmpPoint=newPoint(1,2,3);

PointGeometrytmpPG1=newPointGeometry(tmpPoint);
PointGeometrytmpPG2=newPointGeometry(tmpPoint);
tmpPG2.X=4;
tmpPG2.Y=5;
tmpPG2.Z=6;

//由于结构是值类型，tmpPG1和tmpPG2的坐标并不一样
Console.WriteLine(tmpPG1);
Console.WriteLine(tmpPG2);

//由于类是引用类型，对tmpPG1坐标修改后影响到了tmpPG3
PointGeometrytmpPG3=tmpPG1;
tmpPG1.X=7;
tmpPG1.Y=8;
tmpPG1.Z=9;
Console.WriteLine(tmpPG1);
Console.WriteLine(tmpPG3);

Console.ReadLine();
}
}
}
结果：
X:1,Y:2,Z:3
X:4,Y:5,Z:6
X:7,Y:8,Z:9
X:7,Y:8,Z:9


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

答：

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample17
{
classProgram
{
//一个完整的接口声明示例
interfaceIExample
{
//属性
stringP
{
get;
set;
}
//方法
stringF(intValue);
//事件
eventEventHandlerE;
//索引指示器
stringthis[intIndex]
{
get;
set;
}
}
interfaceIA
{
intCount{get;set;}
}
interfaceIB
{
intCount();
}
//IC接口从IA和IB多重继承
interfaceIC:IA,IB
{
}
classC:IC
{
privateintcount=100;
//显式声明实现IA接口中的Count属性
intIA.Count
{
get{return100;}
set{count=value;}
}
//显式声明实现IB接口中的Count方法
intIB.Count()
{
returncount*count;
}
}
staticvoidMain(string[]args)
{
CtmpObj=newC();

//调用时也要显式转换
Console.WriteLine("Countproperty:{0}",((IA)tmpObj).Count);
Console.WriteLine("Countfunction:{0}",((IB)tmpObj).Count());

Console.ReadLine();
}
}
}
结果：
Countproperty:100
Countfunction:10000


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

答：

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

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

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

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


19.别名指示符是什么？

答：

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

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

别名指示符只在一个单元文件内起作用

示例：

Class1.cs:

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespacecom.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01
{
classClass1
{
publicoverridestringToString()
{
return"com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01'sClass1";
}
}
}
Class2.cs

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespacecom.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02
{
classClass1
{
publicoverridestringToString()
{
return"com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02'sClass1";
}
}
}
主单元（Program.cs）：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

//使用别名指示符解决同名类型的冲突
usingLib01Class1=com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01.Class1;
usingLib02Class2=com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02.Class1;

namespaceExample19
{
classProgram
{
staticvoidMain(string[]args)
{
Lib01Class1tmpObj1=newLib01Class1();
Lib02Class2tmpObj2=newLib02Class2();

Console.WriteLine(tmpObj1);
Console.WriteLine(tmpObj2);

Console.ReadLine();
}
}
}
结果：
com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01'sClass1
com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02'sClass1



20.如何释放非托管资源？

答：

.NET平台在内存管理方面提供了GC（GarbageCollection），负责自动释放托管资源和内存回收的工作，但它无法对非托管资源进行释放，这时我们必须自己提供方法来释放对象内分配的非托管资源，比如你在对象的实现代码中使用了一个COM对象

最简单的办法，可以通过实现protectedvoidFinalize()（析构函数会在编译时变成这个东东）来释放非托管资源，因为GC在释放对象时会检查该对象是否实现了Finalize()方法，如果是则调用它。但，据说这样会降低效率。。。

有一种更好的，那就是通过实现一个接口显式的提供给客户调用端手工释放对象的方法，而不是傻傻的等着GC来释放我们的对象（何况效率又那么低）

System命名空间内有一个IDisposable接口，拿来做这事非常合适，就省得我们自己再声明一个接口了

另外补充一句，这种实现并不一定要使用了非托管资源后才用，如果你设计的类会在运行时有大些的实例（象GIS中的Geometry），为了优化程序性能，你也可以通过实现该接口让客户调用端在确认不需要这些对象时手工释放它们

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample20
{
classProgram
{
classClass1:IDisposable
{
//析构函数，编译后变成protectedvoidFinalize()，GC会在回收对象前会调用调用该方法
~Class1()
{
Dispose(false);
}

//通过实现该接口，客户可以显式地释放对象，而不需要等待GC来释放资源，据说那样会降低效率
voidIDisposable.Dispose()
{
Dispose(true);
}

//将释放非托管资源设计成一个虚函数，提供在继承类中释放基类的资源的能力
protectedvirtualvoidReleaseUnmanageResources()
{
//Dosomething...
}

//私有函数用以释放非托管资源
privatevoidDispose(booldisposing)
{
ReleaseUnmanageResources();

//为true时表示是客户显式调用了释放函数，需通知GC不要再调用对象的Finalize方法
//为false时肯定是GC调用了对象的Finalize方法，所以没有必要再告诉GC你不要调用我的Finalize方法啦
if(disposing)
{
GC.SuppressFinalize(this);
}
}
}
staticvoidMain(string[]args)
{
//tmpObj1没有手工释放资源，就等着GC来慢慢的释放它吧
Class1tmpObj1=newClass1();

//tmpObj2调用了Dispose方法，传说比等着GC来释放它效率要调一些
//个人认为是因为要逐个对象的查看其元数据，以确认是否实现了Dispose方法吧
//当然最重要的是我们可以自己确定释放的时间以节省内存，优化程序运行效率
Class1tmpObj2=newClass1();
((IDisposable)tmpObj2).Dispose();
}
}
}

21.P/Invoke是什么？

答：

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

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

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

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



22.StringBuilder和String的区别？

答：

String虽然是一个引用类型，但在赋值操作时会产生一个新的对象，而StringBuilder则不会

所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用StringBuilder，不要使用String

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample22
{
classProgram
{
staticvoidMain(string[]args)
{
constintcycle=100000;

longvTickCount=Environment.TickCount;
Stringstr=null;
for(inti=0;i<cycle;i++)
str+=i.ToString();
Console.WriteLine("String:{0}MSEL",Environment.TickCount-vTickCount);

vTickCount=Environment.TickCount;
//看到这个变量名我就生气，奇怪为什么大家都使它呢？：）
StringBuildersb=newStringBuilder();
for(inti=0;i<cycle;i++)
sb.Append(i);
Console.WriteLine("StringBuilder:{0}MSEL",Environment.TickCount-vTickCount);

Console.ReadLine();
}
}
}
结果：
String:102047MSEL
StringBuilder:46MSEL


23.explicit和implicit的含义？

答：

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

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

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample23
{
classProgram
{
//本例灵感来源于大话西游经典台词“神仙？妖怪？”--主要是我实在想不出什么好例子了
classImmortal
{
publicstringname;
publicImmortal(stringName)
{
name=Name;
}
publicstaticimplicitoperatorMonster(Immortalvalue)
{
returnnewMonster(value.name+"：神仙变妖怪？偷偷下凡即可。。。");
}
}
classMonster
{
publicstringname;
publicMonster(stringName)
{
name=Name;
}
publicstaticexplicitoperatorImmortal(Monstervalue)
{
returnnewImmortal(value.name+"：妖怪想当神仙？再去修炼五百年！");
}
}
staticvoidMain(string[]args)
{
ImmortaltmpImmortal=newImmortal("紫霞仙子");
//隐式转换
MonstertmpObj1=tmpImmortal;
Console.WriteLine(tmpObj1.name);

MonstertmpMonster=newMonster("孙悟空");
//显式转换
ImmortaltmpObj2=(Immortal)tmpMonster;
Console.WriteLine(tmpObj2.name);

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


24.params有什么用？

答：

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceConsoleApplication1
{
classApp
{
//第一个参数必须是整型，但后面的参数个数是可变的。
//而且由于定的是object数组，所有的数据类型都可以做为参数传入
publicstaticvoidUseParams(intid,paramsobject[]list)
{
Console.WriteLine(id);
for(inti=0;i<list.Length;i++)
{
Console.WriteLine(list[i]);
}
}

staticvoidMain()
{
//可变参数部分传入了三个参数，都是字符串类型
UseParams(1,"a","b","c");
//可变参数部分传入了四个参数，分别为字符串、整数、浮点数和双精度浮点数数组
UseParams(2,"d",100,33.33,newdouble[]{1.1,2.2});

Console.ReadLine();
}
}
}
结果：
1
a
b
c
2
d
100
33.33
System.Double[]


25.什么是反射？

答：

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

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

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

示例：

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

namespaceExample25Lib
{
publicclassClass1
{
privatestringname;
privateintage;

//如果显式的声明了无参数构造函数，客户端只需要用程序集的CreateInstance即可实例化该类
//在此特意不实现，以便在客户调用端体现构造函数的反射实现
//publicClass1()
//{
//}
publicClass1(stringName,intAge)
{
name=Name;
age=Age;
}
publicvoidChangeName(stringNewName)
{
name=NewName;
}
publicvoidChangeAge(intNewAge)
{
age=NewAge;
}
publicoverridestringToString()
{
returnstring.Format("Name:{0},Age:{1}",name,age);
}
}
}
反射实例化对象并调用其方法，属性和事件的反射调用略去

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;

//注意添加该反射的命名空间
usingSystem.Reflection;

namespaceExample25
{
classProgram
{
staticvoidMain(string[]args)
{
//加载程序集
AssemblytmpAss=Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory+"Example25Lib.dll");

//遍历程序集内所有的类型，并实例化
Type[]tmpTypes=tmpAss.GetTypes();
foreach(TypetmpTypeintmpTypes)
{
//获取第一个类型的构造函数信息
ConstructorInfo[]tmpConsInfos=tmpType.GetConstructors();
foreach(ConstructorInfotmpConsInfointmpConsInfos)
{
//为构造函数生成调用的参数集合
ParameterInfo[]tmpParamInfos=tmpConsInfo.GetParameters();
object[]tmpParams=newobject[tmpParamInfos.Length];
for(inti=0;i<tmpParamInfos.Length;i++)
{
tmpParams[i]=tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
if(tmpParamInfos[i].ParameterType.FullName=="System.String")
{
tmpParams[i]="Clark";
}
}

//实例化对象
objecttmpObj=tmpConsInfo.Invoke(tmpParams);
Console.WriteLine(tmpObj);

//获取所有方法并执行
foreach(MethodInfotmpMethodintmpType.GetMethods())
{
//为方法的调用创建参数集合
tmpParamInfos=tmpMethod.GetParameters();
tmpParams=newobject[tmpParamInfos.Length];
for(inti=0;i<tmpParamInfos.Length;i++)
{
tmpParams[i]=tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
if(tmpParamInfos[i].ParameterType.FullName=="System.String")
{
tmpParams[i]="ClarkZheng";
}
if(tmpParamInfos[i].ParameterType.FullName=="System.Int32")
{
tmpParams[i]=27;
}
}
tmpMethod.Invoke(tmpObj,tmpParams);
}

//调用完方法后再次打印对象，比较结果
Console.WriteLine(tmpObj);
}
}

Console.ReadLine();
}
}
}
结果：
Name:Clark,Age:0
Name:ClarkZheng,Age:27