C#学习基础概念二十五问(3)

19.别名指示符是什么？

答：

通过别名指示符我们可以为某个类型起一个别名

主要用于解决两个命名空间内有同名类型的冲突或避免使用冗余的命名空间

别名指示符只在一个单元文件内起作用

示例：

 

 1Class1.cs:
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Text;
 6 
 7namespace com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01
 8{
 9    class Class1
10    {
11        public override string ToString()
12        {
13            return "com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01's Class1";
14        }
15    }
16}
17Class2.cs
18
19using System;
20using System.Collections.Generic;
21using System.Text;
22 
23namespace com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02
24{
25    class Class1
26    {
27        public override string ToString()
28        {
29            return "com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02's Class1";
30        }
31    }
32}
33主单元（Program.cs）：
34
35using System;
36using System.Collections.Generic;
37using System.Text;
38 
39//使用别名指示符解决同名类型的冲突
40using Lib01Class1 = com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01.Class1;
41using Lib02Class2 = com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02.Class1;
42 
43namespace Example19
44{
45    class Program
46    {
47        static void Main(string[] args)
48        {
49            Lib01Class1 tmpObj1 = new Lib01Class1();
50            Lib02Class2 tmpObj2 = new Lib02Class2();
51 
52            Console.WriteLine(tmpObj1);
53            Console.WriteLine(tmpObj2);
54 
55            Console.ReadLine();
56        }
57    }
58}
59结果：
60com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01's Class1
61com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02's Class1 
62
63 
64
65

复制代码

20.如何释放非托管资源？

答：

 .NET 平台在内存管理方面提供了GC（GarbageCollection），负责自动释放托管资源和内存回收的工作，但它无法对非托管资源进行释放，这时我们必须自己提供方法来释放对象内分配的非托管资源，比如你在对象的实现代码中使用了一个COM对象

最简单的办法，可以通过实现protected voidFinalize()（析构函数会在编译时变成这个东东）来释放非托管资源，因为GC在释放对象时会检查该对象是否实现了Finalize() 方法，如果是则调用它。但，据说这样会降低效率。。。

有一种更好的，那就是通过实现一个接口显式的提供给客户调用端手工释放对象的方法，而不是傻傻的等着GC来释放我们的对象（何况效率又那么低）

System 命名空间内有一个 IDisposable 接口，拿来做这事非常合适，就省得我们自己再声明一个接口了

另外补充一句，这种实现并不一定要使用了非托管资源后才用，如果你设计的类会在运行时有大些的实例（象 GIS中的Geometry），为了优化程序性能，你也可以通过实现该接口让客户调用端在确认不需要这些对象时手工释放它们

示例：

 

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4 
 5namespace Example20
 6{
 7    class Program
 8    {
 9        class Class1 : IDisposable
10        {
11            //析构函数，编译后变成 protected void Finalize()，GC会在回收对象前会调用调用该方法
12            ~Class1()
13            {
14                Dispose(false);
15            }
16 
17            //通过实现该接口，客户可以显式地释放对象，而不需要等待GC来释放资源，据说那样会降低效率
18            void IDisposable.Dispose()
19            {
20                Dispose(true);
21            }
22 
23            //将释放非托管资源设计成一个虚函数，提供在继承类中释放基类的资源的能力
24            protected virtual void ReleaseUnmanageResources()
25            {
26                //Do something
27            }
28 
29            //私有函数用以释放非托管资源
30            private void Dispose(bool disposing)
31            {
32                ReleaseUnmanageResources();
33 
34                //为true时表示是客户显式调用了释放函数，需通知GC不要再调用对象的Finalize方法
35                //为false时肯定是GC调用了对象的Finalize方法，所以没有必要再告诉GC你不要调用我的Finalize方法啦
36                if (disposing)
37                {
38                    GC.SuppressFinalize(this);
39                }
40            } 
41        }
42        static void Main(string[] args)
43        {
44            //tmpObj1没有手工释放资源，就等着GC来慢慢的释放它吧
45            Class1 tmpObj1 = new Class1();
46 
47            //tmpObj2调用了Dispose方法，传说比等着GC来释放它效率要调一些
48            //个人认为是因为要逐个对象的查看其元数据，以确认是否实现了Dispose方法吧
49            //当然最重要的是我们可以自己确定释放的时间以节省内存，优化程序运行效率
50            Class1 tmpObj2 = new Class1();
51            ((IDisposable)tmpObj2).Dispose();
52        }
53    }
54}
55
56

复制代码

21.P/Invoke是什么？

答：

在受控代码与非受控代码进行交互时会产生一个事务（transition） ，这通常发生在使用平台调用服务（PlatformInvocation Services），即P/Invoke

如调用系统的 API 或与 COM 对象打交道，通过 System.Runtime.InteropServices命名空间

虽然使用 Interop 非常方便，但据估计每次调用事务都要执行 10 到 40条指令，算起来开销也不少，所以我们要尽量少调用事务

如果非用不可，建议本着一次调用执行多个动作，而不是多次调用每次只执行少量动作的原则

 

22.StringBuilder 和 String 的区别？

答：

String 虽然是一个引用类型，但在赋值操作时会产生一个新的对象，而 StringBuilder 则不会

所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder，不要使用 String

示例：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4 
 5namespace Example22
 6{
 7    class Program
 8    {
 9        static void Main(string[] args)
10        {
11            const int cycle = 100000;
12 
13            long vTickCount = Environment.TickCount;
14            String str = null;
15            for (int i = 0; i < cycle; i++)
16                str += i.ToString();
17            Console.WriteLine("String: {0} MSEL", Environment.TickCount - vTickCount);
18 
19            vTickCount = Environment.TickCount;
20            //看到这个变量名我就生气，奇怪为什么大家都使它呢？ ：）
21            StringBuilder sb = new StringBuilder();
22            for (int i = 0; i < cycle; i++)
23                sb.Append(i);
24            Console.WriteLine("StringBuilder: {0} MSEL", Environment.TickCount - vTickCount);
25 
26            Console.ReadLine();
27        }
28    }
29}
30结果：
31String: 102047 MSEL
32StringBuilder: 46 MSEL
33
34

复制代码

23.explicit 和 implicit 的含义？

答：

explicit 和 implicit 属于转换运算符，如用这两者可以让我们自定义的类型支持相互交换

explicti 表示显式转换，如从 A -> B 必须进行强制类型转换（B =(B)A）

implicit 表示隐式转换，如从 B -> A 只需直接赋值（A = B）

隐式转换可以让我们的代码看上去更漂亮、更简洁易懂，所以最好多使用 implicit运算符。不过！如果对象本身在转换时会损失一些信息（如精度），那么我们只能使用 explicit运算符，以便在编译期就能警告客户调用端

示例：

 

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4 
 5namespace Example23
 6{
 7    class Program
 8    {
 9        //本例灵感来源于大话西游经典台词“神仙？妖怪？”--主要是我实在想不出什么好例子了
10        class Immortal
11        {
12            public string name;
13            public Immortal(string Name)
14            {
15                name = Name;
16            }
17            public static implicit operator Monster(Immortal value)
18            {
19                return new Monster(value.name + "：神仙变妖怪？偷偷下凡即可。。。");
20            }
21        }
22        class Monster
23        {
24            public string name;
25            public Monster(string Name)
26            {
27                name = Name;
28            }
29            public static explicit operator Immortal(Monster value)
30            {
31                return new Immortal(value.name + "：妖怪想当神仙？再去修炼五百年！");
32            }
33        }
34        static void Main(string[] args)
35        {
36            Immortal tmpImmortal = new Immortal("紫霞仙子");
37            //隐式转换
38            Monster tmpObj1 = tmpImmortal;
39            Console.WriteLine(tmpObj1.name);
40 
41            Monster tmpMonster = new Monster("孙悟空");
42            //显式转换
43            Immortal tmpObj2 = (Immortal)tmpMonster;
44            Console.WriteLine(tmpObj2.name);
45 
46            Console.ReadLine();
47        }
48    }
49}
50结果：
51紫霞仙子：神仙变妖怪？偷偷下凡即可。。。
52孙悟空：妖怪想当神仙？再去修炼五百年！ 
53
54

复制代码

 
24.params 有什么用？

答：

params 关键字在方法成员的参数列表中使用，为该方法提供了参数个数可变的能力

它在只能出现一次并且不能在其后再有参数定义，之前可以

示例：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4 
 5namespace ConsoleApplication1
 6{
 7    class App
 8    {
 9        //第一个参数必须是整型，但后面的参数个数是可变的。
10        //而且由于定的是object数组，所有的数据类型都可以做为参数传入
11        public static void UseParams(int id, params object[] list)
12        {
13            Console.WriteLine(id);
14            for (int i = 0; i < list.Length; i++)
15            {
16                Console.WriteLine(list[i]);
17            }
18        }
19 
20        static void Main()
21        {
22            //可变参数部分传入了三个参数，都是字符串类型
23            UseParams(1, "a", "b", "c");
24            //可变参数部分传入了四个参数，分别为字符串、整数、浮点数和双精度浮点数数组
25            UseParams(2, "d", 100, 33.33, new double[] { 1.1, 2.2 });
26 
27            Console.ReadLine();
28        }
29    }
30}
31结果：
321
33a
34b
35c
362
37d
38100
3933.33
40System.Double[] 
41
42

复制代码

25.什么是反射？

答：

反射，Reflection，通过它我们可以在运行时获得各种信息，如程序集、模块、类型、字段、属性、方法和事件

通过对类型动态实例化后，还可以对其执行操作

一般用于插件式框架程序和设计模式的实现，当然反射是一种手段可以充分发挥其能量来完成你想做的任何事情（前面好象见过一位高人用反射调用一个官方类库中未说明的函数。。。）

示例：

 

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4 
 5namespace Example25Lib
 6{
 7    public class Class1
 8    {
 9        private string name;
10        private int age;
11 
12        //如果显式的声明了无参数构造函数，客户端只需要用程序集的CreateInstance即可实例化该类
13        //在此特意不实现，以便在客户调用端体现构造函数的反射实现
14        //public Class1()
15        //{
16        //}
17        public Class1(string Name, int Age)
18        {
19            name = Name;
20            age = Age;
21        }
22        public void ChangeName(string NewName)
23        {
24            name = NewName;
25        }
26        public void ChangeAge(int NewAge)
27        {
28            age = NewAge;
29        }
30        public override string ToString()
31        {
32            return string.Format("Name: {0}, Age: {1}", name, age);
33        }
34    }
35}
36

复制代码

反射实例化对象并调用其方法，属性和事件的反射调用略去

 

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4 
 5//注意添加该反射的命名空间
 6using System.Reflection;
 7 
 8namespace Example25
 9{
10    class Program
11    {
12        static void Main(string[] args)
13        {
14            //加载程序集
15            Assembly tmpAss = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "Example25Lib.dll");
16 
17            //遍历程序集内所有的类型，并实例化
18            Type[] tmpTypes = tmpAss.GetTypes();
19            foreach (Type tmpType in tmpTypes)
20            {
21                //获取第一个类型的构造函数信息
22                ConstructorInfo[] tmpConsInfos = tmpType.GetConstructors();
23                foreach (ConstructorInfo tmpConsInfo in tmpConsInfos)
24                {
25                    //为构造函数生成调用的参数集合
26                    ParameterInfo[] tmpParamInfos = tmpConsInfo.GetParameters(); 
27                    object[] tmpParams = new object[tmpParamInfos.Length];
28                    for (int i = 0; i < tmpParamInfos.Length; i++)
29                    {
30                        tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
31                        if (tmpParamInfos[i].ParameterType.FullName == "System.String")
32                        {
33                            tmpParams[i] = "Clark";
34                        }
35                    }
36 
37                    //实例化对象
38                    object tmpObj = tmpConsInfo.Invoke(tmpParams);
39                    Console.WriteLine(tmpObj);
40 
41                    //获取所有方法并执行
42                    foreach (MethodInfo tmpMethod in tmpType.GetMethods())
43                    {
44                        //为方法的调用创建参数集合
45                        tmpParamInfos = tmpMethod.GetParameters();
46                        tmpParams = new object[tmpParamInfos.Length];
47                        for (int i = 0; i < tmpParamInfos.Length; i++)
48                        {
49                            tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
50                            if (tmpParamInfos[i].ParameterType.FullName == "System.String")
51                            {
52                                tmpParams[i] = "Clark Zheng";
53                            }
54                            if (tmpParamInfos[i].ParameterType.FullName == "System.Int32")
55                            {
56                                tmpParams[i] = 27;
57                            }
58                        }
59                        tmpMethod.Invoke(tmpObj, tmpParams);
60                    }
61 
62                    //调用完方法后再次打印对象，比较结果
63                    Console.WriteLine(tmpObj);
64                }
65            }
66 
67            Console.ReadLine();
68        }
69    }
70}
71结果：
72Name: Clark, Age: 0
73Name: Clark Zheng, Age: 27 
74
75

复制代码