DotNet下的问答汇总之一（0-10）

 

[1]             什么是CLR和CTS

CLR（Common language Runtime）公用语言运行时环境，是一种多语言执行环境，支持众多的数据类型和语言特性，从而使得开发过程变得更加简单。运行时环境使用元数据定位并载入类，在内存中展开对象实例，解决方法调用，产生本地代码，强制执行安全性，并建立运行时环境的边界。

CTS（Common Type System）公共类型系统，.Net定义了一个称为通用类型系统的类型标准。任何以.Net为平台目标的语言必须建立它的数据类型与CTS的类型间的映射。所有.Net语言共享这一类型系统，实现他们之间无缝的互操作。

[2]             C#中的数据类型

CLR支持两种数据类型：值类型和引用类型。

值类型包括基本类型（int，char，float等来声明），结构，枚举。

引用类型包括类和委托（delegate声明的一种特殊的类）。

值类型的实例是分配在线程栈上面的，引用类型的实例一般是在进程堆中开辟的。

同时值类型的都可以为null，引用类型的数据不能为null（比如DateTime）

[3]             explicit和implicit的区别

在C语言和C++的时候，还记得类型转换吗？

比如：

 

 float f=100.0；
2 
3 int t=f;
4 
5 int fToi=(int)f;
6 

 

 

在这个小的程序中，浮点数f一种是隐式的转换成了整形，但是两种是两种截然不同的处理方式（隐式转换，显示转换）。

.Net中也同样引入了这样的特性，供开发人员使用。

下面的程序一目了然两者之间的用法：

 

 1 using System;
 2 
 3 using System.Collections.Generic;
 4 
 5 using System.Linq;
 6 
 7 using System.Text;
 8 
 9  
10 
11 namespace DotNetAudition
12 
13 {
14 
15     class eximplicit
16 
17     {
18 
19         private Double dValue;
20 
21  
22 
23         public eximplicit()
24 
25         {
26 
27             //todo:公开的构造函数
28 
29         }
30 
31  
32 
33         private eximplicit(Double m)
34 
35         {
36 
37             dValue = m;
38 
39         }
40 
41  
42 
43         public static implicit operator eximplicit(Double m)
44 
45         {
46 
47             return new eximplicit(m);
48 
49         }
50 
51  
52 
53         public static explicit operator double(eximplicit d)
54 
55         {
56 
57             return d.dValue;
58 
59         }
60 
61  
62 
63         public override string ToString()
64 
65         {
66 
67             return String.Format("{0}", this.dValue);
68 
69             //return base.ToString();
70 
71         }
72 
73     }
74 
75 }
76 

 

 

调用方法：

 

 1 eximplicit d = 1.23;
 2 
 3 Console.WriteLine(d);
 4 
 5  
 6 
 7 double dD = (double)d;
 8 
 9 Console.WriteLine(dD);
10 
11 Console.ReadKey();
12 

 

 

[4]             .Net中引用的函数调用方式

这是一个基础的问题，在C#中开发人员考虑到函数调用的大数据量的复制效率，可以选择用引用类型来达到提高函数调用的问题。

函数的调用采用ref声明的方式：

 

 1 /*
 2 
 3 *    测试引用效果
 4 
 5 */
 6 
 7 private static void TestRef()
 8 
 9 {
10 
11 int x = 20;
12 
13 int y = 40;
14 
15 Plus(ref x, y);
16 
17 Console.WriteLine("x={0};y={1}", x, y);
18 
19 }
20 
21 /*
22 
23       * 测试引用类型传值的效果
24 
25       */
26 
27         private static void Plus(ref int x,int y)
28 
29         {
30 
31             x = x + y;
32 
33             y = x + y;
34 
35         }
36 

 

 

[5]             .Net中==和equals的异同

对于预定义的值类型，如果操作数的值相等，则相等运算符 (==) 返回 true，否则返回 false。对于 string 以外的引用类型，如果两个操作数引用同一个对象，则 == 返回 true。对于 string 类型，== 比较字符串的值

[6]             Assembly.LoadFrom()和Assembly.LoadFile()异同

1、Assembly.LoadFile只载入相应的dll文件，比如Assembly.LoadFile("a.dll")，则载入a.dll，假如a.dll中引用了b.dll的话，b.dll并不会被载入。

Assembly.LoadFrom则不一样，它会载入dll文件及其引用的其他dll，比如上面的例子，b.dll也会被载入。

2、用Assembly.LoadFrom载入一个Assembly时，会先检查前面是否已经载入过相同名字的Assembly，比如a.dll有两个版本(版本1在目录1下，版本2放在目录2下)，程序一开始时载入了版本1，当使用Assembly.LoadFrom("2\\a.dll")载入版本2时，不能载入，而是返回版本1。

[7]             关键字internal protected的用法

internal限制访问域为类所在的程序内，protected限制类的访问域在本身或者继承类中。

而internal protected得组合修饰效果是扩展的关系：

internal protected==internal || protected

[8]             虚函数在.Net中可以肆意使用吗？

虚函数的引入带来的动态绑定，让开发人员能更加灵活的方式处理事务。但同时也引入了vtable的概念（虚函数表）。它是根据某个指针定位到函数的真实地址。期间需要一次地址的转换：间接地址到真实物理地址转换，同时带来的效率的损失。

虚函数效率的低下同时也跟CPU的预取指令密切相关，在编译期间，相对地址是确定的，如果通过vtable表动态的运行时绑定，会造成查找vtable的时间开销，关键在于这个函数地址是动态的，在查找跳转地址后，CPU预取的流水线指令基本上都立刻失效，预测失败的代价也是不可忽视的。

[9]             有必要使用静态构造函数吗？

大家都知道，构造函数是在类被实例化的时候首先调用的。那么静态函数在期间起到什么作用呢？

下面我们来写一个程序验证下：

 

 1 using System;
 2 
 3 using System.Collections.Generic;
 4 
 5 using System.Linq;
 6 
 7 using System.Text;
 8 
 9  
10 
11 namespace DotNetAudition
12 
13 {
14 
15     class StaticConstruction
16 
17     {
18 
19         public static int value;
20 
21  
22 
23         public static int Value
24 
25         {
26 
27             get { return StaticConstruction.value; }
28 
29             set { StaticConstruction.value = value; }
30 
31         }
32 
33  
34 
35         public StaticConstruction()
36 
37         {
38 
39             //
40 
41             value++;
42 
43         }
44 
45  
46 
47         static StaticConstruction()
48 
49         {
50 
51             value++;
52 
53         }
54 
55     }
56 
57 }
58 

 

 

调用代码：

 

 StaticConstruction sc = new StaticConstruction();
2 
3 Console.WriteLine("{0}", StaticConstruction.Value);
4 
5 StaticConstruction scc = new StaticConstruction();
6 
7 Console.WriteLine("{0}", StaticConstruction.Value);
8 

 

 

输出：2 3

很明显，静态构造函数在第一个对象对实例化的时候调用了一次，第二次就忽略了这个静态构造函数。

所以static的构造函数一般用于初始化static的静态变量，只有初始化static成员变量的时候，static类构造函数就会发挥应有的作用。

[10]        私有构造函数又有什么用呢？

经常在.Net下开发的开发人员一般知道，构造函数如果设置为private，那么在实例化这个对象的时候，会提示构造函数权限不够。同时我们在写程序的时候可以利用这么一个特性，用于对对象的非实例化的控制。

如果一个类中仅仅提供了静态函数以及静态成员函数，那么这样的类一般起到的全局数据共享的功能，或者单一的函数功能。

此时如果我们将类的构造函数设置为private，是不是恰恰给我们这个类起到了保障作用？一旦被实例化，编译器机会报错，告诉我们此类不能被实例化？

其次：静态构造函数还可以用于单例模型中（singleton model）。

类静态函数调用private构造函数对此类进行单例的构造，而从而保证不能在其他途径下的实例下对象。

用处是不是很大，而你有一种差异的眼睛来审视它？