c#面试题

公司这几天在为招聘C#程序员做准备,让我负责准备面试题目.我在网上搜索到一份很好的C#面试题目.

c#面试问题

1. 传入某个属性的set方法的隐含参数的名称是什么？
   value，它的类型和属性所声名的类型相同。
2. 如何在C#中实现继承？
   在类名后加上一个冒号，再加上基类的名称。
3. C#支持多重继承么？
   不支持。可以用接口来实现。
4. 被protected修饰的属性/方法在何处可以访问？
   在继承或间接继承与这个类的子类中可以访问。
5. 私有成员会被继承么？
   会，但是不能被访问。所以看上去他们似乎是不能被继承的，但实际上确实被继承了。
6. 请描述一下修饰符protected internal。 
   被protected internal修饰的属性/方法只能在它的在同一个程序集（Assembly）中的子类被访问。
7. C#提供一个默认的无参数构造函数，当我实现了另外一个有一个参数的构造函数时候，还想保留这个无参数的构造函数。这样我应该写几个构造函数？
   两个，一旦你实现了一个构造函数，C#就不会再提供默认的构造函数了，所以需要手动实现那个无参数构造函数。
8. C#中所有对象共同的基类是什么？
   System.Object.
9. 重载和覆写有什么区别？
   重载提供了对一个方法签名的不同参数调用的实现。覆写提供了子类中改变父类方法行为的实现。
10. 在方法定义中，virtual有什么含意？ 
    被virtual修饰的方法可以被子类覆写。
11. 能够将非静态的方法覆写成静态方法么？
    不能，覆写方法的签名必须与被覆写方法的签名保持一致，除了将virtual改为override。
12. 可以覆写私有的虚方法么？
    不可以，甚至子类中无法访问父类中的私有方法。
13. 能够阻止某一个类被其他类继承么？ 
    可以，使用关键字sealed。
14. 能够实现允许某个类被继承，但不允许其中的某个方法被覆写么？ 
    可以，标记这个类为public，并标记这个方法为sealed。
15. 什么是抽象类（abstract class）？
    一种不可以被实例化的类。抽象类中一般含有抽象方法，当然也可有具体实现。继承类只有实现过所有抽象类的抽象方法后才能被实例化。
16. 何时必须声明一个类为抽象类？ 
    当这个类中包含抽象方法时，或是该类并没有完全实现父类的抽象方法时。
17. 接口（interface）是什么？
    只含有共有抽象方法（public abstract method）的类。这些方法必须在子类中被实现。
18. 为什么不能指定接口中方法的修饰符？ 
    接口中的方法用来定义对象之间通信的契约，指定接口中的方法为私有或保护没有意义。他们默认为公有方法。
19. 可以继承多个接口么？ 
    当然。
20. 那么如果这些接口中有重复的方法名称呢？ 
    这种情况中你可以决定如何实现。当然需要特别得小心。但是在编译环节是没有问题的。
21. 接口和抽象类的区别是什么？ 
    接口中所有方法必须是抽象的，并且不能指定方法的访问修饰符。抽象类中可以有方法的实现，也可以指定方法的访问修饰符。
22. 如何区别重载方法？ 
    不同的参数类型，不同的参数个数，不同的参数顺序。
23. const和readonly有什么区别？
    const关键字用来声明编译时常量，readonly用来声明运行时常量。
24. System.String 和System.StringBuilder有什么区别？
    System.String是不可变的字符串。System.StringBuilder存放了一个可变的字符串，并提供一些对这个字符串修改的方法。 
    

.NET方向高级开发人员面试时应该事先考虑的问题

（澄清一下，我发帖的目的不是用来专门给人评价这些问题的好坏的，实际上我所在的公司就考察这些问题。而能够基本上答出来的可以说百里挑一。如果各位觉得这些问题很简单，那么基本上在.NET面试环节就没有什么问题了，同时欢迎提供一些更多的问题。如果还有些不知道，那么不妨静下心来思考一下（或者用15秒搜索一下），没有必要花太多时间来攻击题目的合理性。毕竟，几乎所有的面试都是这样。如果没法改变，我们还是学着适应吧。）

如果你的简历上面说“精通.NET”，那么下面的问题应该大都可以给出较完美的答案。我会稍后给出一些我的想法，还请各位不吝指正并参与讨论。也欢迎提供给我更多的问题。
这里还有一些基础问题：http://www.cnblogs.com/dflying/archive/2006/04/01/364458.html 

注：对于每个判断是非问题，都要考虑“为什么”与“为什么不”。

1. Thread和Process之间有什么区别？.NET新引入了Application Domain的概念，这样他们三个之间有什么区别？引入了Application Domain会带来一些潜在的问题么？
2. Windows Service与普通的EXE在执行过程中有什么区别？
3. 一个进程可以访问的Windows地址空间有多大？等于系统的虚拟内存大小么？这两方面将对系统的设计产生什么样的影响？
4. EXE和DLL之间的区别是什么？在系统设计中应该如何选择使用它们？
5. 普通的EXE与.NET EXE的执行过程有什么不同？
6. 什么是弱类型，什么是强类型？在系统设计中应该首先考虑使用哪种类型？
7. PDB文件是作什么用的？里面包含了什么信息？
8. Cycloramic Complexity是什么？为什么它很重要？
9. 为创建一个critical section以访问某个变量书写一个标准的lock() 并加上double check。
10. 为某个对象实现标准的Dispose模式。
11. 什么是FullTrust? 存在于GAC中的 assembly 拥有FullTrust么？
12. 下面这个命令是做什么的？gacutil /l | find /i “system”
13. 下面这个命令是作什么的？ sn -t something.dll
14. 跨防火墙的 DCOM必须打开哪个端口？端口135是用来做什么的？
15. 有什么办法可以与现有unmanaged code集成？在集成的时候应该考虑什么问题？
16. 简要解释一下OOP与SOA都是用来作什么的？
17. XmlSerializer是如何工作的？进程运行XmlSerializer时候需要什么样的ACL权限？
18. 在系统设计时，何时应该使用try catch？何时需要避免使用？
19. Debug.Write()和Trace.Write()之间有什么区别？二者分别应该用于何处？
20. Debug Build和Release Build有什么区别？在执行效率上有什么明显的区别么？
21. JIT是针对Assembly还是Method发生的？解释一下为什么.NET的设计者要这样做？
22. 简要描述一下GC的执行过程。
23. 应该如何选择使用abstract class还是interface？
24. 在设计一个自定义类型时应如何选择使用Value Type还是Reference Type？
25. 对于Value Type和Reference Type，a.Equals(b)的默认实现方式有什么不同？
26. .NET中为什么不提供默认的deep copy？如果需要，要如何实现deep copy？
27. 相对于.NET 1.1，.NET2.0为了避免过度的boxing/unboxing造成的系统开销提供了哪些支持？
28. String是Value Type还是Reference Type？为什么.NET中的String对象被设置成immutable？

 

C#基本问题列表——面试通常题 (转)

1、String str=new String("a")和String str = "a"有什么区别？

String str = "a"; 这个只是一个引用，内存中如果有“a"的话，str就指向它，如果没有才创建如果你以后还用到"a"这个字符串的话并且是这样用： String str1 = "a"; String str2 = "a"; String str2 = "a"; 这4个变量都共享一个字符串"a" 而String str = new String("a");是根据"a"这个String对象再次构造一个String对象，将新构造出来的String对象的引用赋给str

2、判断字符串变量str是否为空的一下三种方法哪个性能更优：a、str=="";b、str==String.Empty;c、str.Length==0;？

答案是c；原因我就不说了。

3、string与String的区别

string、int是C#定义的类型，而String、Int32是.net类型即是CTS类型； 
string 是 .NET 框架中 System.String 的别名。 
string在编译的时候会转化为String类

4、虚方法（virtual ）和抽象方法（abstract）的区别？

之一：抽象方法仅有声明，而没有任何实现，如abstract someMethod();，虚方法却不能如此
之二：子类继承父类，可以对父类中的虚方法进行重写、覆盖、不处理三种处理（见5），对抽象方法却必须实现

5、子类对父类中虚方法的处理有重写（override）和覆盖（new），请说明它们的区别？

有父类ParentClass和子类ChildClass、以及父类的虚方法VirtualMethod。有如下程序段：
ParentClass pc = new ChildClass();
pc.VirtualMethod(...);
如果子类是重写（override）父类的VirtualMethod，则上面的第二行语句将调用子类的该方法
如果子类是覆盖（new）父类的VirtualMethod，则上面的第二行语句将调用父类的该方法

6、抽象类（abstract）和接口（interface）的区别

抽象类可以有自己的实现，接口却仅有声明，可以有自己的静态数据字段；
java和C#中可以实现多个接口，却只能继承一个抽象类（或者非抽象类）（单继承，和c++的多继承不同）；

使用 Override 和 New 关键字控制版本

C# 语言经过专门设计，以便不同库中的基类与派生类之间的版本控制可以不断向前发展，同时保持向后兼容。这具有多方面的意义。例如，这意味着在基类中引入与派生类中的某个成员具有相同名称的新成员在 C# 中是完全支持的，不会导致意外行为。它还意味着类必须显式声明某方法是要重写一个继承方法，还是一个仅隐藏具有类似名称的继承方法的新方法。

C# 允许派生类包含与基类方法名称相同的方法。

• 基类方法必须定义为 virtual。

• 如果派生类中的方法前面没有 new 或 override 关键字，则编译器将发出警告，该方法将有如存在 new 关键字一样执行操作。

• 如果派生类中的方法前面带有 new 关键字，则该方法被定义为独立于基类中的方法。

• 如果派生类中的方法前面带有 override 关键字，则派生类的对象将调用该方法，而不调用基类方法。

• 可以从派生类中使用 base 关键字调用基类方法。

• override、virtual 和 new 关键字还可以用于属性、索引器和事件中。

默认情况下，C# 方法不是虚方法 -- 如果将一种方法声明为虚方法，则继承该方法的任何类都可以实现其自己的版本。若要使方法成为虚方法，必须在基类的方法声明中使用 virtual 修饰符。然后，派生类可以使用 override 关键字重写基虚方法，或使用 new 关键字隐藏基类中的虚方法。如果 override 关键字和 new 关键字均未指定，编译器将发出警告，并且派生类中的方法将隐藏基类中的方法。

 

设计模式概述

设计模式从本质上说是一种规则，从形式上说，分为创建型、结构型、行为型。

　　设计模式的应用是为了实现软件设计中的几个原则，其中一个重要原则是：减少模块之间的耦合程度。为了确保这个目的，在设计一个类时，要针对接口，而非实现。（Programming to an Interface, not an Implementation）设计的时候只关心类的接口，编程的时候可以先实现一个简单的接口，供别的模块调用。使用一个类的时候只对接口工作，不关心具体的实现，也不关心具体的类型。这样也符合人类认识世界的规律，一般说来人们总是先了解一个事情的大概情况，比如，我们先了解一台电视机的大概功能，然后才能了解每个功能具体是怎样实现的。

　　开始的时候不提供实现，正是为了以后能够最大限度的实现。

　　设计模式不受语言的限制，使用.net或者java更容易实现。

　　工厂模式（Factory）

　　工厂模式属于一种创建型模式（Creational）。同样属于创建型模式的还有单件模式（Singleton），以后有机会再说。

　　    工厂模式的要点：

    1：存在一个创建对象的工厂；

    2：调用者从工厂中取得某些对象；

    3：由工厂决定如何创建对象；

    4：客户不知道对象是如何生成的。

　　举一个例子，下面的类视图：

　　Namer对象是FirstFirst和LastFirst的基类，用户调用Namer类的时候，不直接new出Namer类或者他的子类，而是使用NameFactory的getName方法得到具体的对象。这样在用户就不用关心自己正在使用的是哪一个Namer，正在调用哪一个方法。用户只针对Namer进行工作，而不用关心具体的类型。在实际工程中可以将Namer类的子类的构造函数只对NameFactory开放，进一步限制程序员。

　　C＃代码如下：

　　1：Namer的实现

using System; 　 namespace NameFactory {     ///     /// Summary description for Namer.     ///     //Base class for getting split names     public class Namer {                 //parts stored here         protected string frName, lName;   　         //return first name         public string getFrname(){               return frName;         }         //return last name         public string getLname() {               return lName;         }     } }

　

　　2：FirstFirst类的实现

using System; namespace NameFactory {     ///     /// Summary description for FirstFirst.     ///     publicclass FirstFirst : Namer           {         public FirstFirst(string name)         {             int i = name.IndexOf (" ");             if(i > 0) {                 frName = name.Substring (0, i).Trim ();                 lName = name.Substring (i + 1).Trim ();             }             else {                 lName = name;                 frName = "";             }         }     } }

　

　　3：LastFirst类的实现

using System; namespace NameFactory {     ///     /// Summary description for LastFirst.     ///     publicclass LastFirst : Namer           {         public LastFirst(string name) {             int i = name.IndexOf (",");             if(i > 0) {                 lName = name.Substring (0, i);                 frName = name.Substring (i + 1).Trim ();             }             else {                 lName = name;                 frName = "";             }         }     } }

　

　　4：NameFactory，工厂的实现

using System; namespace NameFactory {     ///     /// Summary description for NameFactory.     ///     public class NameFactory {               public NameFactory() {}         public Namer getName(string name) {             int i = name.IndexOf (",");             if(i > 0)                 return new LastFirst (name);             else                 return new FirstFirst (name);           }     } }

　

　　5：调用者，一个窗体，如图：

　　按钮的响应事件代码如下：

Namer nm = nameFact.getName (txName.Text );     txFirst.Text = nm.getFrname ();     txLast.Text = nm.getLname (); } private void btCompute_Click(object sender, System.EventArgs e) {

　

　　程序并不复杂，运行不运行无所谓，关键是要搞清楚Factory所起的作用：他隐藏了Namer类的创建细节，调用者始终不知道他创建的是哪一个类，也不需要关心他调用的方法是哪一个子类的。如果以后的程序的需求发生改动，比如：某国的人不仅有First Name和Last Name，还有Mid Name，就可以很方便的进行扩充，添加一个Namer的子类，修改一下Factory。调用者甚至不知道有新加了一种Namer的类型。

　

　　实际的应用

　

　　举一个简单的例子：工程中需要使用多种数据库，Oracle、SQL Server、Sybase，为这些数据库建立了各自的连接和查询操作的类，这些类有一个共同的基类BaseConn。可以建立一个ConnFactory类，用于根据不同情况产生具体的类。调用者不必关心自己调用的是谁。大大简化了业务代码。

　

　　实际的使用例子还有很多。

 

 

　　单件模式（Singleton）

　　是一个非常简单的模式，这是我第一个理解并且能运用的模式。有时候模式的复杂程度并不在于本身，而是由于他的应用目的。最初的时候面对一个模式经常充满了困惑，一个简单的调用为什么要搞的如此复杂？为什么要建立这么多类，只是为了打开一个文件。

　　通常说来学习一个模式是一个接受、认可、领会的过程。接受：了解模式的结构，了解实例的意义；认可：认可该模式在实际工程中的作用和可行性；领会：将模式应用到开发过程中。

　　而模式的应用目的说到底无非是为了降低模块之间在时间和空间上的耦合程度，以此提高模块的复用性，降低出错的概率。

　　单件模式

　　Singleton模式是一个较为简单的模式，下面的代码就可以建立一个Singlton模式的例子，这是一个写系统日志的类。

{     //申明一个静态的变量，类型为类本身     private static LogWriter _instance = null;   　     //将类的构造函数私有化，使得这个类不可以被外界创建     privateLogWriter()       {     } 　     //提供静态的方法，创建类的实例     public static LogWriter GetInstance()       {         if (_instance == null)         {             _instance = new LogWriter();         }         return _instance;     } 　    //下面实现类的其他功能     //....     } public class LogWriter

　　调用者不可以通过new的形式得到Singleton的实例，调用的例子如下：

LogWriter log = LogWriter.GetInstance(); log.Debug("hello world");

　　实际应用

　　很容易想象，单件模式适用于下面的情况：整个系统中某个对象是唯一的，或者是有固定数量的。比如数据库连接，配置文件，等等……

　　模式是一种程序员间的约定术语，语言可以成为思维的基础。有了这样的语言，一些复杂的概念就变得容易交流了。比如设计人员只要说到，某个类是一个单件模式，是一个Singleton，程序员听见以后就至少应该明白这个类的调用方式了，而不用再详细的说明。