.Net面試4套

一

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

答: 继承，多态，封装，类，对象，接口，聚集，聚合，泛化

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

答: 用户控件就是使用.ascx作为扩展名的文件，其将多种服务器端控件组合在一起，作为一个单独的控件服务于页面。这种用户控件存在的问题如，将其拖到不同级别的目录下后里面的图片等的相对路径会变得不准确。需要自已写方法调整。

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

答: 应用程序域就是.NET应用程序所运行的环境，一个应用程序域可能运行一个或多个应用程序装，这解除了传统Windows中一个应用依赖一个进程的缺点，大大提高了系统资源的利用率。两个应用程序域之间实现了隔离更好，保证了安全性。

托管代码即为运行于应用程序域（也可以说是CLR）中的代码。

强类型系统下，在声明一个对象时，必须指定一个类型，类型之间可以进行转换。当不确定一个类的类型是，可以将其指定为object型，即所有类型的父类型。

装箱就是把值类型转成引用类型，把一个值由堆栈转到托管堆中，反之为拆箱。

重载就是指一个方法名同,参数个数不同,返回值可以相同的方法.CLR是通用语言运行时,其它的不清楚.

CTS是通用类型系统，表示要在CLR上运行的语言所要符合的类型。CLS通用语言规范，表示要在CLR上运行的语言所要遵守的规范。CLR通用语言运行时，使用.net平台的语言编写的程序的运行环境。

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

答: Web Service，Xml+Xslt做网站，配置文件也多以xml格式出现。

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

答: 值类型存储于堆栈上，而引用类型存储于托管堆之上，需要注意的是引用类型的复制，通过"="赋值的方式复制只是复制了一个引用，要想完整的复制出另一个新对象，需要自己编写进行深拷贝的代码。在声明值类型的变量时，将自动给变量赋默认值，而引用类型默认被初始化为空(null)。可以由引用类型派生类，但是值类型不可以。C#预定义的引用类型有object，string。值类型有int,float等。

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

答: ADO.NET中的类分连接类与非连接类，非连接类包括DataSet，DataTable，DataView，DataRow，DataColumn等。连接类包括各类Connection，Command ，DataReader，DataAdapter等。

7. 如何理解委托？

答: 委托相当于为调用的方法定义了一种声明，包括参数要求与返回值要求。委托的主要作用就是允许将方法作为参数进行传递，这可用于定义回调方法等。委托可以链接在一起；例如，可以对一个事件调用多个方法。由于有协变和逆变，方法不需要与委托签名精确匹配。

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

答: 接口主要用来定义功能的契约，类主要用来定义一个实现。这个实现可以通过继承向子类传递。

9.net中读写数据库需要用到哪些类？它们的作用
答: 可以使用ADO.NET的链接类来完成这些功能。具体见第六题，其中Connection用来建立与数据库的链接，Commond用来传入数据库更新，查询等命令。DataReader用来单向读取数据，DataAdapter可以返回数据集。ExcuteScalar可以执行返回受影响的行数。DataParameter定义了参数。

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

答: TCP有个三次握手协议，而UDP没有这样的操作过程，所以TCP保证了数据传输的完整。

11. ASP.net的身份验证方式有哪些？分别是什么原理？
答: form认证,使用表单，需要用户输入用户名密码，然后传回数据库进行验证。

windows集成身份认证，这个往往.用于域环境中，通过Windows系统的令牌来实现验证。

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

答： 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

线程是进程的一个实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。

13.什么是code-Behind技术。
答: 代码分离，将Html描述的页面置于一个文件，然后将操作这些元素的C#代码写在一个后台代码文件中。类似于webform的winform也是采用了这种方式。

14. 活动目录的作用

答： 构建一个域环境。具体域环境可以用来部署SharePoint Server后者VFS等。

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

答: System.Xml，在.net 3.5中System.Xml.Linq也用来操作xml

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

答: 可以将Web服务注册到UDDI，这样可以通过查找UDDI来获得Web Service的列表。WSDL是Web服务描述语言，其描述了一个Web服务的详细信息，Vs就是通过这个来生成一个Web服务的本地代理。

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

答: SOAP（Simple Object Access Protocol ）简单对象访问协议是在分散或分布式的环境中交换信息并执行远程过程调用的协议，是一个基于XML的协议。使用SOAP，不用考虑任何特定的传输协议（最常用的还是HTTP协议），可以允许任何类型的对象或代码，在任何平台上，以任何一直语言相互通信。这种相互通信采用的是XML格式的消息。其主要用于Web服务的消息传输。

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

答： 放在iis的某个网站或者虚拟目录下。

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

答： 基本上.net垃圾回收工作原理是寻找不再使用的对象，将他们从内存中删除，并压缩托管堆以释放不再使用的对象所占用的内存。在堆被压缩之后，所有的对象引用都将被调整为指向对象新的存储位置。

20.常用的调用webservice方法有哪些？
答: 说一下目前比较常用的方法：使用jQuery这样的客户端框架。也可以使用ASP.NET(Ajax)中的Script Manager。

二

这一部分简单整理了一些我在网上遇到的面试题中不是很熟悉的部分，简单起见直接把答案列在题目后方。

1. 表征数据传输可靠性的指标是误码率。
2. 关于广义表的叙述中正确的是广义表是0个或多个单元素或子表组成的有限序列。
3. 二叉树的对称序遍历即指中序遍历。
4. 根据XML注释生成文档的编译选项是/doc
5. 判断字符串是否为空最快的方法是str.Lenght == 0

1 static void Main()
2 {
3     int i = 2000;
4     object o = i;
5     i = 2001;
6     int j = (int)o;
7     Console.WriteLine("i={0},o={1},j={2}", i, o, j);
8 }

请问此程序的输出是什么，为什么？

其输出结果如下：

i=2001,o=2000,j=2000

原因是，i为值类型，o为引用类型，当把i给o时，执行一个装箱操作，当把值2001赋给i时，i的值变为2001，此时o中存放的仍然是2000被装箱的对象，当把o赋给j后，执行一个拆箱操作，把包含2000的对象拆为值类型放入2000，即j的值为2000。

 1 class Class1
 2 {
 3     public static int Count = 0;
 4     static Class1()
 5     {
 6         Count++;
 7     }
 8     public Class1()
 9     {
10         Count++;
11     }
12     static void Main()
13     {
14         Class1 o1 = new Class1();
15         Class1 o2 = new Class1();
16         Console.WriteLine(Class1.Count);
17         Console.Read();
18     }
19 }

输出什么？

解答：添加如下程序语句（黑体表示）可以看到程序执行的过程：

 1 class Class1
 2 {
 3     public static int Count = 0;
 4     static Class1()
 5     {
 6         Count++;
 7         Console.WriteLine("静态构造函数！");
 8     }
 9     public Class1()
10     {
11         Count++;
12         Console.WriteLine("实例构造函数！");
13     }
14     static void Main()
15     {
16         Class1 o1 = new Class1();
17         Class1 o2 = new Class1();
18         Console.WriteLine(Class1.Count);
19         Console.Read();
20     }
21 }

注意：静态构造函数只会被执行一次。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用。

以下语句执行后myTable的名称是什么？

 System.Data.DataTable myTable = new System.Data.DataTable(); 

解答：使用如下语句显示一下myTable的TableName属性即可：

 Console.WriteLine(myTable.TableName);  

名称为空字符串，即""；

如下的IDimensions接口和Box类，该类显示实现接口成员Length和Width。myDimensions是IDimensions接口的一个实例。

 1 interface IDimensions
 2 {
 3     float Length();
 4     float Width();
 5 }
 6 
 7 class Box : IDimensions
 8 {
 9     float lengthInches;
10     float widthInches;
11     public Box(float length, float width)
12     {
13         lengthInches = length;
14         widthInches = width;
15     }
16 
17     float IDimensions.Length()
18     {
19         return lengthInches;
20     }
21 
22     float IDimensions.Width()
23     {
24         return widthInches;
25     }
26 
27     public static void Main()
28     {
29         Box myBox = new Box(30.0f, 20.0f);
30         IDimensions myDimensions = (IDimensions)myBox;
31         Console.WriteLine("Length: {0}", myBox.Length());
32         Console.WriteLine("Width: {0}", myBox.Width());
33     }
34 }

执行以上程序控制台输出为？

解答：这段程序不会通过编译，因为类实现接口时使用的显式实现，而显式实现的方法只能通过接口对象访问，无法通过类对象访问。隐式实现接口的方法既可以通过接口对象，也可以通过类对象访问。

所以可以改为这种方式

……

1 public static void Main()
2 {
3     Box myBox = new Box(30.0f, 20.0f);
4     IDimensions myDimensions = (IDimensions)myBox;
5     Console.WriteLine("Length: {0}", myDimensions.Length());
6     Console.WriteLine("Width: {0}", myDimensions.Width());
7 }

或者是改为隐式实现接口方法：

1 public float Length()
2 {
3     return lengthInches;
4 }
5 public float Width()
6 {
7     return widthInches;
8 }

1. 填空：（1）面向对象的语言具有继承性、封装性和多态性。

        （2）能用foreach遍历访问的对象需要实现IEnumerable接口的IEnumerator方法（这个方法的返回类型IEnumerator实现了foreach所需要的方法）

        （3）列举ADO.NET中的五个主要对象Command、Connection、DataSet、DataAdapter、DataReader。

2. 不定项选择：

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

A. 接口中可以有虚方法。                B. 一个类可以实现多个接口。

C. 接口不能被实例化。                D. 接口中可以包含已实现的方法。

以上正确的是：B,C

解释A项，因为接口的方法不能用修饰符修饰，所以A不正确。

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

A.ExecuteNonQuery        B.ExecuteScalar        C.Fill        D.ExcuteReader

以上正确的项是：C,D

说明：B项会返回受影响的行数，此项可选。

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

答：private: 私有，只限于在类（所声明于的对象）内部访问。

    protected: 保护，只限于在被声明于的类及其子类中被访问。

    public: 公共，无访问限制

    internal: 内部，在同一程序集内可以被访问。

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

两种写法如下所示：

1 SELECT TOP 10 * FROM TestTable
2 WHERE (ID NOT IN
3           (SELECT TOP 30 ID FROM TestTable ORDER BY ID))
4 ORDER BY ID
5 
6 SELECT TOP 10 * FROM T
7 WHERE ID >
8           (SELECT MAX(ID) FROM (SELECT TOP 30 ID FROM TestTable) AS T)

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

答： 基本上有如下4种方式，依次介绍：

(1) 使用QueryString：

方法都明白，说一下优缺点，优点：1.使用简单，对于安全性要求不高时传递数字或是文本值非常有效。缺点：1.缺乏安全性，由于它的值暴露在浏览器的URL地址中的。2.不能传递对象。难点问题：传递文字或者特殊字符时使用

(2) 使用Application变量，可以传递各类对象，但是有一个缺点就是作为全局变量容易被误操作。

(3) 使用Session。没有Application的缺点，但是大量应用Session可能会消耗服务器资源。

(4) 使用cookie对象，类似于Session针对单用户的特性，但cookie存储于客户端。读写方式可以概括为以下两句：

1 HttpCookie cookie_name = new HttpCookie("name");
2 cookie_name.Value = Label1.Text;
3 Reponse.AppendCookie(cookie_name);
4 Request.Cookie["name"].Value.ToString();

(5) 使用Server.Transfer在页面见传递参数

直接给出示例：首先在页面a.aspx的代码文件中编写如下代码：

 1 protected void Page_Load(object sender, EventArgs e)
 2 {
 3     Label1.Text = "待传递" + DateTime.Now.ToString();
 4 }
 5 
 6 public string Name
 7 {
 8     get { return Label1.Text; }
 9 }
10 
11 
12 protected void Button1_Click(object sender, EventArgs e)
13 {
14     Server.Transfer("b.aspx");
15 }

当然页面中首先需要添加如下两个Server Control

1 <asp:Button ID="Button1" runat="server" Text="Button" OnClick="Button1_Click" />
2 <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>

b页面的设计如下所示：

1 protected void Page_Load(object sender, EventArgs e)
2 {
3     a newWeb;   //实例a窗体
4     newWeb = (a)Context.Handler;
5     string name;
6     name = newWeb.Name;
7     Response.Write("这是页面b：" + name);
8 }

这样当点击按钮后，a将传递信息给b（或者说b可以有a获取信息）

主要参考：

http://www.cnblogs.com/changhai-xuri/archive/2008/09/26/1299647.html

http://blog.csdn.net/baoxuetianxia/archive/2009/05/22/4208404.aspx

6. 写出程序的输出结果

 1 public class Class1
 2 {
 3     private string str = "Class1.str";
 4     private int i = 0;
 5     static void StringConvert(string str)
 6     {
 7         str = "string being converted.";
 8     }
 9 
10     static void StringConvert(Class1 c)
11     {
12         c.str = "string being converted.";
13     }
14 
15     static void Add(int i) {
16         i++;
17     }
18 
19     static void AddWithRef(ref int i) {
20         i++;
21     }
22 
23     static void Main() {
24         int i1 = 10;
25         int i2 = 20;
26         string str = "str";
27         Class1 c = new Class1();
28         Add(i1);
29         AddWithRef(ref i2);
30         Add(c.i);
31         StringConvert(str);
32         StringConvert(c);
33         Console.WriteLine(i1);
34         Console.WriteLine(i2);
35         Console.WriteLine(c.i);
36         Console.WriteLine(str);
37         Console.WriteLine(c.str);
38     }
39 }

输出结果如下：

10

21

0

str

string being converted.

个人总结：主要考察值类型与应用类型在作为参数时的一些处理，以及string这种特殊的引用类型一些类似值类型的特性。

7. 写出程序的输出结果

 1 public abstract class A
 2 {
 3     public A()
 4     {
 5         Console.WriteLine('A');
 6     }
 7     public virtual void Fun()
 8     {
 9         Console.WriteLine("A.Fun()");
10     }
11 }
12 
13 public class B : A
14 {
15     public B()
16     {
17         Console.WriteLine('B');
18     }
19 
20     public new void Fun()
21     {
22         Console.WriteLine("B.Fun()");
23     }
24 
25     public static void Main()
26     {
27         A a = new B();
28         a.Fun();
29     }
30 }

输出结果为：

A

B

A.Fun()

说明：首先调用父类型的构造函数，然后调用派生类型的构造函数。

8. 写出程序的输出结果：

 1 public class A
 2 {
 3     public virtual void Fun1(int i)
 4     {
 5         Console.WriteLine(i);
 6     }
 7 
 8     public void Fun2(A a)
 9     {
10         a.Fun1(1);
11         Fun1(5);
12     }
13 }
14 
15 public class B : A
16 {
17     public override void Fun1(int i)
18     {
19         base.Fun1(i + 1);
20     }
21 
22     public static void Main()
23     {
24         B b = new B();
25         A a = new A();
26         a.Fun2(b);
27         b.Fun2(a);
28     }
29 }

输出结果：

2

5

1

6

9. 一列数的规则如下: 1、1、2、3、5、8、13、21、34......求第30位数是多少，用递归算法实现。（C#语言）

解答：

 1 public class MainClass
 2 {
 3     public static void Main()
 4     {
 5         Console.WriteLine(Foo(30));
 6         Console.Read();
 7     }
 8 
 9     public static int Foo(int i)
10     {
11         if (i <= 0)
12             return 0;
13         else if (i > 0 && i <= 2)
14             return 1;
15         else
16             return Foo(i - 1) + Foo(i - 2);
17     }
18 }

结果为：832040

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

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

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

解法1：

 1 public interface Observer
 2 {
 3     //观察者的响应，如是老鼠见到猫的反映
 4     void Response();
 5 }
 6 
 7 public interface Subject
 8 {
 9     //针对哪些观察者，这里指猫的要捕捉的对象 --- 老鼠
10     void AimAt(Observer obs);
11 }
12 
13 public class Mouse : Observer
14 {
15     private string name;
16     public Mouse(string name, Subject subj)
17     {
18         this.name = name;
19         subj.AimAt(this);
20     }
21 
22     public void Response()
23     {
24         Console.WriteLine(name + "attempt to escape!");
25     }
26 }
27 
28 public class Master : Observer
29 {
30     public Master(Subject subj)
31     {
32         subj.AimAt(this);
33     }
34 
35     public void Response()
36     {
37         Console.WriteLine("Host waken!");
38     }
39 }
40 
41 public class Cat : Subject
42 {
43     private ArrayList observers;
44 
45     public Cat()
46     {
47         this.observers = new ArrayList();
48     }
49 
50     public void AimAt(Observer obs)
51     {
52         this.observers.Add(obs);
53     }
54 
55     public void Cry()
56     {
57         Console.WriteLine("Cat cayed!");
58         foreach (Observer obs in this.observers)
59         {
60             obs.Response();
61         }
62     }
63 }
64 
65 class MainClass
66 {
67     static void Main(string[] args)
68     {
69         Cat cat = new Cat();
70         Mouse mouse1 = new Mouse("mouse1", cat);
71         Mouse mouse2 = new Mouse("mouse2", cat);
72         Master master = new Master(cat);
73         cat.Cry();
74 
75         Console.Read();
76     }
77 }

解法2：（使用event – delegate设计）

 1 public delegate void SubEventHandler();
 2 
 3 public abstract class Subject
 4 {
 5     public event SubEventHandler SubEvent;
 6     protected void FireAway()
 7     {
 8         if (this.SubEvent != null)
 9         {
10             this.SubEvent();
11         }
12     }
13 }
14 
15 public class Cat : Subject
16 {
17     public void Cry()
18     {
19         Console.WriteLine("cat cryed.");
20         this.FireAway();
21     }
22 }
23 
24 public abstract class Observer
25 {
26     public Observer(Subject sub)
27     {
28         sub.SubEvent += new SubEventHandler(Response);
29     }
30 
31     public abstract void Response();
32 }
33 
34 public class Mouse : Observer
35 {
36     private string name;
37     public Mouse(string name, Subject sub)
38         : base(sub)
39     {
40         this.name = name;
41     }
42 
43     public override void Response()
44     {
45         Console.WriteLine(name + " attempt to escape!");
46     }
47 }
48 
49 public class Master : Observer
50 {
51     public Master(Subject sub) : base(sub) { }
52     public override void Response()
53     {
54         Console.WriteLine("host waken");
55     }
56 }
57 
58 class Class1
59 {
60     static void Main(string[] args)
61     {
62         Cat cat = new Cat();
63         Mouse mouse1 = new Mouse("mouse1", cat);
64         Mouse mouse2 = new Mouse("mouse2", cat);
65         Master master = new Master(cat);
66         cat.Cry();
67 
68         Console.Read();
69     }
70 }

运行结果为：

cat cryed.

mouse1 attempt to escape!

mouse2 attempt to escape!

host waken

几个需要注意的地方：

1.    Mouse与Master需要得到一个抽象，即解法1中的接口与解法2中的抽象类。

三

1. ASP.NET中的身份验证有那些？你当前项目采用什么方式验证请解释。

答：有三种，分别是集成Windows身份验证，表单Forms验证以及Passport，Forms验证是最常用的一种。

2. 什么是WEB控件？使用WEB控件有那些优势？

答：实现了System.Web.UI.WebControls这个命名空间的一些类。包括像ASP.NET服务器端控件，用户控件及自定义控件等。使用控件提高了复用性，可以获得更好的开发效率。

3．请解释ASP.NET中以什么方式进行数据验证？

答：Aps.net中有非空验证(RequiredFieldValidator)，比较验证(CompareValidator)，取值范围验证(RangeValidator)，正则表达式验证(RegularExpressionValidator)及客户自定义验证(CustomValidator)五大控件，另还有一个集中验证信息处理控件(ValidationSummary)。

4．请谈谈对正则表达式的看法？

答：善用正则表达式可以高效的处理字符串。如查找匹配正则表达式的文本。

5．ASP.NET中共有几种类型的控件？各有什么区别？

答：按我理解，有普通HTML控件，HTML服务器控件（普通HTML控件加runat="server"标签），ASP.NET服务器控件，自定义控件，用户控件。

6．WEB控件可以激活服务端事件，请谈谈服务端事件是怎么发生并解释其原理？自动回传是什么？为什么要使用自动回传。

答：在web控件发生事件时，客户端采用提交的形式将数据交回服务端，服务端先调用Page_Load事件，然后根据传回的状态信息自动调用服务端事件。

自动传回是当我们在点击客户端的控件时，采用提交表单的形式将数据直接传回到务端。

只有通过自动传回才能实现服务端事件的机制，如果没有自动回传机制就只能调用客户端事件，而不能调用服务端事件。

7．WEB控件及HTML服务端控件能否调用客户端方法？如果能，请解释如何调用？

答：对于ASP.NET服务器端控件可以使用，ClientScriptManager的RegisterStartupScript等相关实例方法。这其中可以定义与客户端脚本交互的JavaScript。

8．ASP.NET与ASP相比有什么优势？

答：定义了一个WebForm模型，一定程度上提高了开发效率，另外编译执行的模式也提高了运行效率。

9．请解释web.config文件中的重要节点。

• appSettings包含自定义应用程序设置。
• connectionStrings：保存连接字符串（.Net2.0新增）
• system.web 系统配置
• compilation动态调试编译设置，如是否启用调适模式等。
• customErrors自定义错误信息设置
• authentication身份验证,此节设置应用程序的身份验证策略。
• authorization授权, 此节设置应用程序的授权策略。

10．请解释ASP.NET中的web页面与其隐藏类之间的关系？

答：（针对ASP.NET2.0+）一个ASP.NET页面一般都对应一个代码隐藏文件，一般都在ASP.NET页面的声明中指定了代码隐藏文件。例如一个页面a.aspx的页面声明如下：

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="a.aspx.cs" Inherits="a" %>

 CodeFile="a.aspx.cs"  表明此页面使用的代码隐藏文件

 Inherits="a"  表示此页面的类型的名称，这里使用了.NET2.0中的部分类这个新特性。

代码隐藏文件声明类的方式：

public partial class a : System.Web.UI.Page

11．什么是viewstate，能否禁用？是否所用控件都可以禁用?

答：Viewstate是用于在两次PostBack之间保存状态的一种机制，禁用ViewState将不能在回发之间保存状态，仅当控件状态无关且使用ViewState将造成性能问题时才禁用ViewState。将EnableViewState属性设置为false可禁用ViewState。

12．当发现不能读取页面上的输入的数据时很有可能是什么原因造成的？怎么解决？

一种可能是在Page_Load中数据处理时没有对Page的IsPostBack属性进行判断。

13．请解释一个WEB页面中代码执行次序。

答：

(1). 初始化对象，所有声明于aspx页面中的对象在此时被初始化，可以通过重载OnInit来自定义这个初始化过程。

(2). 导入Viewstate数据。在事件处理函数LoadViewState中执行了这个操作

(3). 处理页面实现的IPostBackDataHandler接口中LoadPostData函数，在其中处理了PostBack的数据。

(4). Load事件触发，OnLoad函数中，对象被实现为DOM，客户端可以开始处理DOM。

(5). LoadPostData函数中通过PostBack更新控件后，发生属性变化的控件将触发ReasePostBackChanged事件。这个事件是在所有的控件都被更新以及Load事件处理完毕后进行。（这样保证一个控件在被postback数据更新前，别的控件不会在RaisePostDataChanged事件中被更改。）

(6). 当RaisePostBackChanged事件的处理完毕后，产生PostBack数据的对象开始执行RaisePostBackEvent事件的处理函数。RaisePostBackEvent是在一个回发过程中最后发生的。

(7). 预先呈递对象，可以在这一步中对控件的属性、控件树结构等进行最后的修改。可以通过OnPreRender来重载这一过程。

(8). SaveViewState事件执行，在这一步中所有对控件的更改被保存到<input>这个客户端存储ViewState的地方。这一步以及以后的操作已经不能修改ViewState。SaveViewState事件的处理函数可以被重载以增加自定义的处理。

(9). Render事件将Html输出到浏览器。在这个事件处理中，可以自定义一个HtmlTextWriter并将其输出到客户端，来取代服务器的输出，但这只是对客户端的一种行为，服务器端并不受影响。

(10). 销毁对象，在这一步中所有已经呈递为Html的对象都应被销毁。有些销毁工作应该在Dispose事件（经重载）来完成。

14．请解释什么是上下文对象，在什么情况下要使用上下文对象？

答：上下文对象是指HttpContext类的Current 属性，当我们在一个普通类（一个不是继承自Page类的类）中要访问ASP.NET服务器对象(Response, Request, Session, Server, Appliction等)时就要使用此对象。

15．请解释转发与跳转的区别？

答：转发:HttpServerUtility.Transfer(); 对于当前请求，终止当前页的执行，并使用指向一个新页的指定URL路径来开始执行此新页。可以清除QueryString和Form集合。

跳转:HttpResponse.Redirect(); 将客户端重定向到新的URL并指定该新URL，默认不终止当前页的执行。

参考：http://www.cnblogs.com/jinweida/archive/2008/03/27/1126148.html

16．请解释ASP.NET中不同页面之间数据传递有那些方式？

(1) 使用QueryString：

(2) 使用Application变量，可以传递各类对象，但是有一个缺点就是作为全局变量容易被误操作。

(3) 使用Session。没有Application的缺点，但是大量应用Session可能会消耗服务器资源。

(4) 使用cookie对象，类似于Session针对单用户的特性，但cookie存储于客户端。

(5) 使用Server.Transfer在页面见传递参数。

17．请解释ASP.NET中button、linkbutton、imagebutton及hyperlink这四个控件之间的区别。

答：实现机制：用户单击控件时，HyperLink控件立即转向目标，表单不需回发到服务器端,而LinkButton需将表单发回给服务器，在服务器端处理页面跳转功能。

使用方法：HyperLink只需设置NavigateUrl就可以实现页面跳转。LinkButton控件实现页面跳转是在Click事件中使用Response.Redirect等方法实现的。

Button,LinkButton,ImageButton都属于服务器端的按钮类控件。它们的点击操作都会有一次PostBack。

18．请解释一下.NET多层应用程序中层与层之间以那几种方式进行数据传递。并解释你自己的项目中采用那种方式进行。

答：传统的传递DataSet，另外有传递实体类对象，这种对象包括普通只封装了数据的对象与封装了数据与状态对象这两种情况。还有可以传递用来获取对象的参数。

19．如果出现ASP.NET中的事件不能触发可能由于什么原因造成？

答：有可能由于页面声明中，AutoEventWireup没有被设置为true。

20．如果需要在datagride控件中的某一列中添加下拉列表框并绑定数据怎么解决？

答：（针对ASP.NET2.0以上版本）在GridView中添加一列TemplateFeild列，在其ItemTemplate模板中放入一个DropDownList控件。然后在Gridview的DataBinding方法中将数据绑定到下拉列表。

21．请解释asp.net中的数据绑定与传统数据绑定有什么区别？

答：注意看阿不同志这个系列的文章：http://www.cnblogs.com/hjf1223/archive/2008/05/03/digging_into_binding_expression_1.html

22．请解释.net采用委托实现的事件模型与JAVA中采用接口实现的事件模型有什么区别，以图示方式解释。

Java不了解，不进行比较了。

23．请解释接口的显式实现有什么意义？

答：显示实现是通过使用接口的完全限定名来实现接口成员的。如果类或者结构继承了多个接口，那么接口中相同名称成员就要显式实现。 

Q：您在什么情况下会用到虚方法？它与接口有什么不同？

A：虚方法是父类中为了让派生类可以覆写某一函数，而将此函数标记为虚函数。与接口没有什么关系。虚函数可以有自己的实现。（接口中的函数是不允许有实现的）

Q：Override与重载有什么区别？

A：Override是对父函数中虚函数的覆写，而重载是对一个函数的编写一个同名不同参的新实现，完全是函数之间的关系。

Q：值类型与引用类型有什么区别？

A: 值类型存储于栈上，引用类型存储于托管堆上，声明一个值类型的对象会初始化为一个默认值，而声明一个引用类型默认为null。值类型进行赋值时变量将会被拷贝一份，而引用类型赋值只是复制了一个到引用类型对象的引用。

Q：怎样理解静态变量？

A: 静态变量在类的多个实例之间共享。可以用来完成类的实例数统计等工作。

Q：向服务器发送请求有几种方式？

A：基本上比较常用的方式有GET，POST与HEAD这三种。

Q：DataReader与Dataset有什么区别？

A: Dataset是一套完整的内存中关系数据系统，而DataReader是一种实现单向的只读数据访问的类。

Q：如果在一个B/S结构的系统中需要传递变量值，但是又不能使用Session、Cookie、Application，您有几种方法进行处理？

A: 在不能使用上述方式的情况下，可以使用下列两种方法：

(1) 使用QueryString：

(2) 使用Server.Transfer在页面见传递参数。

Q：用.net做B/S结构的系统，您是用几层结构来开发，每一层之间的关系以及为什么要这样分层？

A: 较旧一些的分层方式，展现层，业务逻辑层，数据访问层。更新的方式，界面层（Ajax，只使用客户端控件及逻辑），服务Façade，业务逻辑，数据访问。

Q：软件开发过程一般有几个阶段？每个阶段的作用？

A: 需求分析，设计，编码，测试。

Q：微软推出了一系列的Application Block，请举出您所知道的Application Block并说明其作用？

A: Data Access数据访问用，Exception Handling异常处理，Unity Application Block依赖注入容器。

Q：请列举一些您用到过的设计模式以及在什么情况下使用该模式？

A: 单例模式，用于工具类。装饰模式，用于包装业务逻辑。抽象工厂模式，用于数据访问层的设计。

Q：您对WebService的体会？

A：传统的Web服务在安全性上存在不足，可以考虑使用WSE来弥补，或者使用WCF这种更优秀的技术。

Q：通过超链接怎样传递中文参数？

A: 可以将中文使用Server.Encode()来进行编码。

Q：请编程遍历页面上所有TextBox控件并给它赋值为string.Empty？

A：方法1：

1 for (int i = 0; i < this.Controls.Count; i++)
2 {
3     foreach (System.Web.UI.Control control in this.Controls[i].Controls)
4     {
5         if (control is TextBox)
6             (control as TextBox).Text = string.Empty;
7     }
8 }

方法2：

1 foreach (Control cl in this.Page.FindControl("FormName").Controls)
2 {
3     if (cl.GetType().ToString() == "System.Web.UI.WebControls.TextBox")
4     {
5         ((TextBox)cl).Text = string.Empty;
6     }
7 }

参考：http://www.cnitblog.com/ffan/archive/2005/07/30/1193.html

Q：请编程实现一个冒泡排序算法？

A：程序如下：

 1 public static void Main(String[] args)
 2 {
 3     int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5 };
 4 
 5     Sort(values);
 6     for (int i = 0; i < values.Length; ++i)
 7     {
 8         Console.WriteLine("Index: " + i + "Value: " + values[i]);
 9     }
10 }
11 
12 public static void Sort(int[] values)
13 {
14     int temp;
15 
16     for (int i = 0; i < values.Length; ++i)
17     {
18         for (int j = 0; j < values.Length - i - 1; ++j)
19         {
20             if (values[j] > values[j + 1])
21             {
22                 temp = values[j];
23                 values[j] = values[j + 1];
24                 values[j + 1] = temp;
25             }
26         }
27     }
28 }

四

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

答：Property用来封装类的成员，可以通过逻辑限制对成员的读写及可访问性。而Attribute是一种标记类，通过反射获取Attribute信息可以获得一个类的部分特性。

Q2. 讲一讲你理解的web service,在dot net framework中，怎么很好的结合xml?

答：Web Service通过SOAP协议（本质是XML数据）来传输信息，对比普通Web应用来看，发布信息都是需要Web Server。只是发布信息有所不同，普通Web应用发布的是Html/XHTML的数据。而Web Service发布的是Xml类型符合SOAP协议的数据。（当然WebService也可以使用JSON等来传输数据）

Q3. C#可否对内存进行直接的操作？

答：是可以的。可以使用C#中所谓的非安全代码，在这类代码中可以使用指针以操作内存。非安全代码需放置在unsafe块中。

Q4. 用Visual C++ 6.0编写的代码(unmanaged code)，如何在CLR下和其他.Net Component结合？

答：对于非托管程序集可以使用.NET中的互操作性的功能。从MSDN摘录了一个简要的步骤：

1.标识 DLL 中的函数。最低限度上，必须指定函数的名称和包含该函数的 DLL 的名称。

2.创建用于容纳 DLL 函数的类。可以使用现有类，为每一非托管函数创建单独的类，或者创建包含一组相关的非托管函数的一个类。

3.在托管代码中创建原型。[C#] 使用 DllImportAttribute 标识 DLL 和函数。用 static 和 extern 修饰符标记方法。

4.调用 DLL 函数。像处理其他任何托管方法一样调用托管类上的方法。传递结构和实现回调函数属于特殊情况。

Q5：维护数据库的完整性、一致性、你喜欢用触发器还是自写业务逻辑？为什么

答：自己写业务逻辑，可控性更高。同时性能也比触发器要好一些。

Q6：ADO.NET相对于ADO等主要有什么改进？

答：ADO.NET中实现了两套类，连接类与非连接类。非连接类实现了一套内存中的关系数据模型，将数据存于这样的dataset中可以减少访问数据库的次数。另外连接类应用了Provider模式，可以方便的连接到多少数据源。

Q7：ASP.NET与ASP相比，主要有哪些进步？

答：实现了一套WebForm框架，有完整的生命周期模型，使开发效率大大提高，而且编译执行的方式比ASP解释执行的效率大大提高。通过自定义控件的方式也实现了一种较高层次的复用。

Q8：C#中的委托是什么？事件是不是一种委托？

答：委托也是一种引用类型，其表示一种可以被调用的方法的签名的规范。委托的实例是表示到与其匹配的方法的引用。事件就是委托的一种。

Q9：描述一下C#中索引器的实现过程，是否只能根据数字进行索引？

答：MSDN中对索引器的说明：索引器允许类或结构的实例按照与数组相同的方式进行索引。索引器类似于属性，不同之处在于它们的访问器采用参数。 下面先看一个简单的索引器：

 1 class SampleCollection<T>
 2 {
 3     private T[] arr = new T[100];
 4     public T this[int i]
 5     {
 6         get
 7         {
 8             return arr[i];
 9         }
10         set
11         {
12             arr[i] = value;
13         }
14     }
15 }

索引器使用方式：

1 class Program
2 {
3     static void Main(string[] args)
4     {
5         SampleCollection<string> stringCollection = new SampleCollection<string>();
6         stringCollection[0] = "Hello, World";
7         System.Console.WriteLine(stringCollection[0]);
8     }
9 }

MSDN中对索引器设计的一些要求：

索引器概述

• 索引器使得对象可按照与数组相似的方法进行索引。
• get 访问器返回值。set 访问器分配值。
• this 关键字用于定义索引器。
• value 关键字用于定义由 set 索引器分配的值。
• 索引器不必根据整数值进行索引，由您决定如何定义特定的查找机制。
• 索引器可被重载。
• 索引器可以有多个形参，例如当访问二维数组时。

由上可以看出索引也可以字符串等其它类型。

最后给出一个较为复杂的索引器的例子。（摘自：http://www.cnblogs.com/jiang_jiajia10/archive/2009/03/13/1410798.html）

 1 class Program1
 2 {
 3     static void Main(string[] args)
 4     {
 5         ScoreIndex s = new ScoreIndex();
 6         s["张三", 1] = 90;
 7         s["张三", 2] = 100;
 8         s["张三", 3] = 80;
 9         s["李四", 1] = 60;
10         s["李四", 2] = 70;
11         s["李四", 3] = 50;
12         Console.WriteLine("张三课程编号为1的成绩为：" + s["张三", 1]);
13         Console.WriteLine("张三的所有成绩为：");
14         ArrayList temp;
15         temp = s["张三"];
16         foreach (IndexClass b in temp)
17         {
18             Console.WriteLine("姓名：" + b.Name + "课程编号：" + b.CourseID + "分数：" + b.Score);
19         }
20         Console.ReadKey();
21     }
22 }
23 
24 class IndexClass
25 {
26     private string _name;
27     private int _courseid;
28     private int _score;
29     public IndexClass(string _name, int _courseid, int _score)
30     {
31         this._name = _name;
32         this._courseid = _courseid;
33         this._score = _score;
34     }
35     public string Name
36     {
37         get { return _name; }
38         set { this._name = value; }
39     }
40     public int CourseID
41     {
42         get { return _courseid; }
43         set { this._courseid = value; }
44     }
45     public int Score
46     {
47         get { return _score; }
48         set { this._score = value; }
49     }
50 }
51 
52 class ScoreIndex
53 {
54     private ArrayList arr;
55     public ScoreIndex()
56     {
57         arr = new ArrayList();
58     }
59     public int this[string _name, int _courseid]
60     {
61         get
62         {
63             foreach (IndexClass a in arr)
64             {
65                 if (a.Name == _name && a.CourseID == _courseid)
66                 {
67                     return a.Score;
68                 }
69             }
70             return -1;
71         }
72         set
73         {
74             arr.Add(new IndexClass(_name, _courseid, value)); //arr["张三",1]=90
75         }
76     }
77     //重载索引器
78     public ArrayList this[string _name]
79     {
80         get
81         {
82             ArrayList temp = new ArrayList();
83             foreach (IndexClass b in arr)
84             {
85                 if (b.Name == _name)
86                 {
87                     temp.Add(b);
88                 }
89             }
90             return temp;
91         }
92     }
93 }

Q10：C#中要使一个类支持foreach遍历，实现过程怎样？

答：这个问题参见我的这篇随笔：http://www.cnblogs.com/lsxqw2004/archive/2009/10/15/1583829.html

总结一句话：实现IEnumerable接口的GetEnumerator方法（此方法返回个实现IEnumerator接口的对象），这个方法返回的对象是迭代器的重点。

Q11：写一个HTML页面，实现以下功能，左键点击页面时显示"您好"，右键点击时显示"禁止右键"。并在2分钟后自动关闭页面。

答：

JavaScript写法：

 1 <body onload="init()">
 2 
 3     <script type="text/javascript">
 4         function init() {
 5             document.onclick = showalert;
 6             document.oncontextmenu = new Function("event.returnValue=false");
 7             window.setTimeout(function() { window.close(); }, 2 * 60 * 1000);
 8         }
 9 
10         function showalert() {
11             alert("您好");
12         }       
13     </script>
14 
15     <form id="form1" runat="server">
16     </form>
17 </body>

Q12： 简单描述XMLHTTP、WebService的特点、作用。

XmlHttp是一种置于浏览器内的组件，其为浏览器与服务器间进行异步调用来服务。

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

答：接口不可以包括成员及函数实现，抽象类可以，接口可以多继承，抽象类不可以。

接口主要定义一个协定。实现接口的类或结构必须遵守其协定。抽象类应主要用于关系密切的对象，如果要设计大的功能单元，则使用抽象类。

Q14：自定义控件和一般用户控件的异同？如果要用这两者之一，你会选择哪种？为什么

答：自定义控件一般就是将现有的服务器控件整合在一个扩展名为.ascx文件中，其作用是使一组服务器控件的复用性增高。而用户空间就是完全创建一个新的服务器控件，我们可以最大化的实现我们想要的功能，可以像现有服务器控件一样放入工具箱中。

Q15：大概描述一下ASP.NET服务器控件的生命周期。

答：

• 实例化(Instantiate)：

  控件被页面或另一个控件通过调用它的构造器所实例化。这个步骤之后所列出的阶段，仅当控件加入控件树中才会发生。

• 初始化(Initialize)：

  初始化在传入 Web 请求生命周期内所需的设置。在此阶段，控件树中的页面和全部控件通过默认方式来调用OnInit方法。开发人员可以通过重载OnInit方法，为控件提供初始化逻辑。在其生命周期的这个时候，控件能够安全地访问其置于Controls集合中的子控件，但是它不能访问控件层次中的父控件或其他层次更高的控件（如页面）

• 开始跟踪视图状态(Begin Tracking View State)：

  这个阶段发生在初始化阶段的末尾。在此阶段页面自动调用TrackViewState方法。TrackViewState方法保证在此阶段之后，使用ViewState字典属性而产生的变化保存在控件视图状态中。在大多数情况下，Control基类提供的TrackViewState方法实现已经足够了，只有在控件定义了复杂属性时，才必须重载TrackViewState方法。

• 加载视图状态（仅用于回传过程）(Load View State (postback only))：

  这个阶段发生在回传时，而不是初始请求过程中，在此阶段结束时，就会自动填充控件的 ViewState 属性。控件可以重写 LoadViewState 方法的默认实现，以自定义状态还原。

• 加载回传数据（仅用于回传过程，为可选项）(Load Postback Data(postback only, optional))：

  只有在控件通过实现IPostBackDataHandler接口参与了回传数据处理时，这个阶段才发生在回传中。TextBox控件就是一个例子。在这个阶段中，控件必须从已发送的表单数据中，通过实现IPostBackDataHandler接口的LoadPostData方法更新其状态。

• 加载(Load)：

  直到此阶段开始，控件树中的所有控件都已被初始化，并恢复到它们在先前周期最后的状态。OnLoad方法会执行所有请求共有的操作，如设置数据库查询。此时，树中的服务器控件已创建并初始化、状态已还原并且窗体控件反映了客户端的数据。如果需要实现仅在页面初始请求中执行的逻辑，那么实现该逻辑时，应该检查页面的IsPostBack属性

• 引发修改事件（仅用于回传过程，为可选项）(Raise Changed Events(postback only, optional))：

  只有在控件通过实现IPostBackDataHandler接口参与了回传数据处理时，这个阶段才发生在回传中。在此阶段中，控件通过引发事件（如TextBox的TextChanged事件）作为一种信号-----其状态由于回传而改变（引发更改事件以响应当前和以前回发之间的状态更改）。为了参与此阶段，控件必须实现IPostBackDataHandler接口的RaisePostDataChangedEvent方法。

• 引发回传事件（仅用于回传过程，为可选项）(Raise Postback Events(postback only, optional))：

  只有在控件通过实现IPostBackEventHandler接口参与了回传数据处理时，这个阶段才发生在回传中。在此阶段可以通过实现IPostBackEventHandler接口的RaisePostBackEvent方法来实现逻辑，以便把客户端事件映射到服务器端事件。

• 预生成(PreRender)：

  在此阶段中，应该通过重载OnPreRender方法，执行在生成控件之前所需要的任何工作。在生成输出之前执行任何更新，可以保存在预生成阶段对控件状态所做的更改，而在生成阶段所对应的更改则会丢失。

• 保存视图状态(Save View State)：

  如果控件不维持状态，或者它为保存其所有状态信息而使用ViewState字典，那么不必在此阶段期间实现任何附加逻辑。在此阶段期间，页面框架会自动保存ViewState字典。如果需要自定义状态管理，必须通过重载SaveViewState方法来实现自定义状态恢复，这种方法只被EnableViewState属性为true的控件所调用。在此阶段以后任何控件的改变都不会保存在控件的视图状态中。

• 生成(Render)：

  通过这种方法，控件在输出流上通过重载Control的Render方法或WebControl类的rendering方法中的一种，来写标记文本。

• 卸载(Unload)：

  在此阶段中，页面通过实现Page_Unload方法，来执行清除工作。作为控件开发者，应该重载Dispose方法来执行清除。

  （摘自：http://blog.csdn.net/grgufo/archive/2008/02/20/2110123.aspx）

一.填空题

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

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

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

分普通成员/方法还有静态成员/方法：

普通成员/方法 类内部：this.Member/this.Method() 类外部：obj.Member/obj.Method()

静态成员/方法 类内部：Member/Method() 类外部：ClassName.Member/ ClassName.Method()

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

5.float f=-123.567F;

int i=(int)f;

i的值现在是_123_?

（说明：无论正负，无论小数部分是否大于.5，都是把小数部分砍掉而不考虑什么四舍五入。）

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

重载==需要同时重载!=。（个人想法）

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

8.用sealed修饰的类有什么特点？表示密封类，不能继承

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

自定义ASP.NET服务器控件派生自System.Web.UI.WebControls.WebControl类；

Web用户控件派生自System.Web.UI.UserControl类。

10.在.Net中所有可序列化的类都被标记为_[Serializable]_?

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

CLR中的自动垃圾回收机制

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

 1 class A
 2 {
 3     public virtual void F()
 4     {
 5         Console.WriteLine("A.F");
 6     }
 7 }
 8 abstract class B : A
 9 {
10     public abstract override void F();
11     //new public abstract void F();
12 }

按编译看没有什么错误。。。

13.当类T只声明了私有实例构造函数时，则在T的程序文本外部，__不可以__（可以 or 不可以）从T派生出新的类， 不可以__（可以 or 不可以）直接创建T的任何实例。

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

 1 int i = 0;
 2 switch (i)
 3 {
 4     case 0:
 5         CaseZero();
 6         break;
 7     case 1:
 8         CaseOne();
 9         break;
10     case 2:
11         dufault;  //wrong –> dufault: //right
12         CaseTwo();
13         break;
14 }

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

可以（所有WebForm中创建的页面都是源自这个类）

二.简答题

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

using：引用命名空间

using：实现将代码包装在一个try{}catch{}finally{}块中。

new：创建对象新实例

new：隐藏基类中方法。

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

最重要的区别：类是引用类型、结构是值类型。

使用选择上：较复杂的逻辑放在类中，有大量的成员对象放在结构中。

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

 1 static void Main()
 2 {
 3     Random r = new Random();
 4     StringBuilder sb = new StringBuilder();
 5     int index = (int)'a';
 6     for (int i = 0; i < 10000; i++)
 7     {
 8         int m = r.Next(26) + index;
 9         sb.Append(Convert.ToChar(m).ToString());
10     }
11     sb.ToString();
12 }

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

1 enum Color : byte
2 {
3     Red,
4     Green,
5     Blue,
6     Orange
7 }

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

解答：

1 string[] ss = Enum.GetNames(typeof(Color));
2 byte[] bb = (byte[])Enum.GetValues(typeof(Color));
3 
4 for (int i = 0; i < ss.Length; i++)
5 {
6     Console.WriteLine("value:{0}; text:{1}", bb[i], ss[i]);
7 }

5.请在SQL Server中设计表来保存一个树状结构的组织结构图（假设结构图中只有名称这一项内容需要保存），如果我想查询某一职位下的所有职位，用一个存储过程来实现，你有什么思路？

答：深入起来这是一个复杂的问题，可以参考这篇文章：

http://hi.baidu.com/genet/blog/item/fbc5ba0acf73b33bb1351d91.html

一般应用中我们可以采取如下简单的方式：

数据表设计：

（查询语句：

1 SELECT ID, ParentID, Pos, Title
2 FROM  Nodes
3 ORDER BY ParentID

）

我们将要设计的存储过程传入一个待查询职位的ID，返回其下所有节点的Title：

1 CREATE PROCEDURE GetTitle
2     @ID int
3 AS
4 BEGIN
5     SELECT Title
6     FROM  Nodes
7     WHERE ParentID = @ID
8 END

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

答：通过构造非法的SQL的字符串来是系统返回攻击者想要得到的信息，对输入字符串进行严格校验。替换其中的单引号 - '等。

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

1 int i=5;
2 int j=5;
3 if (Object.ReferenceEquals(i,j))
4      Console.WriteLine("Equal");
5 else
6      Console.WriteLine("Not Equal");

答：输出Not Equal，ReferenceEquals比较两个引用类型对象的引用是否相同，对于值类型要先装箱再比较，所以总是返回false（装箱操作引用不会相同）。

8. 写一个实现对一段字符串翻转的方法，附加一些条件，如其中包括"，"、"."，对其设计测试用 例 。

1 string strfrist = "abcdef";
2 int len = strfrist.Length;
3 string aa = "";
4 
5 for (int i = len - 1; i >= 0; i--)
6 {
7     aa += strfrist.Substring(i, 1);
8 }
9 string resultstr = aa.ToString();

测试用例不了解

9. 对一支纸杯设计测试用例（可以是广义的杯，不一定是某一支特定功能的杯）

答：漏不漏，超过最大容量溢出的保护。仍然对测试用例不了解。

10. 什么是反射？

答：反射提供了封装程序集、模块和类型的对象（Type 类型）。可以使用反射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性(Attribute)，可以利用反射对它们进行访问。

11. 用Singleton设计模式编写一段代码。

 1 public class Singleton
 2 {
 3     private static Singleton instance = null;
 4 
 5     public static Singleton getInstance()
 6     {
 7         if (instance == null)
 8             instance = new Singleton();
 9         return instance;
10     }
11 }

12. C#中的垃圾回收机制是怎样的？

答：垃圾回收机制需要应用程序不时地暂停从而释放不再使用的内存，垃圾回收机制假设了以下情况：

1.被分配内存空间的对象最有可能被释放。

2.生命期最长的对象释放的可能性最小。

3.同时被分配内存的对象通常是同时使用，将它们彼此相连有助于提高缓存性能和回收效率 。

C#中的回收器是分代的垃圾回收器（Gererational Garbage Collector) ，它将分配的对象分为3个代。最常用的对象在第一代，每次回收后还在使用的对象将被放入下一代，直至被放入第二代。另外回收器负责引用对象的回收，不负责值类型对象的回收。

13. 什么是Application Pool？

答：应用程序池是将一个或多个应用程序链接到一个或多个工作进程集合的配置。因为应用程序池中的应用程序与其他应用程序被工作进程边界分隔，所以某个应用程序池中的应用程序不会受到其他应用程序池中应用程序所产生的问题的影响。

14. Remoting在客户端服务器怎么实现?

答：以Remoting的升级技术WCF来说，服务器端通过终结点（定义了服务的地址，协议，契约）来发布，客户端订阅这个服务，定义代理（其中也包括与终结点相同的地址，协议，契约等信息）来访问服务。

15.什么是虚函数？

一般函数在编译时就静态地编译到了执行文件中，其相对地址在程序运行期间是不发生变化的，也就是写死了的！而虚函数在编译期间是不被静态编译的，它的相对地址是不确定的，它会根据运行时期对象实例来动态判断要调用的函数。

检查过程如下：

1、当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即声明类，看所调用的函数是否为虚函数；

2、如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。

3、在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重写了该虚函数的父类为止，然后执行该父类里重写后的函数。

给出个示例说明上述问题：

 1 class Program
 2 {
 3     static void Main(string[] args)
 4     {
 5         C c = new C();
 6     }
 7 }
 8 
 9 public class A
10 {
11     public A()
12     {
13         Console.WriteLine("DEBUG: A constructing");
14         this.GetYear();
15     }
16 
17     public virtual void GetYear()
18     {
19         Console.WriteLine("A");
20     }
21 }
22 
23 public class B : A
24 {
25     public B()
26         : base()
27     {
28         Console.WriteLine("DEBUG: B constructing");
29         this.GetYear();
30     }
31 
32     public override void GetYear()
33     {
34         Console.WriteLine("B");
35     }
36 }
37 
38 public class C : B
39 {
40     public C()
41     {
42         Console.WriteLine("DEBUG : C constructing");
43         this.GetYear();
44     }
45 
46     public override void GetYear()
47     {
48         Console.WriteLine("C");
49     }
50 }

参考：

http://www.cnblogs.com/piccolo/articles/128606.html

http://blog.csdn.net/thebesghost/archive/2006/11/23/1408433.aspx

16.什么是抽象函数？

抽象函数没有执行代码，必须在非抽象的派生类中重写。显然，抽象函数也是虚拟的(但也不需要提供virtual关键字)。如果类包含抽象函数，该类将也是抽象的，也必须声明为抽象的。

17.使用什么工具来调用存储过程。

答：ADO.NET2.0实现方式：

1 SqlConnection conn = new SqlConnection("testconn");
2 SqlCommand comm = conn.CreateCommand();
3 string Sql = "SqlServerSpName";
4 comm.CommandText = Sql;
5 comm.CommandType = CommandType.StoredProcedure;
6 comm.ExecuteNonQuery();

18.SQL Server的两种索引是何形式？索引的作用？索引的优缺点？

SQL SERVER提供了两种索引：聚集索引（clustered index，也称聚类索引、簇集索引）和非聚集索引（nonclustered index，也称非聚类索引、非簇集索引）。

用聚集索引的最大好处就是能够根据查询要求，迅速缩小查询范围，避免全表扫描。一个表中只能存在一个聚集索引，因为一个表中的记录只能以一种物理顺序存放。由于聚集索引所以很大，所以要选择好建立聚集索引的列。（SQL Server默认将主键作为聚集索引有时并不符合设计要求）。

非聚簇索引需要大量的硬盘空间和内存。另外，虽然非聚簇索引可以提高从表中 取数据的速度，它也会降低向表中插入和更新数据的速度。每当你改变了一个建立了非聚簇索引的表中的数据时，必须同时更新索引。因此你对一个表建立非聚簇索引时要慎重考虑。如果你预计一个表需要频繁地更新数据，那么不要对它建立太多非聚簇索引。另外，如果硬盘和内存空间有限，也应该限制使用非聚簇索引的数量。

19.触发器的作用。

触发器（trigger）是个特殊的存储过程，它的执行不是由程序调用，也不是手工启动，而是由个事件来触发，比如当对一个表进行操作（ insert，delete， update）时就会激活它执行。触发器经常用于加强数据的完整性约束和业务规则等。

它们主要用于强制服从复杂的业务规则或要求。例如，您可以根据客户当前的帐户状态，控制是否允许插入新订单。触发器也可用于强制引用完整性，以便在多个表中添加、更新或删除行时，保留在这些表之间所定义的关系。然而，强制引用完整性的最好方法是在相关表中定义主键和外键约束。

20.Socket怎么实现？

 1 IPAddress ipAddress = IPAddress.Parse("192.168.1.10");
 2 int port = 8080;
 3 IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
 4 // 生成一个TCP/IP socket.  
 5 Socket client = new Socket(AddressFamily.InterNetwork,
 6 SocketType.Stream, ProtocolType.Tcp);
 7 // 与目标终端连接. 
 8 client.Connect(remoteEP);
 9 
10 // 发送数据到远程终端. 
11 // 格式转换.
12 byte[] byteData = Encoding.ASCII.GetBytes("Test");
13 // 开始发送数据到远程设备.
14 client.Send(byteData, 0, byteData.Length, 0);

感謝博主--hystar的.Net世界的分享,點擊產看原文連接