C#基础概念二十五问

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();

}

}

}

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();

}

}

}

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();

}

}

}

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();

}

}

}

classBaseClass

{

publicvirtualvoidF()

{

Console.WriteLine("BaseClass.F");

}

}

abstractclassDeriveClass1:BaseClass

{

publicabstractnewvoidF();

}

//感谢watsonhua(http://huazhihao.cnblogs.com/)的指点

//是他提醒了我还可以用这种方法抽象重写基类的虚方法

abstractclassDeriveClass2:BaseClass

{

publicabstractoverridevoidF();

}

classBaseClass

{

publicvirtualvoidF()

{

Console.WriteLine("BaseClass.F");

}

}

sealedclassDeriveClass:BaseClass

{

//基类中的虚函数F被隐式的转化为非虚函数

//密封类中不能再声明新的虚函数G

//publicvirtualvoidG()

//{

//Console.WriteLine("DeriveClass.G");

//}

}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample14

{

classBaseClass

{

publicvirtualvoidF()

{

Console.WriteLine("BaseClass.F");

}

}

abstractclassDeriveClass1:BaseClass

{

//在这里，abstract是可以和override一起使用的

publicabstractoverridevoidF();

}

classProgram

{

staticvoidMain(string[]args)

{

}

}

}

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();

}

}

}

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();

}

}

}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespacecom.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01

{

classClass1

{

publicoverridestringToString()

{

return"com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01'sClass1";

}

}

}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespacecom.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02

{

classClass1

{

publicoverridestringToString()

{

return"com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02'sClass1";

}

}

}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

//使用别名指示符解决同名类型的冲突

//在所有命名空间最外层定义，作用域为整个单元文件

usingLib01Class1=com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;

usingLib02Class2=com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02.Class1;

namespaceExample19

{

namespaceTest1

{

//Test1Class1在Test1命名空间内定义，作用域仅在Test1之内

usingTest1Class1=com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;

classClass1

{

//Lib01Class1和Lib02Class2在这可以正常使用

Lib01Class1tmpObj1=newLib01Class1();

Lib02Class2tmpObj2=newLib02Class2();

//TestClass1在这可以正常使用

Test1Class1tmpObj3=newTest1Class1();

}

}

namespaceTest2

{

usingTest1Class2=com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;

classProgram

{

staticvoidMain(string[]args)

{

//Lib01Class1和Lib02Class2在这可以正常使用

Lib01Class1tmpObj1=newLib01Class1();

Lib02Class2tmpObj2=newLib02Class2();

//注意这里，TestClass1在这不可以正常使用。

//因为，在Test2命名空间内不能使用Test1命名空间定义的别名

//Test1Class1tmpObj3=newTest1Class1();

//TestClass2在这可以正常使用

Test1Class2tmpObj3=newTest1Class2();

Console.WriteLine(tmpObj1);

Console.WriteLine(tmpObj2);

Console.WriteLine(tmpObj3);

Console.ReadLine();

}

}

}

}

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();

}

}

}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample22

{

classProgram

{

staticvoidMain(string[]args)

{

constintcycle=10000;

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);

stringtmpStr1="A";

stringtmpStr2=tmpStr1;

Console.WriteLine(tmpStr1);

Console.WriteLine(tmpStr2);

//注意后面的输出结果，tmpStr1的值改变并未影响到tmpStr2的值

tmpStr1="B";

Console.WriteLine(tmpStr1);

Console.WriteLine(tmpStr2);

Console.ReadLine();

}

}

}

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();

}

}

}

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();

}

}

}

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();

}

}

}