.NET面试题汇总

正文

本次给大家介绍的是我收集以及自己个人保存一些.NET面试题

简介

此次包含的不止是.NET知识，也包含少许前端知识以及.net面试时所涉及的种种考点，希望能给找工作的同学们哪怕一点点帮助。
古人云“温故而知新，可以为师矣”，本人工作三年有余，一直懒于写博客，对已有的知识只存于云笔记中，还自欺欺人以为能加以善用，可惜的是放到里面就不会再看，存笔记的习惯是有了，然而却少有回去翻看的习惯。久而久之，越堆越多，恶心循环，存的只是安心，而不是技术，为此，我决定以后多写博客，不仅是存笔记，还得是整理并发出来，这样才能真正地巩固。
本文面向的阅读读者是
[x] 刚毕业的萌新
[x] 工作不久换工作同学
大牛看到估计是下面这张图的这个表情了，所以，可以在评论区给给意见啦233。

废话少说，直入正题：

1.C# 值类型和引用类型的区别

区别	详解
赋值时的区别	值类型的变量将直接获得一个真实的数据副本，初值为0；而对引用类型的赋值仅仅是把对象的引用赋给变量，这样就可能导致多个变量引用到一个实际对象实例上，初值为null。
内存分配的区别	值类型的对象会在堆栈上分配内存，而引用类型的对象将会在堆上分配内存。堆栈的控件相对有限，但运行效率却比堆高得多。
来自继承结构的区别	由于所有的值类型都有一个共同的基类：System.ValueType，所以值类型拥有一些引用类型不具有的共同性质。较为重要的一点是值类型的比较方法Equals 方法的实现有了改变。所有的值类型已经实现了内容的比较，而引用类型在没有重写Equals方法的情况下，仍然采用引用比较。

2.如何使得一个类型可以在foreach 语句中使用

1.若要循环访问集合，集合必须满足特定的要求。

例如，在下面的 foreach 语句中：
foreach (ItemType item in myCollection)
myCollection 必须满足下列要求：
集合类型：
①.必须是 interface、class 或 struct。
②.必须包括返回类型的名为 GetEnumerator 的实例方法，例如 Enumerator。
Enumerator 类型（类或结构）必须包含：
一个名为 Current 的属性，它返回 ItemType 或者可以转换为此类型的类型。属性访问器返回集合的当前元素。
一个名为 MoveNext 的 bool 方法，它递增项计数器并在集合中存在更多项时返回 true。

2.有三种使用集合的方法：

使用上述指导创建一个集合。此集合只能用于 C# 程序。
使用上述指导创建一个一般集合，另外实现 IEnumerable 接口。此集合可用于其他语言（如 Visual Basic）。
在集合类中使用一个预定义的集合。

3.sealed修饰的类有什么特点

sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其他类的基类，则会发生编译时错误。
密封类不能同时为抽象类。
sealed 修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化。具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数成员的调用可以转换为非虚拟调用来处理。

// cs_sealed_keyword.cs
using System;
sealed class SealedClass
{
    public int x;
    public int y;
}                               

class MainClass
{
    static void Main()
    {
        SealedClass sc = new SealedClass();
        sc.x = 110;             
        sc.y = 150;
        Console.WriteLine("x = {0}, y = {1}", sc.x, sc.y);
    }
}

输出
x = 110, y = 150
在前面的示例中，如果试图通过使用下面的语句从密封类继承：

class MyDerivedC: MyClass {} // Error 

将收到错误信息：

'MyDerivedC' cannot inherit from sealed class 'MyClass'.

4.面向对象的3个基本特征

封装

名词	简介
封装	封装是面向对象的特征之一，是对象和类概念的主要特性。

封装详解：

也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

名词	简介
继承	面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

继承详解：

通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承

实现继承是指使用基类的属性和方法而无需额外编码的能力；
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

多态

名词	简介
多态	多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载：

覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

那么，多态的作用是什么呢？

我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

5. .NET 托管资源与非托管资源

非托管资源

最常见的一类非托管资源就是包装操作系统资源的对象，例如文件，窗口或网络连接，对于这类资源虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期，但它不了解具体如何清理这些资源。还好.net Framework提供了Finalize()方法，它允许在垃圾回收器回收该类资源时，适当的清理非托管资源。如果在MSDN Library 中搜索Finalize将会发现很多类似的主题，

这里列举几种常见的非托管资源：ApplicationContext,Brush,Component,ComponentDesigner,Container,Context,Cursor,FileStream,Font,Icon,Image,Matrix,Object,OdbcDataReader,OleDBDataReader,Pen,Regex,Socket,StreamWriter,Timer,Tooltip 等等资源。可能在使用的时候很多都没有注意到！

托管资源

像简单的int,string,float,DateTime等等，.net中超过80%的资源都是托管资源。

6.string str=null与string str="" 有什么区别

你定义了一个变量的引用str
string str=null 把这个引用指向了一个null，没有地址没有值的地方，即没分配内存空间
string str="" 把这个引用指向了一个地址，地址里面存的是空的字符，即占用了内存空间

7.StringBuilder有什么作用

简述：String 在进行运算时（如赋值、拼接等）会产生一个新的实例，而 StringBuilder 则不会。
所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder，不要使用 String

另外，对于 String 我们不得不多说几句：

1.它是引用类型，在堆上分配内存

2.运算时会产生一个新的实例

3.String 对象一旦生成不可改变（Immutable）

4.定义相等运算符（== 和 !=）是为了比较 String 对象（而不是引用）的值

总结：
StringBuilder采用构造器设计模式的思想高效地构造一个字符串对象，在构造过程中StringBuilder 可以有效的避免临时字符串对象的生成。一旦 StringBuilder的ToString方法被调用后，最终的字符串就被生成，而随后的操作将导致一个新的字符串对象的分配。因为字符串对象的不可修改特性，StringBuilder还经常被用来和非托管代码交互。

8.序列化有何作用

简述：通过流类型可以方便地操作各种字节流，但如何把现有的实例对象转换为方便传输的字节流，就需要用到序列化的技术。

9.Base64编码用在何处

简述：BASE64编码是一种用于混淆明码的编码方式，其算法是把原先8位字节数组顺序分配到新的6位字节数组中，再在每个字节的高2位填充0来组成新的8位字节数组。.NET中Convert 类型可以用来进行Base64字符串和8位字节数组之间的转换。

10.字符串池是如何提高系统性能的？

简述：一旦使用了字符串池机制，当CLR启动的时候，会在内部创建一个容器，容器的键是字符串内容，而值是字符串在托管堆上的引用。当一个新的字符串对象需要分配时，CLR首先检测内部容器中是否已经包含了该字符对象，如果已经包含，则直接返回已经存在的字符串对象引用：如果不存在，则新分配一个字符串对象，同时把其添加到内部容器里去。但是当程序用new关键字显式地申明新分配的一个字符串对象时，该机制不会起作用。

11.FileInfo 和 DirectoryInfo

简述： .NET 内建类型中提供了 FileInfo 和 DirectoryInfo 两个类型，分别用来操作文件和文件夹。有别于 File 和 Directory 类型， FileInfo 和 Directory 主要的功能在于操作文件和文件夹在文件系统中的结构，完成诸如创建、复制、读取信息、移动、判断是否存在、删除等功能。

12.DateTime.Parse(mystring) 这行代码有什么问题

简述：使用 TryParse 可以避免异常。

示例
string time="2013-02-02";
DateTime t;
if(DateTime.TryParse(s,out t))
{
   //输出
}

13.System.Object的三个比较方法异同

static bool ReferenceEquals(object A ,object B)
static bool Equals(object A ,object B)
virtual bool Equals(object obj)

1.ReferenceEquals 实现了类型的引用比较，从参数类型可以看出，它不仅可以用来比较两个引用类型对象，也可以用来比较两个值类型对象。
当然，ReferenceEquals 方法只有应用在引用类型上时才会有意义，比较值类型的引用将永远返回false，无论他们的值是否相等。甚至与下面的例子：
int i=0; Console.WriteLine(Object.ReferenceEquals(i,i));

解释：因为上面的两个i都是先进行装箱，然后传递给ReferenceEquals 方法。

2.Equals 是另外一个静态比较方法，它实现的功能根据不同的类型而有所不同。事实上，Equals 方法的功能依靠了实例Equals 方法的实现，概括地讲，静态 Equals 方法的内容分为两步：首先检查两个对象是否恒等（==），然后调用其中一个参数对象的实例 Equals 方法来判断两个对象是否恒等。

14.GetHashCode 方法有何作用？什么时候会用到该方法

简述：

Object 中 GetHashCode 的算法保证了同一对象返回同一 HashCode ，而不同对象则返回不同的 HashCode，但对值类型等视内容相等的对象为相等对象的类型时，默认的GetHashCode 算法并不正确。
重写 GetHashCode 必须保证同一对象无论何时都返回同一 HashCode 值，而相等的对象也必须返回相同的值，并且在此基础上，保证 HasCode 尽量随机地散列分布。

15.委托的原理

简述：委托是一类继承自 System.Delegate的类型, 每个委托对象至少包含了一个指向某个方法的指针,该方法可以是实例方法,也可以是静态方法。委托实现了回调方法的机制,能够帮助程序员设计更加简洁优美的面向对象程序。

16.委托回调静态方法和实例方法有何区别

简述：委托回调静态方法和实例方法有何区别当委托绑定静态方法时,内部的对象成员变量 _target将会被设置成 null,而当委托绑定实例方法时, _target 将会设置成指向该实例方法所属类型的一个实例对象, 当委托被执行时, 该对象实例将被用来调用实例方法。

17. 什么是链式委托？

简述：链式委托是指一个委托的链表,而不是指另一类特殊的委托。当执行链上的一个方法时,后续委托方法将会被依次执行。System.Multicast Delegate定义了对链式委托的支持。在System.Delegate的基础上,它增加了一个指向后续委托的指针,这样就实现了一个简单的链表结构。

18.ASP.NET 运行机制

1.浏览器和服务器的交互原理

通俗描述：我们平时通过浏览器来访问网站，其实就相当于你通过浏览器去访问一台电脑上访问文件一样，只不过浏览器的访问请求是由被访问的电脑上的一个 WEB服务器软件来接收处理，它会分析接收到的请求信息，从而按照请求信息来找到服务器电脑上的文件，经过处理，最终将生成的内容发回到浏览器。
简单的说就是：由浏览器生成一条“命令”，通过互联网发给另一台电脑的某个软件(服务器软件)；服务器软件接收到“命令”，就分析理解这个“命令”，然后按照“命令”找到服务器电脑上的文件，将文件内容发送回浏览器。

通过上图，我们看到了浏览器和服务器交互的简单过程。现在，我们要想想，浏览器和服务器软件到底是神马东东，他们之间又是如何交互信息的呢？
其实，浏览器和服务器软件，就是两个独立的应用程序(就如qq、office、画图工具一样)。那么两个应用程序之间要交互信息，就牵扯到了应用程序通信的问题。那他俩是使用神马方式通信的呢？

答案是套接字：Socket。至于Socket的具体用法和原理，篇幅问题不在此文中写了，先预留位置在这，下次补上《基于多线程和套接字的简易WebServer软件-没有控件的ASP.NET》。
浏览器和服务器软件通过套接字来发送和接收对方的信息,但现在的关键问题是,他们发送和接收的到底是什么?--- 基于Http协议的报文数据（详见《Http协议介绍---没有控件的ASP.NET》）。
也就是说：浏览器和服务器软件其实就是两个使用Socket进行通信的的两个应用程序：双方都发送按照 Http协议语法规范组织的数据，接收到数据后都按照 Http协议语法规范来解释。

2.浏览器和IIS(or other webserver)交互机制

上图就是IIS (服务器软件)

1.浏览器和IIS交互过程：
我们都知道，在互联网上确定一台电脑的位置是使用IP寻址，但为什么当我们平时访问网站时直接输入一个域名也能够访问到某个服务器电脑进而由对方的服务器软件发送响应页面数据给我呢？下面我把简单步骤列出：

(1)在浏览器输入网址:www.oumind.com/index.html，浏览器按照Http协议语法生成请求报文数据。

(2).浏览器检查本机是否保存了www.oumind.com/index.html.域名对应的服务器IP地址。如果没有，则发送请求到所在城市网中最近的DNS服务器(域名解析服务器)，它会根据我们发送来的域名查询到该域名对应的服务器IP地址，并发送回浏览器。

(3)浏览器从DNS服务器获得了 www.oumind.com/index.html域名对应的服务器电脑IP，则将请求报文通过Socket发送到服务器电脑。（注意：Http协议规定服务器软件使用的默认端口是80，通俗的说，就是如果浏览器访问一个网站页面，浏览器默认就是将请求报文发送到服务器80端口，而服务器负责监听这个端口的软件一般就是服务器软件—比如asp.net用的IIS，java用的Tomcat。）

(4)IIS接收到请求报文，分析请求报文，从中获取请求的页面路径 /index.html。判断页面的后缀名，如果是静态页面(.html/.jpg/.css/.js等)，则直接由IIS软件的组件读取该文件内容，并将内容通过Socket发送回浏览器。

(5)但如果此时请求的是一个动态页面(.aspx/.ashx)，IIS自己就处理不了 (因为IIS软件开发出来的时候，ASP.NET程序还不存在呢) 。所以，IIS就去它的扩展程序映射表中根据被请求文件后缀名查看是否有能够处理这种文件的扩展程序。

而我们ASPNET中常用的文件.aspx/.ashx等对应的处理程序是aspnet_isapi.dll。如下图：

(6)如果IIS根据后缀名找到对应的处理程序，则通过调用此程序来处理浏览器发送来的请求报文。

IIS自身是不能处理像ASPX扩展名这样的页面，只能直接请求像HTML这样的静态文件，之所以能处理ASPX这样扩展名的页面，是因为IIS有一个ISAPI过滤器，它是一个COM组件。

ASP.NET服务在注册到IIS的时候，就会添加一个Win32的扩展动态库aspnet_isapi.dll。并将扩展可以处理的页面扩展名（如 ASPX）注册到IIS里面。扩展启动后，就根据定义好的方式来处理IIS所不能处理的页面。

当客户端请求一个服务器资源时，这个HTTP请求会被inetinfo.exe进程截获（www服务），然后Check请求资源的类型，并依据资源映射信息（存储在IIS元库中，一种IIS专用的配置数据库）将请求的资源分配给特定的处理程序模块。若请求的是静态资源（img,text,html等）则由IIS处理（IIS在本地Web Server上访问请求的文件），将内容输出到控制台，发出请求的浏览器就能接收到它了。

若需要在服务器端处理的请求，则会被传到已注册的扩展模块中，aspx请求会被分配给aspnet_isapi.dll，让这个程序开始处理代码，生成标准的HTML代码，然后将这些HTML加入到原有的 HTML中，最后把完整的HTML返回给IIS，IIS再把内容发送到客户浏览器。

ASP.NET FrameWork对请求的处理：

上面说到IIS将像ASPX这样的页面分配给aspnet_isapi.dll，接着处理如下：

1、aspnet_isapi.dll则会通过一个Http PipeLine的管道将这个Http请求发给w3wp.exe（iis 工作者进程，IIS6.0中叫做 w3wq.exe，IIS5.0中叫做 aspnet_wp.exe)，之后asp.net framework就会通过HttpRuntime来处理这个Http请求。

2、HttpRuntime首先会确定处理该请求的类名，HttpRuntime通过公共接口IHttpHandler来调用该类获取被请求资源的类的实例。

3、调用HttpRuntime.ProcessRequest开始处理要发送到浏览器的页面，具体说就是创建一个HttpContext实例，它封装了所有与请求有关的http特有的信息，并初始化一个Write对象用于缓存标记代码。

4、HttpRuntime使用上下文信息查找或新建能处理该请求的WEB应用程序的对象。由HttpApplication Factory负责返回HttpApplication实例。

5、HttpApplication实例会读取web.config中所有HttpModule的配置。

6、HttpApplication对象使用IHttpHandlerFactory类型的实例返回HttpHandler（http处理程序）给HttpRuntime对象。一个页面只是个http处理程序对象。
7、最后由HttpRuntime对象调用IHttpHandler的页面对象的ProcessRequest方法。

19.C＃中静态变量和方法用什么用处

1.静态变量简介

在C#程序中，没有全局变量的概念，这意味着所有的成员变量只有该类的实例才能操作这些数据，这起到了“信息隐藏”的作用。但有些时候，这样做却不是个明智的选择。

假设我们要定义一个图书类，要求该类能保存图书的数量，即每增加一本图书（定义一个实例），图书的数量应该加1。如果没有静态变量，我们需要将图书的数量保存在每本图书（实例）里，然而，这样的变量要在不同图书（实例）里重复存储，图书（实例）数量少的话，我们还能接受，如果图书（实例）数量较多的话，比如成千上万，我们无法想象这要造成多少资源（如内存、磁盘空间）的浪费，更让人无法忍受的是：因为图书（实例）的数量要保存在每本图书（实例）里，该值肯定是不同的。要使这些图书（实例）中保存的图书（实例）数量一致，我们必须在每增加一本新书（生成一个新实例）时，修改其他所有图书（实例）中保存的该值。
Oh,My God!你会重新向往面向过程的程序设计方法，向往拥有全局变量的时代。但，这种局面不会出现，因为C#中为你准备好了另外一种变量类型：静态变量。它在类中类似全局变量，保存类的公共信息，所有该类的实例（对象）共享该值。

静态变量的声明方式如下：

  [访问修饰符] static 数据类型 变量名;

这里的访问修饰符跟类的其它成员一样，可以是public,protected,private或internal等。

2.静态变量又如何使用呢？

静态变量必须使用类名来引用，而不能使用类的实例，因为，静态变量不属于任何实例，而是共有的。

我们可以打个比方：在一个班级中，有些物品是个人的，我们想使用时，必须指出物品的所有者，比如说“王三的自行车”，在C#程序中我们可以使用：王三.自行车的格式。有些物品是大家共有的物品，不能以个人名义使用，而是用班级的名义使用，比如班集体出资买的篮球，只能说：“班级的篮球”，而不能说：“王三的篮球”。这绝对是不行的，这对其他人绝对是不公平的，我们可以联想到许多贪官污吏就是使用了不属于自己的东西，或以个人名义使用公家的东西而葬送了自己。
说一句有用的就是：静态变量是用类名来引用它。即：类名.静态变量名;

举个具体的例子如下：

using System;

class StaticVar
       {
              public int x;
              public static int y;
              public void PrintInfo()
             {
                    Console.WriteLine("非静态变量x={0}",x);
                    Console.WriteLine("静态变量y = {0}",y);
             }
        }
        class Test
        {
                  static void Main(string[] args)
                  {
                         StaticVar stv = new StaticVar();
                         stv.x = 10;
                          // stv.y = 20; //error;无法使用实例引用访问静态成员“StaticVar.y”；改用类型名来限定它
                         StaticVar.y = 20;
                         stv.PrintInfo();
                   }
        }

程序中被注释的部分：stv.y = 20是使用实例引用静态变量，这将引发错误。

另外，我想说一句，对于静态变量在声明时，如果没有给出初始值或使用前没有赋任何值的话，系统会给他们一个默认值：对于整型数据默认值为0；单精度数据为：0.0f；双精度数据为0.0；布尔型数据为False；引用型数据为null。

3.静态方法

静态方法与静态变量一样，不属于任何特定的实例，属于类全体成员共有，由类名来调用。

但要注意以下几点：

静态方法只能访问类的静态成员，不能访问类的非静态成员；
非静态方法可以访问类的静态成员，也可以访问类的非静态成员；
静态方法不能使用实例来调用，只能使用类名来调用。

这里用一个具体的例子来说明：

using System; 

namespace TestStatic
       {
              class StaticTest
              {
                     int x;
                     static int y;
                     public StaticTest(int a,int b)
                     {
                            x = a;
                            y = b;
                     }
                     public void SimplePrint()
                     {
                            Console.WriteLine("x="+x+",y="+y);
                     }
                     public static void StaticPrint()
                    {
                          Console.WriteLine("y={0}",y);
                         //  Console.WriteLine("x={0}",x);   //静态方法中不能使用非静态成员
                    }
            }
            class Test
            {
                    static void Main(string[] args)
                    {
                            StaticTest st = new StaticTest(10,23);
                            st.SimplePrint();
                            //st.StaticPrint();        //静态方法不能使用实例来调用
                            StaticTest.StaticPrint();
                    }
             } 
       }

posted @ 2017-11-22 13:08 维尼熊320 阅读(347) 评论(0) 编辑收藏举报

刷新页面返回顶部

维尼熊的进阶路