c＃面试笔试题 (全部)

来源：互联网发布：oa java大型源码编辑：程序博客网时间：2024/06/05 04:59

来自：http://www.cnblogs.com/6666/archive/2009/09/23/1572344.html

c＃面试笔试题 (全部)
1. 填空:

(1)面向对象的语言具有________性、_________性、________性。

(2)能用foreach遍历访问的对象需要实现
________________接口或声明________________方法的类型。

(3)列举ADO.net中的五个主要对象_______________、_____________、_______________、_______________、_________________。

2. 不定项选择：

(1) 以下叙述正确的是：

A. 接口中可以有虚方法。 B. 一个类可以实现多个接口。
C. 接口不能被实例化。 D. 接口中可以包含已实现的方法。

(2) 从数据库读取记录，你可能用到的方法有：

A. ExecuteNonQuery B. ExecuteScalar

C. Fill D. ExecuteReader

3. 简述 private、 protected、 public、 internal 修饰符的访问权限。

4. 写出一条Sql语句：取出表A中第31到第40记录（SQLServer, 以自动增长的ID作为主键,
注意：ID可能不是连续的。）

5 .列举ASP.NET 页面之间传递值的几种方式。

6. 写出程序的输出结果

                  class Class1 {
                  private string str = "Class1.str";
                  private int i = 0;
                  static void StringConvert(string str) {
                  str = "string being converted.";
                  }
                  static void StringConvert(Class1 c) {
                  c.str = "string being converted.";
                  }
                  static void Add(int i) {
                  i++;
                  }
                  static void AddWithRef(ref int i) {
                  i++;
                  }
                  static void Main() {
                  int i1 = 10;
                  int i2 = 20;
                  string str = "str";
                  Class1 c = new Class1();
                  Add(i1);
                  AddWithRef(ref i2);
                  Add(c.i);
                  StringConvert(str);
                  StringConvert(c);
                  Console.WriteLine(i1);
                  Console.WriteLine(i2);
                  Console.WriteLine(c.i);
                  Console.WriteLine(str);
                  Console.WriteLine(c.str);
                  }
                  }

7.写出程序的输出结果

                  public abstract class A
                  {
                  public A()
                  {
                  Console.WriteLine('A');
                  }
                  public virtual void Fun()
                  {
                  Console.WriteLine("A.Fun()");
                  }
                  }

                  public class B: A
                  {
                  public B()
                  {
                  Console.WriteLine('B');
                  }

                  public new void Fun()
                  {
                  Console.WriteLine("B.Fun()");
                  }

                  public static void Main()
                  {
                  A a = new B();
                  a.Fun();
                  }
                  }

                  8. 写出程序的输出结果：
                  public class A
                  {
                  public virtual void Fun1(int i)
                  {
                  Console.WriteLine(i);
                  }

                  public void Fun2(A a)
                  {
                  a.Fun1(1);
                  Fun1(5);
                  }
                  }

                  public class B : A
                  {
                  public override void Fun1(int i)
                  {
                  base.Fun1 (i + 1);
                  }

                  public static void Main()
                  {
                  B b = new B();
                  A a = new A();
                  a.Fun2(b);
                  b.Fun2(a);
                  }
                  }

9. 一列数的规则如下: 1、1、2、3、5、8、13、21、34......

求第30位数是多少，用递归算法实现。(C#语言)

10. 程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。(C#语言)

要求： 1.要有联动性，老鼠和主人的行为是被动的。

2.考虑可扩展性，猫的叫声可能引起其他联动效应。

                  参考答案:
                  1. (1) 继承性、封装性、多态性。（考基本概念）
                  (2) IEnumerable 、 GetEnumerator (对foreach机制的理解，本来不想出这题的，凑分)
                  (3) ... (送分题, 对ADO.net的了解)
                  评分标准：一空1分，满分10分。

2. (1) B、C (考对接口的理解) (2) B、C、D (考查对ADO.net的熟练程度)
评分标准: 一题5分，不选或者错选均不得分。漏选得2分。满分10分。

                  3. . private : 私有成员, 在类的内部才可以访问。
                  protected : 保护成员，该类内部和继承类中可以访问。
                  public : 公共成员，完全公开，没有访问限制。
                  internal: 在同一命名空间内可以访问。
                  评分标准：答对1题2分，2题5分，3题7分。全对10分。 (送分题)

                  4. 解1: select top 10 * from A where id not in (select top 30
                  id from A)
                  解2: select top 10 * from A where id > (select max(id) from
                  (select top 30 id from A )as A)
                  评分标准：写对即10分。(答案不唯一，datagrid 分页可能需要用到)

                  5. 1.使用QueryString, 如....?id=1; response. Redirect()....
                  2.使用Session变量
                  3.使用Server.Transfer
                  ....
                  评分标准：答对1点得3分，两点7分， 3点10分。

                  6. (考查值引用和对象引用)
                  10
                  21
                  0
                  str
                  string being converted.
                  评分标准：答对一点得2分，满分10分。

                  7. A
                  B
                  A.Fun()
                  评分标准：写出A.B 得5分，写出A.Fun()得5分，满分10分。
                  (考查在继承类中构造函数, 以及new 方法, )

                  8. 2
                  5
                  1
                  6

评分标准：答对一点得2分，两点得5分，3点得7分。全对得10分。

(一些人做这题，头都晕了.... ^_^ )

                  public class MainClass
                  {
                  public static void Main()
                  {
                  Console.WriteLine(Foo(30));
                  }
                  public static int Foo(int i)
                  {
                  if (i <= 0)
                  return 0;
                  else if(i > 0 && i <= 2)
                  return 1;
                  else return Foo(i -1) + Foo(i - 2);
                  }
                  }
                  评分标准：写出return Foo(i -1) + Foo(i - 2); 得5分。

写出if(i > 0 && i <= 2) return 1; 得5分。

方法参数过多需要扣分（扣除分数 = 参数个数－ 1）

不用递归算法扣5分

(递归算法在树结构建立等方面比较常用)

                  要点：1. 联动效果，运行代码只要执行Cat.Cryed()方法。2. 对老鼠和主人进行抽象
                  评分标准: <1>.构造出Cat、Mouse、Master三个类，并能使程序运行(2分)
                  <2>从Mouse和Master中提取抽象（5分）
                  <3>联动效应，只要执行Cat.Cryed()就可以使老鼠逃跑，主人惊醒。(3分)

                  public interface Observer
                  {
                  void Response(); //观察者的响应，如是老鼠见到猫的反映
                  }
                  public interface Subject
                  {
                  void AimAt(Observer obs); //针对哪些观察者，这里指猫的要扑捉的对象---老鼠
                  }
                  public class Mouse : Observer
                  {
                  private string name;
                  public Mouse(string name, Subject subj)
                  {
                  this.name = name;
                  subj.AimAt(this);
                  }

                  public void Response()
                  {
                  Console.WriteLine(name + " attempt to escape!");
                  }
                  }
                  public class Master : Observer
                  {
                  public Master(Subject subj)
                  {
                  subj.AimAt(this);
                  }

                  public void Response()
                  {
                  Console.WriteLine("Host waken!");
                  }
                  }

                  public class Cat : Subject
                  {
                  private ArrayList observers;
                  public Cat()
                  {
                  this.observers = new ArrayList();
                  }
                  public void AimAt(Observer obs)
                  {
                  this.observers.Add(obs);
                  }
                  public void Cry()
                  {
                  Console.WriteLine("Cat cryed!");
                  foreach (Observer obs in this.observers)
                  {
                  obs.Response();
                  }
                  }
                  }
                  class MainClass
                  {
                  static void Main(string[] args)
                  {
                  Cat cat = new Cat();
                  Mouse mouse1 = new Mouse("mouse1", cat);
                  Mouse mouse2 = new Mouse("mouse2", cat);
                  Master master = new Master(cat);
                  cat.Cry();
                  }
                  }

//---------------------------------------------------------------------------------------------

                  设计方法二: 使用event -- delegate设计..
                  public delegate void SubEventHandler();
                  public abstract class Subject
                  {
                  public event SubEventHandler SubEvent;
                  protected void FireAway()
                  {
                  if (this.SubEvent != null)
                  this.SubEvent();
                  }
                  }
                  public class Cat : Subject
                  {
                  public void Cry()
                  {
                  Console.WriteLine("cat cryed.");
                  this.FireAway();
                  }
                  }
                  public abstract class Observer
                  {
                  public Observer(Subject sub)
                  {
                  sub.SubEvent += new SubEventHandler(Response);
                  }
                  public abstract void Response();
                  }
                  public class Mouse : Observer
                  {
                  private string name;
                  public Mouse(string name, Subject sub) : base(sub)
                  {
                  this.name = name;
                  }
                  public override void Response()
                  {
                  Console.WriteLine(name + " attempt to escape!");
                  }
                  }
                  public class Master : Observer
                  {
                  public Master(Subject sub) : base(sub){}
                  public override void Response()
                  {
                  Console.WriteLine("host waken");
                  }
                  }
                  class Class1
                  {
                  static void Main(string[] args)
                  {
                  Cat cat = new Cat();
                  Mouse mouse1 = new Mouse("mouse1", cat);
                  Mouse mouse2 = new Mouse("mouse2", cat);
                  Master master = new Master(cat);
                  cat.Cry();
                  }

}

第二波

C# 面试笔试题 (http://www.pghome.net)

1、C#中 property 与 attribute的区别，他们各有什么用处，这种机制的好处在哪里？

property和attribute汉语都称之为属性。不过property是指类向外提供的数据区域。而attribute则是描述对象在编译时或运行时属性的。这两者是有本质区别的。

2、讲一讲你理解的web service,在dot net framework中，怎么很好的结合xml?（讲概念就行了）

从表面上看，Web

Service就是一个应用程序，它向外界暴露出一个能够通过Web进行调用的API。这就是说，你能够用编程的方法通过Web调用来实现某个功能的应用程序。从深层次上看，Web

Service是一种新的Web应用程序分支，它们是自包含、自描述、模块化的应用，可以在网络(通常为Web)中被描述、发布、查找以及通过Web来调用。可扩展的标记语言XML是Web

Service平台中表示数据的基本格式。除了易于建立和易于分析外，XML主要的优点在于它既与平台无关，又与厂商无关。XML是由万维网协会(W3C)创建，W3C制定的XML

SchemaXSD定义了一套标准的数据类型，并给出了一种语言来扩展这套数据类型。Web

Service平台是用XSD来作为数据类型系统的。当你用某种语言如VB.NET或C#来构造一个Web

Service时，为了符合Web

Service标准，所有你使用的数据类型都必须被转换为XSD类型。如想让它使用在不同平台和不同软件的不同组织间传递，还需要用某种东西将它包装起来。这种东西就是一种协议，如

SOAP。

3. C#, Java 和 c++的特点，有什么相同的地方，不同的地方，C#分别从c++和java中吸取了他们那些优点？

C#看起来与Java有着惊人的相似;它包括了诸如单一继承,界面,与Java几乎同样的语法,和编译成中间代码再运行的

过程.但是C#与Java有着明显的不同,它借鉴了Delphi的一个特点,与COM(组件对象模型)是直接集成。

微软c#语言定义主

要是从C和C++继承而来的,而且语言中的许多元素也反映了这一点.C#在设计者从C++继承的可选选项方面比Java要广泛一些(比如说

structs),它还增加了自己新的特点(比方说源代码版本定义).

C#从Java继承而来的特点

类:在C#中类的申明与Java很相似。特点看起来与Java相比没有变化.布尔运算:条件表达式的结果是布尔数据类型,布尔数据类型是这种语言中独立的一种数据类型.从布尔类型到其他类型没有

直接的转换过程.布尔常量true和false是C#中的关键字.错误处理:如Java中那样,通过抛出和捕捉异常对象来管理错误处理过程.内存管理:由

底层.NET框架进行自动内存垃圾回收.

C#从C和C++继承的特点

编译:程序直接编译成标准的二进制可执行形式.

结构体:一个C#的结构体与C++的结构体是相似的,因为它能够包含数据申明和方法.但是,不象C++,C#结构体与类是不同的而且不支持继承.但是,与Java相同的是,一个结构体可以实现界面.

预编译:C#中存在预编译指令支持条件编译,警告,错误报告和编译行控制. #error

C#独有的特点

中间代码:微软在用户选择何时MSIL应该编译成机器码的时候是留了很大的余地.微软公司很小心的声称MSIL不是解释性的,而是被编译成了机器码.它也明

白许多--如果不是大多数的话--程序员认为Java程序要不可避免的比C编写的任何东西都要慢.而这种实现方式决定了基于MSIL的程序(指的是用

C#,Visual Basic,"Managed

C++"--C++的一个符合CLS的版本--等语言编写的程序)将在性能上超过"解释性的"Java代码.当然,这一点还需要得到事实证明,因为C#和

其他生成MSIL的编译器还没有发布.但是Java

JIT编译器的普遍存在使得Java和C#在性能上相对相同.象"C#是编译语言而Java是解释性的,"之类的声明只是商业技巧.Java的中间代码和

MSIL都是中间的汇编形式的语言,它们在运行时或其它的时候被编译成机器代码.

命名空间中的申明:当你创建一个程序的时候,你在一个命名空间里创建了一个或多个类.同在这个命名空间里(在类的外面)你还有可能声明界面,枚举类型和结构体.必须使用using关键字来引用其他命名空间的内容.

基本的数据类型:C#拥有比C,C++或者Java更广泛的数据类型.这些类型是bool, byte, ubyte,

short, ushort, int, uint, long, ulong, float,

double,和decimal.象Java一样,所有这些类型都有一个固定的大小.又象C和C++一样,每个数据类型都有有符号和无符号两种类型.与

Java相同的是,一个字符变量包含的是一个16位的Unicode字符.C#新的数据类型是decimal数据类型,对于货币数据,它能存放28位10

进制数字.

两个基本类:一个名叫object的类是所有其他类的基类.而一个名叫string的类也象object一样是这个语言的一部分.作为语言的一部分存在意味着编译器有可能使用它--无论何时你在程序中写入一句带引号的字符串,编译器会创建一个string对象来保存它.

参数传递:方法可以被声明接受可变数目的参数.缺省的参数传递方法是对基本数据类型进行值传递.ref关键字可以用来强迫一个变量通过引用传递,这使得一个变量可以接受一个返回值.out关键字也能声明引用传递过程,与ref不同的地方是,它指明这个参数并不需要初始值.

与COM

的集成:C#对Windows程序最大的卖点可能就是它与COM的无缝集成了,COM就是微软的Win32组件技术.实际上,最终有可能在任何.NET语

言里编写COM客户和服务器端.C#编写的类可以子类化一个以存在的COM组件;生成的类也能被作为一个COM组件使用,然后又能使用,比方说,

JScript语言子类化它从而得到第三个COM组件.这种现象的结果是导致了一个运行环境的产生,在这个环境里的组件是网络服务,可用用任何.NET语

言子类化.

索引下标:一个索引与属性除了不使用属性名来引用类成员而是用一个方括号中的数字来匿名引用(就象用数组下标一样)以外是相似的.

代理和反馈:一个代理对象包括了访问一个特定对象的特定方法所需的信息.只要把它当成一个聪明的方法指针就行了.代理对象可以被移动到另一个地方,然后可以

通过访问它来对已存在的方法进行类型安全的调用.一个反馈方法是代理的特例.event关键字用在将在事件发生的时候被当成代理调用的方法声明中.

4、C#中的委托是什么？事件是不是一种委托？

委托是一个可以对方法进行引用的类。与其他的类不同，委托类具有一个签名，并且它只能对与其签名匹配的方法进行引用。这样，委托就等效于一个类型安全函数指针或一个回调。事件是一种委托。

5、ADO.NET相对于ADO等主要有什么改进？

ADO以Recordset存储，而ADO.NET则以DataSet表示。Recordset看起来更像单表，如果让Recordset以多表的方式表示就必须在SQL中进行多表连接。反之，DataSet可以是多个表的集合。ADO

的运作是一种在线方式，这意味着不论是浏览或更新数据都必须是实时的。ADO.NET则使用离线方式，在访问数据的时候ADO.NET会利用XML制作数据的一份幅本，ADO.NET的数据库连接也只有在这段时间需要在线。

由于ADO使用COM技术，这就要求所使用的数据类型必须符合COM规范，而ADO.NET基于XML格式，数据类型更为丰富并且不需要再做COM编排导致的数据类型转换，从而提高了整体性能。

6、接口和抽象类有什么区别？你选择使用接口和抽象类的依据是什么？

接口是一个纯粹的抽象类，没有任何实际的东西，只是定义了一个框架，而抽象类里面可以有实际的一个方法，并不要求所有的方法都是抽象的。可以实现一个接口中的所有方法，也可以继承一个抽象的类，然后覆写其中的方法。接口一般只有方法，而没有数据成员或属性。抽象类有方法，也有数据成员或属性,一般情况下，优先考虑用接口，只有当可能要访问到数据成员或属性时，用抽象类。

7、谈谈final, finally, finalize的区别。

final 修饰符用于指定类不能扩展或者方法或属性不能重写。它将防止其他类通过重写重要的函数来更改该类的行为。带有

final 修饰符的方法可以由派生类中的方法来隐藏或重载。

finally 块用于清除在 try 块中分配的任何资源。控制总是传递给 finally 块，与 try 块的存在方式无关。

finalize允许 Object 在“垃圾回收”回收 Object 之前尝试释放资源并执行其他清理操作。

第三波

ASP.NET面试的题目1

ASP.NET面试的题目

1。请简要写出你对C#及ASP。NET的认识

2。怎么获得文件的当前路径（代码）

3。请使用ADO。NET 写出数据库连接开始事务处理，即数据库连接（代码）

4。在SQL语言中，如果要建立一个工资表包含职工号，姓名，职称。工资等字段。若要保证工资字段

的取值不低于800元，最合适的实现方法是：

A。在创建工资表时为”工资“字段建立缺省

B。在创建工资表时为”工资“字段建立检查约束

C。在工资表建立一个触发器

D。为工资表数据输入编写一个程序进行控制

5。没有关键码序列（Q。G。M。Z。A。N。B。P。X。H。Y。S。L。T。K。E）

采用二路归并排序法进行排序，请写出第二趟归并后的结果？

6。创建一个新文本文件并向其写入一个字符串（代码）

7。请使用正则表达式验证电子邮件地址的合法性（代码）

8。如何设定DATAGRID中模板列里下拉列表默然值，如何在编辑时，让其绑定另一个表的数据并自动讲当前值设为默认值

9。上机测试题目：用户管理中，用户验证，用户添加，用户删除功能，采用ACCESS数据库

（时间30分钟）

--------------------------------------------------------------------------------

第四波

asp.net面试题(2)

asp.net面试题(A)

1.new有几种用法

第一种:new Class();

第二种:覆盖方法

public new XXXX(){}

第三种:new 约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。

2.如何把一个array复制到arrayList里

foreach( object o in array )arrayList.Add(o);

3.datagrid.datasouse可以连接什么数据源 [dataset,datatable,dataview]

dataset,datatable,dataview , IList

4.概述反射和序列化

反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性

序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet

在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。

5.概述o/r mapping 的原理

利用反射，配置将类于数据库表映射

6.类成员有( )种可访问形式

可访问形式？不懂。

可访问性：public ,protected ,private,internal

7.用sealed修饰的类有什么特点

sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其他类的基类，则会发生编译时错误。

密封类不能同时为抽象类。

sealed

修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化。具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数成员的调用可以转换为非虚拟调用来处理。

8.列举ADO.NET中的五个主要对象，并简单描述

connection,command,dataReader,trans,dataset ...

9.执行下面代码后：

String strTemp ="abcdefg 某某某"；

Int i System.Text.Encoding.Default.GetBytes(strTemp).Length;

Int j = strTemp.Length;

问：i=(14 ) ；j=(11 )

i=(14 ) ；j=(11 ) 中文两个字节

10.C#中，string str = null 与 string str

=""，请尽量用文字说明区别。(要点：说明详细的内存空间分配)

string str ="" 分配空间

11.详述.NET里class和struct的异同！

class:放在 ? struct放在？

struct值传递

类与结构有很多相似之处：结构可以实现接口，并且可以具有与类相同的成员类型。然而，结构在几个重要方面不同于类：结构为值类型而不是引用类型，并且结构不支持继承。结构的值存储在“在堆栈上”或“内联”。细心的程序员有时可以通过聪明地使用结构来增强性能。

12.概述.NET里对 remoting 和 webservice 两项技术的理解和实际中的应用。

远程逻辑调用，remoing接口只能用在.net中

13.什么是code-behind技术

aspx and cs

14.概述三层结构体系

web/business/dataaccess

15.asp.net如何实现MVC模式，举例说明！

web/business/dataaccess

第五波

一.填空题

1.c#中的三元运算符是_____?

2.当整数a赋值给一个object对象时，整数a将会被_____?

3.类成员有_____种可访问形式？

4.public static const int A=1;这段代码有错误么？是什么？

5.float f=-123.567F;

int i=(int)f;

i的值现在是_____?

6.利用operator声明且仅声明了==，有什么错误么?

7.委托声明的关键字是______?

8.用sealed修饰的类有什么特点？

9.在Asp.net中所有的自定义用户控件都必须继承自________?

10.在.Net中所有可序列化的类都被标记为_____?

11.在.Net托管代码中我们不用担心内存漏洞，这是因为有了______?

12.下面的代码中有什么错误吗？_______

using System;

class A

{

public virtual void F(){

Console.WriteLine("A.F");

}

abstract class B:A

{

public abstract override void F();

}

13.当类T只声明了私有实例构造函数时，则在T的程序文本外部，______（可以 or 不可以）从T

派生出新的类，____（可以 or 不可以）直接创建T的任何实例。

14.下面这段代码有错误么？

switch (i){

case():

CaseZero();

break;

case 1:

CaseOne();

break;

case 2:

dufault;

CaseTwo();

break;

}

15.在.Net中，类System.Web.UI.Page 可以被继承么？

二.简答题

1.在c#中using和new这两个关键字有什么意义，请写出你所知道的意义？

2.在下面的例子里

using System;

class A

{

public A(){

PrintFields();

}

public virtual void PrintFields(){}

}

class B:A

{

int x=1;

int y;

public B(){

y=-1;

}

public override void PrintFields(){

Console.WriteLine("x={0},y={1}",x,y);

}

当使用new B()创建B的实例时，产生什么输出？

3.下面的例子中

using System;

class A

{

public static int X;

static A(){

X=B.Y+1;

}

class B

{

public static int Y=A.X+1;

static B(){}

static void Main(){

Console.WriteLine("X={0},Y={1}",A.X,B.Y);

}

产生的输出结果是什么？

4.谈谈类和结构的区别？

5.一个长度为10000的字符串，通过随机从a-z中抽取10000个字符组成。请用c＃语言编写主要程

序来实现。

6.对于这样的一个枚举类型：

enum Color:byte{

Red,

Green,

Blue,

Orange

}

试写一段程序显示出枚举类型中定义的所有符号名称以及它们对应的数值。

7.您了解设计模式么？请列出您所知道的设计模式的名称。

8.请在SQL Server中设计表来保存一个树状结构的组织结构图（假设结构图中只有名称这一项内容

需要保存），如果我想查询某一职位下的所有职位，用一个存储过程来实现，你有什么思路？

9.什么叫做SQL注入，如何防止？请举例说明。

10.下面这段代码输出什么？为什么？

int i=5;

int j=5;

if (Object.ReferenceEquals(i,j))

Console.WriteLine("Equal");

else

Console.WriteLine("Not Equal");

答案：

1 ?:

2 装箱

3 3种

4 const成员都是static所以应该去掉static

5 －123

6 要同时修改Equale和GetHash() ? 重载了"==" 就必须重载 "!="

7 delegate

8 不可被继承

9 System.Web.UI.UserControl

10 [serializable]

11 gC

12 abstract override 是不可以一起修饰

13 不可以，不可以

14 case():不行 default;

转贴请注明: http://www.pghome.net

15 可以

1 Using 引入一个名子空间，或在使用了一个对像后自动调用其IDespose，New 实例化一个对

像，或修饰一个方法，表此方法完全重写此方法，

2 X=1,Y=0

3 x=1,y=2

4 最大区别一个是引用类型，一个是值类型默认成员访问为public是另外一个区别

第五波：

C#.Net的常见面试试题

1.面向对象的思想主要包括什么？

2.什么是ASP.net中的用户控件？

3.什么叫应用程序域？什么是受管制的代码？什么是强类型系统？什么是装箱和拆箱？什么是重载？CTS、CLS和CLR分别作何解释？

4.列举一下你所了解的XML技术及其应用。

5.值类型和引用类型的区别？写出C#的样例代码。

6.ADO.net中常用的对象有哪些？分别描述一下。

7.如何理解委托？

8.C#中的接口和类有什么异同。

9.。net中读写数据库需要用到哪些类？他们的作用。

10.UDP连接和TCP连接的异同。

11.ASP.net的身份验证方式有哪些？分别是什么原理？

12.进程和线程分别怎么理解？

13.什么是code-Behind技术。

14.活动目录的作用。

15..net中读写XML的类都归属于哪些命名空间？

16.解释一下UDDI、WSDL的意义及其作用。

17.什么是SOAP,有哪些应用。

18.如何部署一个ASP.net页面。

19.如何理解.net中的垃圾回收机制。

20.常用的调用webservice方法有哪些？

第六波

C#基础概念二十五问

初学 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, intType);

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 中点的成员最好使用结构

using System;

using System.Collections.Generic;

using System.Text;

namespace Example16

{

interface IPoint

{

double X

{

get;

set;

}

double Y

{

get;

set;

}

double Z

{

get;

set;

}

//结构也可以从接口继承

struct Point: IPoint

{

private double x, y, z;

//结构也可以增加构造函数

public Point(double X, double Y, double Z)

{

this.x = X;

this.y = Y;

this.z = Z;

}

public double X

{

get { return x; }

set { x = value; }

}

public double Y

{

get { return x; }

set { x = value; }

}

public double Z

{

get { return x; }

set { x = value; }

}

//在此简化了点状Geometry的设计，实际产品中还包含Project（坐标变换）等复杂操作

class PointGeometry

{

private Point value;

public PointGeometry(double X, double Y, double Z)

{

value = new Point(X, Y, Z);

}

public PointGeometry(Point value)

{

//结构的赋值将分配新的内存

this.value = value;

}

public double X

{

get { return value.X; }

set { this.value.X = value; }

}

public double Y

{

get { return value.Y; }

set { this.value.Y = value; }

}

public double Z

{

get { return value.Z; }

set { this.value.Z = value; }

}

public static PointGeometry operator +(PointGeometry Left, PointGeometry Rigth)

{

return new PointGeometry(Left.X + Rigth.X, Left.Y + Rigth.Y, Left.Z + Rigth.Z);

}

public override string ToString()

{

return string.Format("X: {0}, Y: {1}, Z: {2}", value.X, value.Y, value.Z);

}

class Program

{

static void Main(string[] args)

{

Point tmpPoint = new Point(1, 2, 3);

PointGeometry tmpPG1 = new PointGeometry(tmpPoint);

PointGeometry tmpPG2 = new PointGeometry(tmpPoint);

tmpPG2.X = 4;

tmpPG2.Y = 5;

tmpPG2.Z = 6;

//由于结构是值类型，tmpPG1 和 tmpPG2 的坐标并不一样

Console.WriteLine(tmpPG1);

Console.WriteLine(tmpPG2);

//由于类是引用类型，对tmpPG1坐标修改后影响到了tmpPG3

PointGeometry tmpPG3 = 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# 中类取消了多继承的原因之一），这时在实现时最好使用显式的声明

示例：

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