您的位置：首页 > 编程语言 > C#

C#基础概念二十五问（17－25）[转贴]

2007-06-02 09:53 483 查看

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

.csharpcode,.csharpcodepre
{
font-size:small;
color:black;
font-family:consolas,"CourierNew",courier,monospace;
background-color:#ffffff;
/*white-space:pre;*/
}
.csharpcodepre{margin:0em;}
.csharpcode.rem{color:#008000;}
.csharpcode.kwrd{color:#0000ff;}
.csharpcode.str{color:#006080;}
.csharpcode.op{color:#0000c0;}
.csharpcode.preproc{color:#cc6633;}
.csharpcode.asp{background-color:#ffff00;}
.csharpcode.html{color:#800000;}
.csharpcode.attr{color:#ff0000;}
.csharpcode.alt
{
background-color:#f4f4f4;
width:100%;
margin:0em;
}
.csharpcode.lnum{color:#606060;}
结果：
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";

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespacecom.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02

classClass1

publicoverridestringToString()

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

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

.csharpcode,.csharpcodepre
{
font-size:small;
color:black;
font-family:consolas,"CourierNew",courier,monospace;
background-color:#ffffff;
/*white-space:pre;*/
}
.csharpcodepre{margin:0em;}
.csharpcode.rem{color:#008000;}
.csharpcode.kwrd{color:#0000ff;}
.csharpcode.str{color:#006080;}
.csharpcode.op{color:#0000c0;}
.csharpcode.preproc{color:#cc6633;}
.csharpcode.asp{background-color:#ffff00;}
.csharpcode.html{color:#800000;}
.csharpcode.attr{color:#ff0000;}
.csharpcode.alt
{
background-color:#f4f4f4;
width:100%;
margin:0em;
}
.csharpcode.lnum{color:#606060;}
结果：
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();

.csharpcode,.csharpcodepre
{
font-size:small;
color:black;
font-family:consolas,"CourierNew",courier,monospace;
background-color:#ffffff;
/*white-space:pre;*/
}
.csharpcodepre{margin:0em;}
.csharpcode.rem{color:#008000;}
.csharpcode.kwrd{color:#0000ff;}
.csharpcode.str{color:#006080;}
.csharpcode.op{color:#0000c0;}
.csharpcode.preproc{color:#cc6633;}
.csharpcode.asp{background-color:#ffff00;}
.csharpcode.html{color:#800000;}
.csharpcode.attr{color:#ff0000;}
.csharpcode.alt
{
background-color:#f4f4f4;
width:100%;
margin:0em;
}
.csharpcode.lnum{color:#606060;}

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

.csharpcode,.csharpcodepre
{
font-size:small;
color:black;
font-family:consolas,"CourierNew",courier,monospace;
background-color:#ffffff;
/*white-space:pre;*/
}
.csharpcodepre{margin:0em;}
.csharpcode.rem{color:#008000;}
.csharpcode.kwrd{color:#0000ff;}
.csharpcode.str{color:#006080;}
.csharpcode.op{color:#0000c0;}
.csharpcode.preproc{color:#cc6633;}
.csharpcode.asp{background-color:#ffff00;}
.csharpcode.html{color:#800000;}
.csharpcode.attr{color:#ff0000;}
.csharpcode.alt
{
background-color:#f4f4f4;
width:100%;
margin:0em;
}
.csharpcode.lnum{color:#606060;}
.csharpcode,.csharpcodepre
{
font-size:small;
color:black;
font-family:consolas,"CourierNew",courier,monospace;
background-color:#ffffff;
/*white-space:pre;*/
}
.csharpcodepre{margin:0em;}
.csharpcode.rem{color:#008000;}
.csharpcode.kwrd{color:#0000ff;}
.csharpcode.str{color:#006080;}
.csharpcode.op{color:#0000c0;}
.csharpcode.preproc{color:#cc6633;}
.csharpcode.asp{background-color:#ffff00;}
.csharpcode.html{color:#800000;}
.csharpcode.attr{color:#ff0000;}
.csharpcode.alt
{
background-color:#f4f4f4;
width:100%;
margin:0em;
}
.csharpcode.lnum{color:#606060;}
结果：
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();

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

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航