今年畢業(yè)，本學期找工作期間在面試前做的一些臨時的準備

以下的關于老趙分享的面試題解答參考了手頭的書籍和視頻教程，以及網(wǎng)上的資料，現(xiàn)整理出來希望對大家有所幫助，不對或欠佳的地方望大家指出來我好改正。

1.什么是.NET？什么是CLI？什么是CLR？IL是什么？

(1).net用于代碼編譯和執(zhí)行的集成托管環(huán)境，換句話，它管理應用程序運行的方方面面，包括首次運行的編譯，為程序分配內存
存儲數(shù)據(jù)和指令，對于應用程序授予或拒絕相應的權限，并啟動管理應用程序的執(zhí)行，剩余內存的在分配。由于所有.net應用程序
都是在.net framework上面執(zhí)行，所以開發(fā)人員只需考慮與.net framework打交道，而不必關系和底層操作系統(tǒng)上面的實現(xiàn)
包括CLR和BCL

(2).CLI(common language infrastructure)公共語言基礎結構，一項國際性的標準，沒有規(guī)定標準具體如何實現(xiàn)。相反，它描述了一個
CLI平臺在符合標準的前提下應該具有什么行為。包含了：運行時（CLR），公共中間語言（CIL），公共類型系統(tǒng)（CTS），
公共語言規(guī)范（CLS），元數(shù)據(jù)（Metadata），框架（framework）

(3)CLR：公共語言運行時，負責加載和運行程序  IL：中間語言，C#編譯器將C#代碼轉換成IL，運行時能夠理解IL，并編譯成機器碼

2.JIT是什么，它是如何工作的？GC是什么，簡述一下GC的工作方式？

JIT：Just in time,C#或者是VB.NET的代碼首先被編譯為IL存儲在本地，當要運行這些代碼的時候，CLR對IL進行第二次編譯轉換成機器碼運行。好處：可移植性，而且IL在加載到內存中時將受到類型安全性方面檢查，這實現(xiàn)了更好的安全性和可靠性。

GC：垃圾回收（garbage collection）,是根據(jù)程序的需要自動分配和回收內存的過程。垃圾回收器處理的是引用對象，而且只回收堆上的內存。這意味著假如維持對一個對象的引用，就會阻止GC重用對象使用的內存。在.NET中，垃圾回收器采用的是mark-and-compact算法。在一次垃圾回收周期開始的時候，它要識別對象的所有跟引用，根據(jù)這個引用可以遍歷每個根引用所標識的一個樹形結構，并遞歸確定所有引用指向的對象。這樣一來，垃圾回收器就可以識別所有可達的對象，在執(zhí)行回收的時候，GC不是枚舉所有訪問不到的對象，相反，通過壓縮所有相鄰的可達的對象來執(zhí)行垃圾回收。不可訪問的對象就會被覆蓋。垃圾回收的宗旨是提高內存的利用率，它并不是用來清理文件句柄，和數(shù)據(jù)庫連接字符串，端口或者其他有限的資源（終接器finalizer，不能被顯示調用，不能傳遞任何參數(shù)，即不能被重載，只有垃圾回收器才能調用終接器，使用Using語句進行確定性終結

3.類（class）和結構（struct）的區(qū)別是什么？它們對性能有影響嗎？

1. 值類型與引用類型

結構是值類型：值類型在棧上分配地址，所有的基類型都是結構類型，例如：int 對應System.int32 結構，通過使用結構可以創(chuàng)建更多的值類型
類是引用類型：引用類型在堆上分配地址堆棧的執(zhí)行效率要比堆的執(zhí)行效率高，可是堆棧的資源有限，不適合處理大的邏輯復雜的對象。所以結構處理作為基類型對待的小對象，而類處理某個商業(yè)邏輯因為結構是值類型所以結構之間的賦值可以創(chuàng)建新的結構，而類是引用類型，類之間的賦值只是復制引用
注：1.雖然結構與類的類型不一樣，可是他們的基類型都是對象（object）,c#中所有類型的基類型都是object
2.雖然結構的初始化也使用了New 操作符可是結構對象依然分配在堆棧上而不是堆上，如果不使用“新建”(new)，那么在初始化所有字段之前，字段將保持未賦值狀態(tài)，且對象不可用

 2．繼承性

結構：不能從另外一個結構或者類繼承，本身也不能被繼承，雖然結構沒有明確的用sealed聲明，可是結構是隱式的sealed .
類：完全可擴展的，除非顯示的聲明sealed 否則類可以繼承其他類和接口，自身也能被繼承注：雖然結構不能被繼承 可是結構能夠繼承接口，方法和類繼承接口一樣

3．內部結構：
結構： 沒有默認的構造函數(shù)，但是可以添加構造函數(shù)沒有析構函數(shù)沒有 abstract 和 sealed(因為不能繼承)不能有protected 修飾符可以不使用new 初始化在結構中初始化實例字段是錯誤的
類： 有默認的構造函數(shù) 有析構函數(shù) 可以使用 abstract 和 sealed 有protected 修飾符
必須使用new 初始化

4..NET BCL里有哪些是類（結構），為什么它們不是結構（類）？

結構：System.Boolean  Byte   Char  Decimal Double  Int32
堆棧的空間有限，對于大量的邏輯的對象，創(chuàng)建類要比創(chuàng)建結構好一些 大多數(shù)情況下該類型只是一些數(shù)據(jù)時，結構時最佳的選擇
類：String Object Delegate 接口 等等 包含了大量的邏輯對象，表現(xiàn)抽象

5.在自定義類型時，您如何選擇是類還是結構？

1)． 堆棧的空間有限，對于大量的邏輯的對象，創(chuàng)建類要比創(chuàng)建結構好一些
2)． 結構表示如點、矩形和顏色這樣的輕量對象，例如，如果聲明一個含有 1000 個點對象的數(shù)組，則將為引用每個對象分配附加的內存。在此情況下，結構的成本較低。
3)． 在表現(xiàn)抽象和多級別的對象層次時，類是最好的選擇
4)． 大多數(shù)情況下該類型只是一些數(shù)據(jù)時，結構時最佳的選擇

6.在.NET程序運行過程中，什么是堆，什么是棧？

棧通常保存著我們代碼執(zhí)行的步驟，而堆上存放的則多是對象，數(shù)據(jù)等。我們可以把棧想象成一個接著一個疊放在一起的盒子。當我們使用的時候，每次從最頂部取走一個盒子。棧也是如此，當一個方法（或類型）被調用完成的時候，就從棧頂取走（called a Frame，譯注：調用幀），接著下一個。堆則不然，像是一個倉庫，儲存著我們使用的各種對象等信息，跟棧不同的是他們被調用完畢不會立即被清理掉。
棧內存無需我們管理，也不受GC管理。當棧頂元素使用完畢，立馬釋放。而堆則需要GC(Garbage collection:垃圾收集器)清理

7.什么情況下會在堆（棧）上分配數(shù)據(jù)？它們有性能上的區(qū)別嗎？“結構”對象可能分配在堆上嗎？什么情況下會發(fā)生，有什么需要注意的嗎？

1)值類型一般分配在對上面，引用類型分配在堆上面。棧的效率要高于堆。
2）可能，當在類中定義一個結構類型時，該結構就分配在堆上

8.泛型的作用是什么？它有什么優(yōu)勢？它對性能有影響嗎？它在執(zhí)行時的行為是什么？

作用：為了促進代碼的重用，尤其是算法的重用
優(yōu)勢：（1）可重用性（2）類型安全，在參數(shù)化的類中只有成員明確希望的數(shù)據(jù)類型才可以使用（3）性能：避免了從Object的強制轉換和值類型的裝箱（4）減小了內存消耗：避免裝箱也就不在需要消耗堆上的內存。
執(zhí)行時的行為：泛型也是對象，泛型類的“類型參數(shù)”變成了元數(shù)據(jù)；CLR會在需要的時候構造利用它們的類。一個泛型類經過編譯好之后和普通的類并沒有什么區(qū)別。編譯的結果只有元數(shù)據(jù)和CIL?；谥殿愋偷姆盒蛯嵗篊LR會講指定的類型參數(shù)放到CIL中合適的位置，從而創(chuàng)建一個具體化的泛型類型。所以CLR會為沒個新的參數(shù)值創(chuàng)建具體的泛型類型
基于引用類型的實例化：CLR會創(chuàng)建一個具體化的泛型類型。以后，每次用一個引用類型參數(shù)來說實例化一個構造好的類型時，并在CIL中用Object引用替換類型參數(shù)，CLR都會重用以前生成好的泛型版本

9..NET BCL中有哪些泛型類型？舉例說明平時編程中您定義的泛型類型。

List<T>:通過索引訪問強類型的列表
Dictionary<T>:表示鍵值對的集合
Queue<T>:隊列  Stack<T>: 棧
購物車用Dictionary模擬，OA中獲取員工列表等數(shù)據(jù)的時候，返回值是泛型的

10.異常的作用是什么？.NET BCL中有哪些常見的異常？在代碼中您是如何捕獲/處理異常的？在“catch (ex)”中，“throw”和“throw ex”有什么區(qū)別？您會如何設計異常的結構，什么情況下您會拋出異常？

（1）C# 語言的異常處理功能可幫助您處理程序運行時出現(xiàn)的任何意外或異常情況
（2）throw會保留堆棧信息。throw ex 不會。當然，如果你拋出新的異常之前設置innerException的話，可以通過innerException的堆棧訪問原有的堆棧。
（3）靠異常才能發(fā)現(xiàn)錯誤的，通過try catch finally來捕獲異常。如果是未預料到的則不處理（內存不足，刪除文件）直接報錯更容易發(fā)現(xiàn)錯誤catch塊從最具體到常規(guī)排列

11.List<T>和T[]的區(qū)別是什么，平時你如何進行選擇？Dictionary<TKey, TValue>是做什么的？.NET BCL中還有哪些常用的容器？它們分別是如何實現(xiàn)的（哪種數(shù)據(jù)結構）？分別是適用于哪些場景？

1.List<T>arrylist的泛型版本，大小是可變的，T[]繼承自Array,大小是固定的。如果大小沒有怎么變化，選擇T[],一般情況下選擇List<T>
2.Dictionary是hashtable的泛型版本，用來存儲鍵值對的.例如：sortlist，stack等

12抽象類和接口有什么區(qū)別？使用時有什么需要注意的嗎？

如何選擇是定義一個“完全抽象”的抽象類，還是接口？什么是接口的“顯式實現(xiàn)”？為什么說它很重要？
相同點：都不能被直接實例化，都通過繼承實現(xiàn)其抽象方法
不同點：
（1） 接口支持多繼承；抽象類不能實現(xiàn)多繼承。
（2） 接口只能定義行為；抽象類既可以定義行為，還可能提供實現(xiàn)。
（3） 抽象類允許包含實現(xiàn)的virtual成員，所以能為派生類成員提供一個默認的實現(xiàn)，而接口所有的成員自動成為virtual成員，而且不能包含任何實現(xiàn)

13.字符串是引用類型類型還是結構類型？ 引用類型

它和普通的引用類型相比有什么特別的地方嗎？不可變的
使用字符串時有什么需要注意的地方？為什么說StringBuilder比較高效？
當拼接兩個字符串時，系統(tǒng)先是把兩個字符串寫入內存，接著刪除原來的String對象，然后創(chuàng)建一個String對象，并讀取內存中的數(shù)據(jù)賦給該對象。這一來二去的，耗了不少時間。而使用System.Text命名空間下面的StringBuilder類就不是這樣了，它提供的Append方法，能夠在已有對象的原地進行字符串的修改，簡單而且直接。
在連接多個字符串時，它無論何時都比直接相加更高效嗎？
不一定，在1000個字符以內效果一樣，達到10000時StringBuilder類的效率會顯著提升
如何高效地進行數(shù)組復制？“二維數(shù)組”和“數(shù)組的數(shù)組”有什么區(qū)別？
數(shù)組復制的方法：for  CopyTo()  靜態(tài)CopyTo()  Clone

14.什么是元編程，.NET有哪些元編程的手段和場景？什么是反射？能否舉一些反射的常用場景？有人說反射性能較差，您怎么看待這個問題？有什么辦法可以提高反射的性能嗎？

學著做OA的時候，動態(tài)加載不同的DataProvider（Oracle和Sqlserver），方便，可以隨時替換不用重新編譯程序

15.委托是什么？匿名方法是什么？在C# 3.0中，Lambda表達式是什么？擴展方法是什么？LINQ是什么？您覺得C# 3.0中還有哪些重要的特性，它們帶來了什么優(yōu)勢？BCL中哪些類庫和這些特性有關？您平時最常用哪些？

委托可以把一個方法作為參數(shù)代入另一個方法。
委托可以理解為指向一個函數(shù)的指針。
匿名方法：就是沒有實際方法聲明的委托實例?；蛘哒f，它們的定義是直接內嵌在代碼中的。
Lambda表達式：是比匿名方法更加簡潔的一種匿名函數(shù)語法
委托和事件沒有可比性，因為委托是類型，事件是對象，下面說的是委托的對象（用委托方式實現(xiàn)的事件）和（標準的event方式實現(xiàn)）事件的區(qū)別。事件的內部是用委托實現(xiàn)的。因為對于事件來講，外部只能“注冊自己+=、注銷自己-=”，外界不可以注銷其他的注冊者，外界不可以主動觸發(fā)事件，因此如果用Delegate就沒法進行上面的控制，因此誕生了事件這種語法。事件是用來閹割委托實例的，類比用一個自定義類閹割List。事件只能add、remove自己，不能賦值。事件只能+=、-=，不能= 。事件內部就是一個private的委托和add、remove兩個方法。

16.工作之外您看哪些技術相關的書、網(wǎng)站、社區(qū)、項目等等？

您還接觸哪些.NET以外的技術，能和.NET或.NET中有針對性的部分做個對比嗎？
C#本質論，SQL Server2008實戰(zhàn)，數(shù)據(jù)結構，ASP.NET揭秘，Javascript深入淺出

17.website和webapplication的區(qū)別

1)website修改后不需要重啟即可看到效果，webapplication需要
2）website不分namespace，webapplication有namespace
3）website為了兼容asp轉過來的開發(fā)人員習慣
4）沒有技術上的區(qū)別，調試習慣不同
5）website為每個編譯為一個dll，webapplication生成一個dll
6）不利于工程開發(fā)，比如代碼出錯不容易發(fā)現(xiàn)

18.提交到服務器的表單要設置name，id可以不設置，服務器只用name，Dom用id

19.為了區(qū)分是第一次進入頁面還是點擊提交以后重新進入，form有一個隱藏字段:

<input type=“hidden” name=“ispostback” value=“true”/>,如果從Request中讀取到ispostback=true，說明點擊提交按鈕提交進入ashx，否則是第一次進入ashx

20.Http是請求-響應模型，服務器不會讀取瀏覽器的網(wǎng)頁，能夠得到的就是網(wǎng)頁提交過來的數(shù)據(jù)。

21.get與post提交的比較

Get：通過URL傳遞表單的值（默認），?...&，安全性低，傳遞比較小的數(shù)據(jù)。
Post:傳遞的值隱藏在http報文中，URL中看不到，刷新頁面會彈出提示對話框如果

22. 實現(xiàn)div內文本自增，因為服務器不記得上次給瀏覽器的值是多少，而且不像input那樣會將上次的值重新提交回來，因此瀏覽器需要用一個隱藏的字段將上次的值保存下來

23.ViewState實現(xiàn)原理

非表單元素無法將客戶端的元素值傳遞給服務端，即使是表單元素也只能傳遞value值，對于其他屬性值，比如背景顏色，大小等也是無法傳遞的，因此對于這些值都要存在隱藏字段中。Viewstate是跟頁面相關的，不用的頁面viewstate也會不同，不會相互影響。ViewState對需要PostBack處理的頁面才可能有用，對于新聞展示這類頁面不需要交互，完全可以禁用ViewState來提升性能。如果完全沒有ViewState，則頁面中不能有runat=server的form

24.Cookie

表單是和頁面相關的，只有瀏覽器提交了這些數(shù)據(jù)服務器才能得到，Cookie是和站點相關的，每次向服務器請求的時候除了發(fā)送表單數(shù)據(jù)外，還會將和站點相關的所有Cookie都提交給服務器，這是強制性的
缺點：不能存儲過多的信息，安全性差
針對互聯(lián)網(wǎng)的優(yōu)化：圖片服務器和主站域名不一樣

25.http請求，css，js，圖片，單獨請求，200表示處理成功，301重定向，400錯誤請求
 307臨時重定向，404頁面未找到，403禁止，401未認證，500server內部錯誤，503訪問人數(shù)過多。

26./:網(wǎng)站根目錄，../上一級目錄，./當前目錄，~/應用程序根目錄

27.數(shù)據(jù)庫查詢性能優(yōu)化
1）select中只返回需要的列
2）在減少使用列的同時，考慮減少行，使用where子句
3）只在需要的時候用order by
4）避免在from，where和having子句中隱式數(shù)據(jù)類型的轉換

常見的排序算法：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Sort
{
   public class Sort
   {
      ///<summary>
      /// 插入排序--穩(wěn)定排序
      ///</summary>
      ///<param name="list"></param>
      public static void InsertSort(List<int> list)
      {
         int j, tmp;
         for (int i =1; i < list.Count; i++)
         {
            j = i;
            tmp = list[i];
            while (j >0&& tmp <= list[j -1])
            {
               list[j] = list[j -1];
               j--;
            }
            list[j] = tmp;
         }
      }
      ///<summary>
      /// 希爾排序
      ///</summary>
      ///<param name="list"></param>
      public static void ShellSort(List<int> list)
      {
         int j, tmp;
         int h =3;
         while (h>0)
         {
            for (int i = h; i < list.Count; i++)
            {
               tmp = list[i];
               j = i;
               while ((j > h -1) && tmp < list[j - h])
               {
                  list[j] = list[j - h];
                  j -= h;
               }
               list[j] = tmp;
            }
            h = (h -1) %3;
         }
      }

      ///<summary>
      /// 冒泡排序--穩(wěn)定排序
      ///</summary>
      ///<param name="list"></param>
      public static void BubbleSort(List<int> list)
      {
         if (list ==null|| list.Count <1)
         {
            return;
         }
         int tmp;
         for (int i =0; i < list.Count; i++)
         {
            bool flag=false;
            for (int j = i+1; j <list.Count; j++)
            {
               if (list[i] > list[j])
               {
                  tmp = list[i];
                  list[i] = list[j];
                  list[j] = tmp;
                  flag=true;
               }
               if(flag==false)
               {
                  return;
               }
            }
         }
      }
      ///<summary>
      /// 選擇排序--直接選擇排序
      ///</summary>
      ///<param name="list"></param>
      public static void SelectSort(List<int> list)
      {
         int min, tmp;
         for (int i =0; i < list.Count; i++)
         {
            min = i;
            for (int j = i +1; j < list.Count; j++)
            {
               if (list[j] < list[min])
               {
                  min = j;
               }
            }
            if (i != min)
            {
               tmp = list[i];
               list[i] = list[min];
               list[min] = tmp;
            }
         }
      }

      ///<summary>
      /// 堆排序
      ///</summary>
      ///<param name="list"></param>
      public static void HeapSort(List<int> list)
      {
         int n = list.Count;
         for (int i = n/2-1; i >=0; i--)
         {
            Sift(list, i, n -1);
         }
         for (int i = n -1; i >=1; i--)
         {
            int tmp = list[0];//取堆頂元素
            list[0] = list[i];//讓堆中最后一個元素上移到堆頂位置
            list[i] = tmp;//此時list[i]已不在堆中，用于存放排好序的元素
            Sift(list, 0, i -1);//重新調整堆
         }
      }

      private static void Sift(List<int> list, int low, int high)//建堆過程
      {
         //i為欲調整子樹的根結點的索引號，j為這個結點的左孩子
         int i = low, j =2* i +1;
         int tmp = list[i];//記錄雙親結點的值
         while (j<=high)
         {//如果左孩子小于右孩子，則將欲交換的孩子結點指向右孩子
            if (j < high && list[j] < list[j +1])
            {
               j++;//j指向右孩子
            }
            if (tmp < list[j])//如果雙親結點小于它的孩子結點
            {
               list[i] = list[j];//交換雙親結點和它的孩子結點
               i = j;//以交換后的孩子結點為根，繼續(xù)調整它的子樹
               j =2* i +1;//j此時代表交換后的孩子結點的左孩子
            }
            else//調整完畢
            {
               break;
            }
         }
         list[i] = tmp;//使最初被調整的結點放入正確的位置
      }

      ///<summary>
      /// 歸并排序--穩(wěn)定排序
      ///</summary>
      ///<param name="list"></param>
      ///<param name="low"></param>
      ///<param name="high"></param>
      public static void MergeSort(List<int> list, int low, int high)
      {
         if (low < high)
         {
            int mid = (low + high) /2;
            MergeSort(list, low, mid);
            MergeSort(list, mid +1, high);
            Merge(list, low, mid, high);
         }
      }

      private static void Merge(List<int> list, int low, int mid, int high)
      {//listTmp為臨時存放空間，存放合并后的數(shù)據(jù)
         List<int> listTmp =new List<int>(high - low +1);
         int i = low, j = mid +1, k =0;//k為listTmp的下標
         while (i <= mid && j <= high)
         {
            listTmp[k++] = (list[i] < list[j]) ? list[i++] : list[j++];
         }
         while (i <= mid)
         {
            listTmp[k++] = list[i++];
         }
         while (j <= high)
         {
            listTmp[k++] = list[j++];
         }
         for (i = low, k=0; i <= high;i++,k++ )
         {
            list[i] = listTmp[k];
         }
      }

      ///<summary>
      /// 快速排序
      ///</summary>
      ///<param name="list"></param>
      public static void QuickSort(List<int> list)
      {
         QuickSort(list, 0, list.Count -1);
      }
      public static void QuickSort(List<int> list, int low, int high)
      {
         if (low < high)
         {
            int i = low, j = high, tmp = list[i];
            while (i < j)
            {
               while (i < j && list[j] >= tmp)
               {
                  j--;
               }
               list[i] = list[j];
               while (i < j && list[i] <= tmp)
               {
                  i++;
               }
               list[j] = list[i];
            }
            list[i] = tmp;
            QuickSort(list, low, i -1);
            QuickSort(list, i +1, high);
         }
      }
   }
}

到此這篇關于.NET基礎面試題整理小結的文章就介紹到這了,更多相關.NET面試題內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持腳本之家！

作者：張雪飛
出處：https://zhangxuefei.site

最新評論