解析关于实例化顺序的C#面试题

最近找工作，面试了几家公司，其中有一家公司的面试题给我印象很深，不久前在博客园看过类似的题目，但这次的更复杂，题目如下：

员工经过长期磨合与沉淀，具备了协作精神，得以通过团队的力量开发出优质的产品。创新互联坚持“专注、创新、易用”的产品理念，因为“专注所以专业、创新互联网站所以易用所以简单”。公司专注于为企业提供网站设计、成都网站制作、微信公众号开发、电商网站开发，小程序设计，软件按需定制网站等一站式互联网企业服务。

 
 
 
    
  
  
  
  1. public class BaseA  
    2.   
  
  
  2. {  
    3.   
  
  
  3.     public static MyTest a1 = new MyTest("a1");  
    4.   
  
  
  4.     public MyTest a2 = new MyTest("a2");  
    5.   
  
  
  5.     static BaseA()  
    6.   
  
  
  6.    {  
    7.   
  
  
  7.         MyTest a3 = new MyTest("a3");  
    8.   
  
  
  8.     }  
    9.   
  
  
  9.     public BaseA()  
    10.   
  
  
  10.     {  
    11.   
  
  
  11.         MyTest a4 = new MyTest("a4");  
    12.   
  
  
  12.     }  
    13.   
  
  
  13.     public virtual void MyFun()  
    14.   
  
  
  14.     {  
    15.   
  
  
  15.         MyTest a5 = new MyTest("a5");  
    16.   
  
  
  16.     }  
    17.   
  
  
  17. }  
    18.   
  
  
  18.  
    19.   
  
  
  19. public class BaseB : BaseA  
    20.   
  
  
  20. {  
    21.   
  
  
  21.     public static MyTest b1 = new MyTest("b1");  
    22.   
  
  
  22.     public MyTest b2 = new MyTest("b2");  
    23.   
  
  
  23.     static BaseB()  
    24.   
  
  
  24.    {  
    25.   
  
  
  25.         MyTest b3 = new MyTest("b3");  
    26.   
  
  
  26.     }  
    27.   
  
  
  27.     public BaseB()  
    28.   
  
  
  28.     {  
    29.   
  
  
  29.         MyTest b4 = new MyTest("b4");  
    30.   
  
  
  30.     }  
    31.   
  
  
  31.  
    32.   
  
  
  32.     public new void MyFun()  
    33.   
  
  
  33.     {  
    34.   
  
  
  34.         MyTest b5 = new MyTest("b5");  
    35.   
  
  
  35.     }  
    36.   
  
  
  36. }  
    37.   
  
  
  37.  
    38.   
  
  
  38. static class Program  
    39.   
  
  
  39. {  
    40.   
  
  
  40.     static void Main()  
    41.   
  
  
  41.     {  
    42.   
  
  
  42.         BaseB baseb = new BaseB();  
    43.   
  
  
  43.         baseb.MyFun();  
    44.   
  
  
  44.     }  
    45.   
  
  
  45. }  
    46.   
  
  
  46. public class MyTest  
    47.   
  
  
  47. {  
    48.   
  
  
  48.     public MyTest(string info)  
    49.   
  
  
  49.     {  
    50.   
  
  
  50.         Console.WriteLine(info);  
    51.   
  
  
  51.     }  
    52.   
  
  
  52. } 
    53.

最后的问题是：请写出Main（）方法中，a1-a5，b1-b5这十个类实例化的顺序。（MyTest类是我自己添的，方便查看结果，原题是是实例化一个object类。）

不知道园子里有多少人能胸有成竹的写出正确答案，反正我是答错了，正确答案是：

b1
b3
b2
a1
a3
a2
a4
b4
b5

题目中涉及到的知识点

虽然题目没做对了，但要知道自己为什么会做错，这样才会有所提高，趁着端午的假期，我把这个面试题涉及到的知识点都梳理了一遍，要点如下：

内联（inline）方式初始化字段。

类型构造器（静态构造函数）的执行时间。

C#中基类和子类实例化的顺序。

new修饰符的作用。

内联方式初始化字段

这个知识点在《CLR via C#》书中有讲到，所谓内联方式，就是初始化字段的一种简化语法。来看示例代码：

 
 
 
    
  
  
  
  1. public class SomeType  
    2.   
  
  
  2. {  
    3.   
  
  
  3.     public int m_x = 5;  
    4.   
  
  
  4. } 
    5.

这种在类中声明变量时进行赋值的方式就叫做内联，大致等效于下面的代码：

 
 
 
    
  
  
  
  1. public class SomeType  
    2.   
  
  
  2. {  
    3.   
  
  
  3.     public int m_x;  
    4.   
  
  
  4.     public SomeType()  
    5.   
  
  
  5.     {  
    6.   
  
  
  6.         m_x = 5;  
    7.   
  
  
  7.     }  
    8.   
  
  
  8. } 
    9.

之所以说“大致等效”，因为两者的执行顺序上略有差异，编译器会首先生成内联方式的代码，然后再调用构造函数。

比如，下面的代码，最后m_x的结果就为10。

 
 
 
    
  
  
  
  1. public class SomeType  
    2.   
  
  
  2. {  
    3.   
  
  
  3.     //先执行  
    4.   
  
  
  4.     public int m_x=5;  
    5.   
  
  
  5.     public SomeType()  
    6.   
  
  
  6.     {  
    7.   
  
  
  7.         //后执行  
    8.   
  
  
  8.         m_x = 10;  
    9.   
  
  
  9.     }  
    10.   
  
  
  10. } 
    11.

类型构造器的执行

所谓类型构造器也就是我们熟知的静态构造方法，在我们编写的类中，都会有一个默认的静态无参构造方法，跟无参实例构造方法一样是默认存在的。

每当我们对一个类创建第一个实例或访问静态字段前，JIT编译器就会调用该类的静态构造方法。当然，静态变量也可以使用上面说的内联方法进行赋值。

这里可以看出，当第一次实例化某个类时，会首先调用该类的静态构造方法。

C#中基类和子类实例化的顺序

这个知识点比较简单，那就是在调用子类实例构造方法之前会调用基类的实例构造方法。从面试题的结果可以看出，基类的构造方法又比子类的静态构造函数晚一些，此处因个人能力有限，我也没办法从更底层的角度去分析原理，只能暂且记住吧。

new修饰符的作用

我看过不少关于new以修饰符的形式用在方法声明中的题目，关于new的用法在MSDN上也都查的到，官方说法是“显式隐藏从基类继承的成员”。

我个人的理解比较简单：当子类中，一个方法的签名（指参数，方法名，返回值）与基类的一个方法相同，通过加入new修饰符，可以让子类不做更改的去使用该方法。

说到底，new修饰符就是让两个不相关的同名方法同时存在而已。（这里同名指相同的方法签名）

最后

回头想想，其实在我日常的项目开发中，多多少少都有涉及到这几个问题，只是平时不注意，没有深究吃透，写此文也是勉励自己以后要重视基础，不再浮躁。

原文链接：http://www.cnblogs.com/hkncd/archive/2011/06/05/2073404.html

网页名称：解析关于实例化顺序的C#面试题
网址分享：http://www.shufengxianlan.com/qtweb/news47/554997.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

面包屑导航知识

分类信息网站

专业网站建设　　 　内江服务器托管　　 　微信网站开发　　 　ssl证书申请　　 　温江网站设计　　 　温江电信机房　　 　重庆联通机房托管　　 　app网站建设　　 　成都网站制作　　 　成都网络营销　　 　网站制作公司　　 　成都做商城网站　　 　成都圣月窗帘　　 　西部信息中心　　 　小程序　　 　成都移动服务器托管　　 　定制网站开发　　 　无边发光字厂家　　 　成都商城网站建设　　 　软文发稿