C#基础概念- 做自己想做的事。尽自己{zd0}的努力。

1. 面向对象的思想主要包括：继承多态封装

● 封装：用抽象的数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型内部。

● 继承：子类拥有父类的所有数据和操作。

● 多态：一个程序中同名的不同方法共存的情况。

有两种形式的多态– 重载与重写。

2. 什么是装箱和拆箱

装箱（boxing)和拆箱(unboxing)机制使得在C#类型系统中，任何值类型、引用类型和object（对象）类型之间进行转换，这种转换称为绑定连接。简单地说，有了装箱和拆箱的概念，对任何类型的值来说最终都可看作是object类型。 1、装箱转换

含义：将一个值类型隐式地转换成一个object类型，或把这个值类型转换成一个被该值类型应用的接口类型，把一个值类型的值装箱，就是创建一个object实例并将值复制给这个object

如： int I=10; object obj=I; 也可用显式的方法进行装箱操作： object obj=（object)I;

2、拆箱转换

和装箱相反，拆箱转换是指将一个对象类型显式地转换成一个值类型，或将一个接口类型显式地转换成一个执行该接口的值类型。

过程分两步：

首先，检查这个对象实例，看它是否为给定的值类型的装箱值

然后，把这个实例的值拷贝给值类型的变量。如：

int I=10;

object obj=I;

Int j=(int)obj;

3. 重载与override

重载是指针对所继承下来到方法，重新设计其处理方式，为将来原本处理方式覆盖过去。

在派生类要覆盖的方法前加override修饰，而基类的同名方法前加virtual修饰。这样就能实现多态。多态指一个程序中同名的不同方法共存的情况。有两种形式的多态– 重载与重写。

4. 值类型和引用类型
● 值类型的变量本身包含他们的数据，而引用类型的变量包含的是指向包含数据的内存块的引用或叫句柄。

● 值类型变量存储在堆栈。每个程序在执行时都有自己的堆栈，其他程序不能访问。

● 引用类型存储在堆。引用类型存贮实际数据的引用值的地址。

● C#中的引用类型有4种

● （类、代表、数组、接口）

5. 理解委托

代理是C#中的一种新的类型，要把方法作为参数传递给其他方法时，需要用到代理。

方法通过参数获得外界传递给他的数据，并对这些数据进行一定的操作。

C＃通过代理机制来实现，通过参数把一个方法传递给另外一个方法。

代理四步曲：

a．生成自定义代理类：delegate int MyDelegate();

b．用New运算符实例化代理类：

MyDelegate d = new MyDelegate(MyClass.MyMethod);

c．{zh1}通过实例对象调用方法：int ret = d();

d. 在程序中像调用方法一样应用代理的实例对象调用它指向的方法。 delegate int d(int I);

6. C#中的接口和类

什么是类?类可以这么理解.类就是功能的集合.类也可以看做是实现一种功能的集合或者方法..接口的概念:什么是接口?接口可以理解为,对类的规定,对类的约束,甚至对整个项目的约束. 种模版，定义了对象必须实现的方法，其目的就是让这些方法可以作为接口实例被引用。接口不能被实例化。接口是负责功能的定义，项目中通过接口来规范类，操作类以及抽象类的概念！而类是负责功能的具体实现！在类中也有抽象类的定义，抽象类与接口的区别在于：抽象类是一个不xx的类，类里面有抽象的方法，属性，也可以有具体的方法和属性，需要进一步的专业化。但接口是一个行为的规范，里面的所有东西都是抽象的！一个类只可以继承一个基类也就是父类，但可以实现多个接口

7. net中读写数据库需要用到的类

Connection DataAdapter DataSet Command DataReader

8. 理解.net中的垃圾回收机制

如果发现内存不够,则垃圾回收器,将全部对象作为无效对象(被回收对象),然后先将全局变量,static,处于活动中的局部变量,以及当前CG指针指向的对象放入一个表中.然后

会搜索新列表中的对象所引用的对象.加入列表中,其他没有被加入列表的对象都会被回收.

非托管对象要记得释放资源就行了吧.

9. .net的错误处理机制

错误的处理顺序:finally先,catch次之,{zh1}退会try代码..取消此次操作.返回catch中的异常信息.当然,你也可以定制自己的错误处理机制...如果你的异常处理中包含finally块.则此finally无论是否发生异常始终会被执行...

10. c#中的using和new

using 的用途是为某个namespace建立别名，或者引用存在系统中的其它namespace.

New 用来创建实例，或者覆写方法。

11. 类和结构的区别

1. 值类型与引用类型

● 结构是值类型：值类型在堆栈上分配地址

● 类是引用类型：引用类型在堆上分配地址

2．继承性

● 结构：不能从另外一个结构或者类继承，本身也不能被继承，虽然没有明确sealed声明，可结构是隐式的sealed .

● 类：xx可扩展的，除非显式声明sealed，否则类可以继承其他类和接口，自身也能被继承。

注：虽然结构不能被继承，可结构能够继承接口，方法和类继承接口一样。

3．内部结构的区别：

结构：

● 没有默认的构造函数，可以添加构造函数

● 没有析构函数

● 没有 abstract 和 sealed(因为不能继承)

● 不能有protected 修饰符

● 可以不用new 初始化

● 在结构中初始化实例字段是错误的

类：

● 有默认的构造函数

● 有析构函数

● 可以使用 abstract 和 sealed

● 有protected 修饰符

● 必须使用new 初始化

12. CLR

公共语言运行时（Common Language Runtime,CLR）,提供了一个可靠而完善的多语言运行环境。CLR是一个软件引擎，用于加载应用程序、检查错误、进行安全许可认证、执行和清空内存。它属于纯动态运行时的一种，它的主要组成部分是虚拟执行引擎VEE（Virtual Execution Enging），它可以打破语言和平台的限制。

13. C#的优点

1. C#中指针已经消失. 允许对原始指针的有限制的使用.

2. 基于.NET平台的,继承了自动内存管理和垃圾回收的特点.

3. C#拥有内建的支持来将任何组件转换成一个web service,运行在任何平台上的任何应用程序都可以通过互联网来使用这个服务.

4. 面向对象的

14. 面向对象编程的三大原则

● 继承：都支持类的单一继承，但类可以实现多个接口。所有类都从一个公共的基类继承。

● 封装与可见性：都可决定类成员是否可见。除了C#的internal访问修饰符外，两者可见性机制非常相似

● 多态性：Java和C#都支持某些形式的多态性机制，且两者实现方法非常类似。

15. C#5种类型的可访问性

● public：成员可以从任何代码访问。

● protected：成员只能从派生类访问。

● internal：成员只能从同一程序集的内部访问。

● protected internal：成员只能从同一程序集内的派生类访问。

● private：成员只能在当前类的内部访问。

16. C#代码在执行前要编译为中间语言，中间语言的主要特征：

● 面向对象和使用接口

● 值类型和引用类型之间的巨大差别

● 强数据类型

● 使用异常来处理错误

● 使用属性(attribute)

17. C#中引用类型

（类、代表、数组、接口）

18. 对象间可能存在的三种关系

●聚合，一个（较复杂的）对象由其他若干（较简单的）对象作为其构成部分，称作聚合。

●关联，对象之间的静态联系（即通过对象属性体现的联系）称作关联。

●继承。

==================================================================================

当初学 C# 时是找个人大概问了一下数据类型和分支语句就开始做项目了。这两天又全面的看了一下相关的基础知识（学而时习之嘛），总结了25个问题：

1.静态成员和非静态成员的区别？
2.const 和 static readonly 区别？
3.extern 是什么意思？
4.abstract 是什么意思？
5.internal 修饰符起什么作用？
6.sealed 修饰符是干什么的？
7.override 和 overload 的区别？
8.什么是索引指示器？
9.new 修饰符是起什么作用？
10.this 关键字的含义？
11.可以使用抽象函数重写基类中的虚函数吗？
12.密封类可以有虚函数吗？
13.什么是属性访问器？
14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？
15.接口可以包含哪些成员？
16.类和结构的区别？
17.接口的多继承会带来哪些问题？
18.抽象类和接口的区别？
19.别名指示符是什么？
20.如何手工释放资源？
21.P/Invoke是什么？
22.StringBuilder 和 String 的区别？
23.explicit 和 implicit 的含义？
24.params 有什么用？
25.什么是反射？

以下是我做的一份参考答案（C# 语言范畴之内），如果有不准确、不全面的，欢迎各位朋友指正！

1.静态成员和非静态成员的区别？

答：

静态变量使用 static 修饰符进行声明，在类被实例化时创建，通过类进行访问

不带有 static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问

一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值

静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等

示例：

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

namespace Example01
{
    class Program
    {
        class Class1
        {
            public static String staticStr = "Class";
            public String notstaticStr = "Obj";
        }
        static void Main(string[] args)
        {
            //静态变量通过类进行访问，该类所有实例的同一静态变量都是同一个值
            Console.WriteLine("Class1's staticStr: {0}", Class1.staticStr);

            Class1 tmpObj1 = new Class1();
            tmpObj1.notstaticStr = "tmpObj1";
            Class1 tmpObj2 = new Class1();
            tmpObj2.notstaticStr = "tmpObj2";

            //非静态变量通过对象进行访问，不同对象的同一非静态变量可以有不同的值
            Console.WriteLine("tmpObj1's notstaticStr: {0}", tmpObj1.notstaticStr);
            Console.WriteLine("tmpObj2's notstaticStr: {0}", tmpObj2.notstaticStr);

            Console.ReadLine();
        }
    }
}
结果：
Class1's staticStr: Class
tmpObj1's notstaticStr: tmpObj1
tmpObj2's notstaticStr: tmpObj2

2.const 和 static readonly 区别？

答：

const

用 const 修饰符声明的成员叫常量，是在编译期初始化并嵌入到客户端程序

static readonly

用 static readonly 修饰符声明的成员依然是变量，只不过具有和常量类似的使用方法：通过类进行访问、初始化后不可以修改。但与常量不同的是这种变量是在运行期初始化

示例：

测试类：

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

namespace Example02Lib
{
    public class Class1
    {
        public const String strConst = "Const";
        public static readonly String strStaticReadonly = "StaticReadonly";
        //public const String strConst = "Const Changed";
        //public static readonly String strStaticReadonly = "StaticReadonly Changed";
    }
}

客户端代码：

using System;
using System.Collections.Generic;
using System.Text;
using Example02Lib;

namespace Example02
{
    class Program
    {
        static void Main(string[] args)
        {
            //修改Example02中Class1的strConst初始值后，只编译Example02Lib项目
            //然后到资源管理器里把新编译的Example02Lib.dll拷贝Example02.exe所在的目录，执行Example02.exe
            //切不可在IDE里直接调试运行因为这会重新编译整个解决方案！！

            //可以看到strConst的输出没有改变，而strStaticReadonly的输出已经改变
            //表明Const变量是在编译期初始化并嵌入到客户端程序，而StaticReadonly是在运行时初始化的
            Console.WriteLine("strConst : {0}", Class1.strConst);
            Console.WriteLine("strStaticReadonly : {0}", Class1.strStaticReadonly);

            Console.ReadLine();
        }
    }
}
结果：
strConst : Const
strStaticReadonly : StaticReadonly

修改后的示例：

测试类：

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

namespace Example02Lib
{
    public class Class1
    {
        //public const String strConst = "Const";
        //public static readonly String strStaticReadonly = "StaticReadonly";
        public const String strConst = "Const Changed";
        public static readonly String strStaticReadonly = "StaticReadonly Changed";
    }
}
结果

strConst : Const
strStaticReadonly : StaticReadonly Changed

3.extern 是什么意思？

答：

extern 修饰符用于声明由程序集外部实现的成员函数

经常用于系统API函数的调用（通过 DllImport ）。注意，和DllImport一起使用时要加上 static 修饰符

也可以用于对于同一程序集不同版本组件的调用（用 extern 声明别名）

不能与 abstract 修饰符同时使用

示例：

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace Example03
{
    class Program
    {
        //注意DllImport是一个Attribute Property，在System.Runtime.InteropServices命名空间中定义
        //extern与DllImport一起使用时必须再加上一个static修饰符
        [DllImport("User32.dll")]
        public static extern int MessageBox(int Handle, string Message, string Caption, int Type);

        static int Main()
        {
            string myString;
            Console.Write("Enter your message: ");
            myString = Console.ReadLine();
            return MessageBox(0, myString, "My Message Box", 0);
        }
    }
}
结果：

4.abstract 是什么意思？

答：

abstract 修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员

abstract 不可以和 static 、virtual 一起使用

声明为 abstract 成员可以不包括实现代码，但只要类中还有未实现的抽象成员（即抽象类），那么它的对象就不能被实例化，通常用于强制继承类必须实现某一成员

示例：

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

namespace Example04
{
    #region 基类，抽象类
    public abstract class BaseClass
    {
        //抽象属性，同时具有get和set访问器表示继承类必须将该属性实现为可读写
        public abstract String Attribute
        {
            get;
            set;
        }

        //抽象方法，传入一个字符串参数无返回值
        public abstract void Function(String value);

        //抽象事件，类型为系统预定义的代理(delegate)：EventHandler
        public abstract event EventHandler Event;

        //抽象索引指示器，只具有get访问器表示继承类必须将该索引指示器实现为只读
        public abstract Char this[int Index]
        {
            get;
        }
    }
    #endregion

    #region 继承类
    public class DeriveClass : BaseClass
    {
        private String attribute;

        public override String Attribute
        {
            get
            {
                return attribute;
            }
            set
            {
                attribute = value;
            }
        }
        public override void Function(String value)
        {
            attribute = value;
            if (Event != null)
            {
                Event(this, new EventArgs());
            }
        }
        public override event EventHandler Event;
        public override Char this[int Index]
        {
            get
            {
                return attribute[Index];
            }
        }
    }
    #endregion

    class Program
    {
        static void OnFunction(object sender, EventArgs e)
        {
            for (int i = 0; i < ((DeriveClass)sender).Attribute.Length; i++)
            {
                Console.WriteLine(((DeriveClass)sender)[i]);
            }
        }
        static void Main(string[] args)
        {
            DeriveClass tmpObj = new DeriveClass();

            tmpObj.Attribute = "1234567";
            Console.WriteLine(tmpObj.Attribute);

            //将静态函数OnFunction与tmpObj对象的Event事件进行关联
            tmpObj.Event += new EventHandler(OnFunction);

            tmpObj.Function("7654321");

            Console.ReadLine();
        }
    }
}
结果：
1234567
7
6
5
4
3
2
1

5.internal 修饰符起什么作用？

答：

internal 修饰符可以用于类型或成员，使用该修饰符声明的类型或成员只能在同一程集内访问

接口的成员不能使用 internal 修饰符

值得注意的是，如果为 internal 成员加上了 protected 修饰符，这时的访问级别为 internal 或 protected。只是看字面意思容易弄错，许多人认为 internal protected 应该是“只有同一个程序集中的子类可以访问”，但其实它表示“同一个程序集中的所有类，以及所有程序集中的子类都可以访问”

示例

Example05Lib 项目的 Class1

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

namespace Example05Lib
{
    public class Class1
    {
        internal String strInternal = null;
        public String strPublic;
        internal protected String strInternalProtected = null;
    }
}
结果
Example05Lib 项目的 Class2 类可以访问到 Class1 的 strInternal 成员，当然也可以访问到 strInternalProtected 成员，因为他们在同一个程序集里

Example05 项目里的 Class3 类无法访问到 Class1 的 strInternal 成员，因为它们不在同一个程序集里。但却可以访问到 strInternalProtected 成员，因为 Class3 是 Class1 的继承类

Example05 项目的 Program 类既无法访问到 Class1 的 strInternal 成员，也无法访问到 strInternalProtected 成员，因为它们既不在同一个程序集里也不存在继承关系

6.sealed 修饰符是干什么的？

答：

sealed 修饰符表示密封

用于类时，表示该类不能再被继承，不能和 abstract 同时使用，因为这两个修饰符在含义上互相排斥

用于方法和属性时，表示该方法或属性不能再被重写，必须和 override 关键字一起使用，因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员

通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱

恰当的利用 sealed 修饰符也可以提高一定的运行效率，因为不用考虑继承类会重写该成员

示例：

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

namespace Example06
{
    class Program
    {
        class A
        {
            public virtual void F()
            {
                Console.WriteLine("A.F");
            }
            public virtual void G()
            {
                Console.WriteLine("A.G");
            }
        }
        class B : A
        {
            public sealed override void F()
            {
                Console.WriteLine("B.F");
            }
            public override void G()
            {
                Console.WriteLine("B.G");
            }
        }
        class C : B
        {
            public override void G()
            {
                Console.WriteLine("C.G");
            }
        }
        static void Main(string[] args)
        {
            new A().F();
            new A().G();
            new B().F();
            new B().G();
            new C().F();
            new C().G();

            Console.ReadLine();
        }
    }
}
结果：
类 B 在继承类 A 时可以重写两个虚函数，如图所示：

由于类 B 中对 F 方法进行了密封，类 C 在继承类 B 时只能重写一个函数，如图所示：

控制台输出结果，类 C 的方法 F 只能是输出类B 中对该方法的实现：

A.F
A.G
B.F
B.G
B.F
C.G

7.override 和 overload 的区别？

答：

override 表示重写，用于继承类对基类中虚成员的实现

overload 表示重载，用于同一个类中同名方法不同参数（包括类型不同或个数不同）的实现

示例：

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

namespace Example07
{
    class Program
    {
        class BaseClass
        {
            public virtual void F()
            {
                Console.WriteLine("BaseClass.F");
            }
        }
        class DeriveClass : BaseClass
        {
            public override void F()
            {
                base.F();
                Console.WriteLine("DeriveClass.F");
            }
            public void Add(int Left, int Right)
            {
                Console.WriteLine("Add for Int: {0}", Left + Right);
            }
            public void Add(double Left, double Right)
            {
                Console.WriteLine("Add for int: {0}", Left + Right);
            }
        }
        static void Main(string[] args)
        {
            DeriveClass tmpObj = new DeriveClass();
            tmpObj.F();
            tmpObj.Add(1, 2);
            tmpObj.Add(1.1, 2.2);

            Console.ReadLine();
        }
    }
}
结果：
BaseClass.F
DeriveClass.F
Add for Int: 3
Add for int: 3.3

8.什么是索引指示器？

答：

实现索引指示器（indexer）的类可以象数组那样使用其实例后的对象，但与数组不同的是索引指示器的参数类型不xx于int

简单来说，其本质就是一个含参数属性

示例：

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

namespace Example08
{
    public class Point
    {
        private double x, y;
        public Point(double X, double Y)
        {
            x = X;
            y = Y;
        }
        //重写ToString方法方便输出
        public override string ToString()
        {
            return String.Format("X: {0} , Y: {1}", x, y);
        }
    }
    public class Points
    {
        Point[] points;
        public Points(Point[] Points)
        {
            points = Points;
        }
        public int PointNumber
        {
            get
            {
                return points.Length;
            }
        }
        //实现索引访问器
        public Point this[int Index]
        {
            get
            {
                return points[Index];
            }
        }
    }

    //感谢watson hua()的指点
    //索引指示器的实质是含参属性，参数并不只限于int
    class WeatherOfWeek
    {
        public string this[int Index]
        {
            get
            {
                //注意case段使用return直接返回所以不需要break
                switch (Index)
                {
                    case 0:
                        {
                            return "Today is cloudy!";
                        }
                    case 5:
                        {
                            return "Today is thundershower!";
                        }
                    default:
                        {
                            return "Today is fine!";
                        }
                }
            }
        }
        public string this[string Day]
        {
            get
            {
                string TodayWeather = null;
                //switch的标准写法
                switch (Day)
                {
                    case "Sunday":
                        {
                            TodayWeather = "Today is cloudy!";
                            break;
                        }
                    case "Friday":
                        {
                            TodayWeather = "Today is thundershower!";
                            break;
                        }
                    default:
                        {
                            TodayWeather = "Today is fine!";
                            break;
                        }
                }
                return TodayWeather;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Point[] tmpPoints = new Point[10];
            for (int i = 0; i < tmpPoints.Length; i++)
            {
                tmpPoints[i] = new Point(i, Math.Sin(i));
            }

            Points tmpObj = new Points(tmpPoints);
            for (int i = 0; i < tmpObj.PointNumber; i++)
            {
                Console.WriteLine(tmpObj[i]);
            }

            string[] Week = new string[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Staurday"};
            WeatherOfWeek tmpWeatherOfWeek = new WeatherOfWeek();
            for (int i = 0; i < 6; i++)
            {
                Console.WriteLine(tmpWeatherOfWeek[i]);
            }
            foreach (string tmpDay in Week)
            {
                Console.WriteLine(tmpWeatherOfWeek[tmpDay]);
            }

            Console.ReadLine();
        }
    }
}
结果：
X: 0 , Y: 0
X: 1 , Y: 0.841470984807897
X: 2 , Y: 0.909297426825682
X: 3 , Y: 0.141120008059867
X: 4 , Y: -0.756802495307928
X: 5 , Y: -0.958924274663138
X: 6 , Y: -0.279415498198926
X: 7 , Y: 0.656986598718789
X: 8 , Y: 0.989358246623382
X: 9 , Y: 0.412118485241757
Today is cloudy!
Today is fine!
Today is fine!
Today is fine!
Today is fine!
Today is thundershower!
Today is cloudy!
Today is fine!
Today is fine!
Today is fine!
Today is fine!
Today is thundershower!
Today is fine!

9.new 修饰符是起什么作用？

答：

new 修饰符与 new 操作符是两个概念

new 修饰符用于声明类或类的成员，表示隐藏了基类中同名的成员。而new 操作符用于实例化一个类型

new 修饰符只能用于继承类，一般用于弥补基类设计的不足

new 修饰符和 override 修饰符不可同时用在一个成员上，因为这两个修饰符在含义上互相排斥

示例：

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

namespace Example09
{
    class BaseClass
    {
        //基类设计者声明了一个PI的公共变量，方便进行运算
        public static double PI = 3.1415;
    }
    class DervieClass : BaseClass
    {
        //继承类发现该变量的值不能满足运算精度，于是可以通过new修饰符显式隐藏基类中的声明
        public new static double PI = 3.1415926;
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(BaseClass.PI);
            Console.WriteLine(DervieClass.PI);

            Console.ReadLine();
        }
    }
}
结果：
3.1415
3.1415926

10.this 关键字的含义？

答：

this 是一个保留字，xx于构造函数和方法成员中使用

在类的构造函数中出现表示对正在构造的对象本身的引用，在类的方法中出现表示对调用该方法的对象的引用，在结构的构造上函数中出现表示对正在构造的结构的引用，在结构的方法中出现表示对调用该方法的结果的引用

this 保留字不能用于静态成员的实现里，因为这时对象或结构并未实例化

在 C# 系统中，this 实际上是一个常量，所以不能使用 this++ 这样的运算

this 保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身

示例：

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

namespace Example10
{
    class Class1
    {
        private double c;
        private string value;

        public double C
        {
            get
            {
                return c;
            }
        }
        public Class1(double c)
        {
            //限定同名的隐藏成员
            this.c = c;
        }
        public Class1(Class1 value)
        {
            //用对象本身实例化自己没有意义
            if (this != value)
            {
                c = value.C;
            }
        }
        public override string ToString()
        {
            //将对象本身做为参数
            return string.Format("{0} Celsius = {1} Fahrenheit", c, UnitTransClass.C2F(this));
        }

        //由于好奇，在这做了一个效率测试，想看看到底哪种方式访问成员变量更快，结论：区别不大。。。
        public string Test1()
        {
            long vTickCount = Environment.TickCount;
            for (int i = 0; i < 10000000; i++)
                this.value = i.ToString();
            return string.Format("Have this.: {0} MSEL", Environment.TickCount - vTickCount);
        }
        public string Test2()
        {
            long vTickCount = Environment.TickCount;
            for (int i = 0; i < 10000000; i++)
                value = i.ToString();
            return string.Format("Don't have this.: {0} MSEL", Environment.TickCount - vTickCount);
        }
    }
    class UnitTransClass
    {
        public static double C2F(Class1 value)
        {
            //摄氏到华氏的转换公式
            return 1.8 * value.C + 32;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Class1 tmpObj = new Class1(37.5);

            Console.WriteLine(tmpObj);

            Console.WriteLine(tmpObj.Test1());
            Console.WriteLine(tmpObj.Test2());

            Console.ReadLine();
        }
    }
}
结果：
37.5 Celsius = 99.5 Fahrenheit
Have this.: 4375 MSEL
Don't have this.: 4406 MSEL

11.可以使用抽象函数重写基类中的虚函数吗？

答：

可以

需使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现

或增加 override 修饰符，表示抽象重写了基类中该函数的实现

示例:

    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    abstract class DeriveClass1 : BaseClass
    {
        public abstract new void F();
    }

    //感谢watson hua()的指点
    //是他提醒了我还可以用这种方法抽象重写基类的虚方法
    abstract class DeriveClass2 : BaseClass
    {
        public abstract override void F();
    }

12.密封类可以有虚函数吗？

答：

可以，基类中的虚函数将隐式的转化为非虚函数，但密封类本身不能再增加新的虚函数

示例：

    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    sealed class DeriveClass : BaseClass
    {
        //基类中的虚函数F被隐式的转化为非虚函数

        //密封类中不能再声明新的虚函数G
        //public virtual void G()
        //{
        //    Console.WriteLine("DeriveClass.G");
        //}
    }

13.什么是属性访问器？

答：

属性访问器（Property Accessor），包括 get 访问器和 set 访问器分别用于字段的读写操作

其设计目的主要是为了实现面向对象（OO）中的封装思想。根据该思想，字段{zh0}设为private，一个精巧的类{zh0}不要直接把字段设为公有提供给客户调用端直接访问

另外要注意属性本身并不一定和字段相联系

14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？

答：

abstract 修饰符不可以和 static、virtual 修饰符一起使用

abstract 修饰符可以和 override 一起使用，参见第11点

示例：

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

namespace Example14
{
    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    abstract class DeriveClass1 : BaseClass
    {
        //在这里， abstract是可以和override一起使用的
        public abstract override void F();
    }
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

15.接口可以包含哪些成员？

答：

接口可以包含属性、方法、索引指示器和事件，但不能包含常量、域、操作符、构造函数和析构函数，而且也不能包含任何静态成员

16.类和结构的区别？

答：
类：

类是引用类型在堆上分配，类的实例进行赋值只是复制了引用，都指向同一段实际对象分配的内存

类有构造和析构函数

类可以继承和被继承

结构：

结构是值类型在栈上分配（虽然栈的访问速度比较堆要快，但栈的资源有限放），结构的赋值将分配产生一个新的对象。

结构没有构造函数，但可以添加。结构没有析构函数

结构不可以继承自另一个结构或被继承，但和类一样可以继承自接口

示例：

根据以上比较，我们可以得出一些轻量级的对象{zh0}使用结构，但数据量大或有复杂处理逻辑对象{zh0}使用类。

如：Geoemtry（GIS 里的一个概论，在 OGC 标准里有定义） {zh0}使用类，而 Geometry 中点的成员{zh0}使用结构

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

namespace Example16
{
    interface IPoint
    {
        double X
        {
            get;
            set;
        }
        double Y
        {
            get;
            set;
        }
        double Z
        {
            get;
            set;
        }
    }
    //结构也可以从接口继承
    struct Point: IPoint
    {
        private double x, y, z;
        //结构也可以增加构造函数
        public Point(double X, double Y, double Z)
        {
            this.x = X;
            this.y = Y;
            this.z = Z;
        }
        public double X
        {
            get { return x; }
            set { x = value; }
        }
        public double Y
        {
            get { return x; }
            set { x = value; }
        }
        public double Z
        {
            get { return x; }
            set { x = value; }
        }
    }
    //在此简化了点状Geometry的设计，实际产品中还包含Project（坐标变换）等复杂操作
    class PointGeometry
    {
        private Point value;

        public PointGeometry(double X, double Y, double Z)
        {
            value = new Point(X, Y, Z);
        }
        public PointGeometry(Point value)
        {
            //结构的赋值将分配新的内存
            this.value = value;
        }
        public double X
        {
            get { return value.X; }
            set { this.value.X = value; }
        }
        public double Y
        {
            get { return value.Y; }
            set { this.value.Y = value; }
        }
        public double Z
       {
            get { return value.Z; }
            set { this.value.Z = value; }
        }
        public static PointGeometry operator +(PointGeometry Left, PointGeometry Rigth)
        {
            return new PointGeometry(Left.X + Rigth.X, Left.Y + Rigth.Y, Left.Z + Rigth.Z);
        }
        public override string ToString()
        {
            return string.Format("X: {0}, Y: {1}, Z: {2}", value.X, value.Y, value.Z);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Point tmpPoint = new Point(1, 2, 3);

            PointGeometry tmpPG1 = new PointGeometry(tmpPoint);
            PointGeometry tmpPG2 = new PointGeometry(tmpPoint);
            tmpPG2.X = 4;
            tmpPG2.Y = 5;
            tmpPG2.Z = 6;

            //由于结构是值类型，tmpPG1 和 tmpPG2 的坐标并不一样
            Console.WriteLine(tmpPG1);
            Console.WriteLine(tmpPG2);

            //由于类是引用类型，对tmpPG1坐标修改后影响到了tmpPG3
            PointGeometry tmpPG3 = tmpPG1;
            tmpPG1.X = 7;
            tmpPG1.Y = 8;
            tmpPG1.Z = 9;
            Console.WriteLine(tmpPG1);
            Console.WriteLine(tmpPG3);

            Console.ReadLine();
        }
    }
}
结果：
X: 1, Y: 2, Z: 3
X: 4, Y: 5, Z: 6
X: 7, Y: 8, Z: 9
X: 7, Y: 8, Z: 9

17.接口的多继承会带来哪些问题？

答：

C# 中的接口与类不同，可以使用多继承，即一个子接口可以有多个父接口。但如果两个父成员具有同名的成员，就产生了二义性（这也正是 C# 中类取消了多继承的原因之一），这时在实现时{zh0}使用显式的声明

示例：

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

namespace Example17
{
    class Program
    {
        //一个完整的接口声明示例
        interface IExample
        {
            //属性
            string P
            {
                get;
                set;
            }
            //方法
            string F(int Value);
            //事件
            event EventHandler E;
            //索引指示器
            string this[int Index]
            {
                get;
                set;
            }
        }
        interface IA
        {
            int Count { get; set;}
        }
        interface IB
        {
            int Count();
        }
        //IC接口从IA和IB多重继承
        interface IC : IA, IB
        {
        }
        class C : IC
        {
            private int count = 100;
            //显式声明实现IA接口中的Count属性
            int IA.Count
            {
                get { return 100; }
                set { count = value; }
            }
            //显式声明实现IB接口中的Count方法
            int IB.Count()
            {
                return count * count;
            }
        }
        static void Main(string[] args)
        {
            C tmpObj = new C();

            //调用时也要显式转换
            Console.WriteLine("Count property: {0}", ((IA)tmpObj).Count);
            Console.WriteLine("Count function: {0}", ((IB)tmpObj).Count());

            Console.ReadLine();
        }
    }
}
结果：
Count property: 100
Count function: 10000

18.抽象类和接口的区别？

答：

抽象类（abstract class）可以包含功能定义和实现，接口（interface）只能包含功能定义

抽象类是从一系列相关对象中抽象出来的概念，因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定，因此反映的是事物的外部特性

分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么”

为外部提供调用或功能需要扩充时优先使用接口

19.别名指示符是什么？

答：

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

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

别名指示符在所有命名空间最外层定义，作用域为整个单元文件。如果定义在某个命名空间内，那么它只在直接隶属的命名空间内起作用

示例：

Class1.cs:

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

namespace com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01
{
    class Class1
    {
        public override string ToString()
        {
            return "com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1";
        }
    }
}
Class2.cs：

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

namespace com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02
{
    class Class1
    {
        public override string ToString()
        {
            return "com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02's Class1";
        }
    }
}
主单元（Program.cs）：

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

//使用别名指示符解决同名类型的冲突
//在所有命名空间最外层定义，作用域为整个单元文件
using Lib01Class1 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
using Lib02Class2 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02.Class1;

namespace Example19
{
    namespace Test1
    {
        //Test1Class1在Test1命名空间内定义，作用域仅在Test1之内
        using Test1Class1 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;

        class Class1
        {
            //Lib01Class1和Lib02Class2在这可以正常使用
            Lib01Class1 tmpObj1 = new Lib01Class1();
            Lib02Class2 tmpObj2 = new Lib02Class2();
            //TestClass1在这可以正常使用
            Test1Class1 tmpObj3 = new Test1Class1();
        }
    }
    namespace Test2
    {
        using Test1Class2 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;

        class Program
        {
            static void Main(string[] args)
            {
                //Lib01Class1和Lib02Class2在这可以正常使用
                Lib01Class1 tmpObj1 = new Lib01Class1();
                Lib02Class2 tmpObj2 = new Lib02Class2();

                //注意这里，TestClass1在这不可以正常使用。
                //因为，在Test2命名空间内不能使用Test1命名空间定义的别名
                //Test1Class1 tmpObj3 = new Test1Class1();

                //TestClass2在这可以正常使用
                Test1Class2 tmpObj3 = new Test1Class2();

                Console.WriteLine(tmpObj1);
                Console.WriteLine(tmpObj2);
                Console.WriteLine(tmpObj3);

                Console.ReadLine();
            }
        }
    }
}

结果：
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02's Class1
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1

20.如何手工释放资源？

答：

.NET 平台在内存管理方面提供了GC（Garbage Collection），负责自动释放托管资源和内存回收的工作。但在以下两种情况需要我们手工进行资源释放：一、由于它无法对非托管资源进行释放，所以我们必须自己提供方法来释放对象内分配的非托管资源，比如你在对象的实现代码中使用了一个COM对象；二、你的类在运行是会产生大量实例（象 GIS 中的Geometry），必须自己手工释放这些资源以提高程序的运行效率

最理想的办法是通过实现一个接口显式的提供给客户调用端手工释放对象，System 命名空间内有一个 IDisposable 接口，拿来做这事非常合适，省得我们自己再声明一个接口了
示例：

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

namespace Example20
{
    class Program
    {
        class Class1 : IDisposable
        {
            //析构函数，编译后变成 protected void Finalize()，GC会在回收对象前会调用调用该方法
            ~Class1()
            {
                Dispose(false);
            }

            //通过实现该接口，客户可以显式地释放对象，而不需要等待GC来释放资源，据说那样会降低效率
            void IDisposable.Dispose()
            {
                Dispose(true);
            }

            //将释放非托管资源设计成一个虚函数，提供在继承类中释放基类的资源的能力
            protected virtual void ReleaseUnmanageResources()
            {
                //Do something...
            }

            //私有函数用以释放非托管资源
            private void Dispose(bool disposing)
            {
                ReleaseUnmanageResources();

                //为true时表示是客户显式调用了释放函数，需通知GC不要再调用对象的Finalize方法
                //为false时肯定是GC调用了对象的Finalize方法，所以没有必要再告诉GC你不要调用我的Finalize方法啦
                if (disposing)
                {
                    GC.SuppressFinalize(this);
                }
            }
        }
        static void Main(string[] args)
        {
            //tmpObj1没有手工释放资源，就等着GC来慢慢的释放它吧
            Class1 tmpObj1 = new Class1();

            //tmpObj2调用了Dispose方法，传说比等着GC来释放它效率要调一些
            //个人认为是因为要逐个对象的查看其元数据，以确认是否实现了Dispose方法吧
            //当然最重要的是我们可以自己确定释放的时间以节省内存，优化程序运行效率
            Class1 tmpObj2 = new Class1();
            ((IDisposable)tmpObj2).Dispose();
        }
    }
}

21.P/Invoke是什么？

答：

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

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

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

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

22.StringBuilder 和 String 的区别？

答：

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

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

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

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

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

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

示例：

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

namespace Example22
{
    class Program
    {
        static void Main(string[] args)
        {
            const int cycle = 10000;

            long vTickCount = Environment.TickCount;
            String str = null;
            for (int i = 0; i < cycle; i++)
                str += i.ToString();
            Console.WriteLine("String: {0} MSEL", Environment.TickCount - vTickCount);

            vTickCount = Environment.TickCount;
            //看到这个变量名我就生气，奇怪为什么大家都使它呢？：）
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < cycle; i++)
                sb.Append(i);
            Console.WriteLine("StringBuilder: {0} MSEL", Environment.TickCount - vTickCount);

            string tmpStr1 = "A";
            string tmpStr2 = tmpStr1;
            Console.WriteLine(tmpStr1);
            Console.WriteLine(tmpStr2);
            //注意后面的输出结果，tmpStr1的值改变并未影响到tmpStr2的值
            tmpStr1 = "B";
            Console.WriteLine(tmpStr1);
            Console.WriteLine(tmpStr2);

            Console.ReadLine();
        }
    }
}
结果：
String: 375 MSEL
StringBuilder: 16 MSEL
A
A
B
A

23.explicit 和 implicit 的含义？

答：

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

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

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

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

示例：

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

namespace Example23
{
    class Program
    {
        //本例灵感来源于大话西游经典台词“神仙？妖怪？”--主要是我实在想不出什么好例子了
        class Immortal
        {
            public string name;
            public Immortal(string Name)
            {
                name = Name;
            }
            public static implicit operator Monster(Immortal value)
            {
                return new Monster(value.name + "：神仙变妖怪？偷偷下凡即可。。。");
            }
        }
        class Monster
        {
            public string name;
            public Monster(string Name)
            {
                name = Name;
            }
            public static explicit operator Immortal(Monster value)
            {
                return new Immortal(value.name + "：妖怪想当神仙？再去修炼五百年！");
            }
        }
        static void Main(string[] args)
        {
            Immortal tmpImmortal = new Immortal("紫霞仙子");
            //隐式转换
            Monster tmpObj1 = tmpImmortal;
            Console.WriteLine(tmpObj1.name);

            Monster tmpMonster = new Monster("孙悟空");
            //显式转换
            Immortal tmpObj2 = (Immortal)tmpMonster;
            Console.WriteLine(tmpObj2.name);

            Console.ReadLine();
        }
    }
}
结果：
紫霞仙子：神仙变妖怪？偷偷下凡即可。。。
孙悟空：妖怪想当神仙？再去修炼五百年！

24.params 有什么用？

答：

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

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

示例：

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

namespace ConsoleApplication1
{
    class App
    {
        //{dy}个参数必须是整型，但后面的参数个数是可变的。
        //而且由于定的是object数组，所有的数据类型都可以做为参数传入
        public static void UseParams(int id, params object[] list)
        {
            Console.WriteLine(id);
            for (int i = 0; i < list.Length; i++)
            {
                Console.WriteLine(list[i]);
            }
        }

        static void Main()
        {
            //可变参数部分传入了三个参数，都是字符串类型
            UseParams(1, "a", "b", "c");
            //可变参数部分传入了四个参数，分别为字符串、整数、浮点数和双精度浮点数数组
            UseParams(2, "d", 100, 33.33, new double[] { 1.1, 2.2 });

            Console.ReadLine();
        }
    }
}
结果：
1
a
b
c
2
d
100
33.33
System.Double[]

25.什么是反射？

答：

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

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

简单来说就是用string可以在runtime为所欲为的东西，实际上就是一个.net framework内建的{wn}工厂

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

示例：

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

namespace Example25Lib
{
    public class Class1
    {
        private string name;
        private int age;

        //如果显式的声明了无参数构造函数，客户端只需要用程序集的CreateInstance即可实例化该类
        //在此特意不实现，以便在客户调用端体现构造函数的反射实现
        //public Class1()
        //{
        //}
        public Class1(string Name, int Age)
        {
            name = Name;
            age = Age;
        }
        public void ChangeName(string NewName)
        {
            name = NewName;
        }
        public void ChangeAge(int NewAge)
        {
            age = NewAge;
        }
        public override string ToString()
        {
            return string.Format("Name: {0}, Age: {1}", name, age);
        }
    }
}
反射实例化对象并调用其方法，属性和事件的反射调用略去

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

//注意添加该反射的命名空间
using System.Reflection;

namespace Example25
{
    class Program
    {
        static void Main(string[] args)
        {
            //加载程序集
            Assembly tmpAss = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "Example25Lib.dll");

            //遍历程序集内所有的类型，并实例化
            Type[] tmpTypes = tmpAss.GetTypes();
            foreach (Type tmpType in tmpTypes)
            {
                //获取{dy}个类型的构造函数信息
                ConstructorInfo[] tmpConsInfos = tmpType.GetConstructors();
                foreach (ConstructorInfo tmpConsInfo in tmpConsInfos)
                {
                    //为构造函数生成调用的参数集合
                    ParameterInfo[] tmpParamInfos = tmpConsInfo.GetParameters();
                    object[] tmpParams = new object[tmpParamInfos.Length];
                    for (int i = 0; i < tmpParamInfos.Length; i++)
                    {
                        tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
                        if (tmpParamInfos[i].ParameterType.FullName == "System.String")
                        {
                            tmpParams[i] = "Clark";
                        }
                    }

                    //实例化对象
                    object tmpObj = tmpConsInfo.Invoke(tmpParams);
                    Console.WriteLine(tmpObj);

                    //获取所有方法并执行
                    foreach (MethodInfo tmpMethod in tmpType.GetMethods())
                    {
                        //为方法的调用创建参数集合
                        tmpParamInfos = tmpMethod.GetParameters();
                        tmpParams = new object[tmpParamInfos.Length];
                        for (int i = 0; i < tmpParamInfos.Length; i++)
                        {
                            tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
                            if (tmpParamInfos[i].ParameterType.FullName == "System.String")
                            {
                                tmpParams[i] = "Clark Zheng";
                            }
                            if (tmpParamInfos[i].ParameterType.FullName == "System.Int32")
                            {
                                tmpParams[i] = 27;
                            }
                        }
                        tmpMethod.Invoke(tmpObj, tmpParams);
                    }

                    //调用完方法后再次打印对象，比较结果
                    Console.WriteLine(tmpObj);
                }
            }

            Console.ReadLine();
        }
    }
}
结果：
Name: Clark, Age: 0
Name: Clark Zheng, Age: 27

示例下载：

如果你认为还有哪些概念比较重要或容易混淆，可以在回复中提出，我会及时更新这篇随笔

一些话：

To: watson hua，谢谢你帮我改正了第4、11、14和19点的错误，并且让我对索引指示器的理解更全面！

To: xiao，谢谢你关于“实例化”的详细解释，让这篇随笔中的措词更加xx！

To: charleschen，谢谢你追问，让第1、第8的提法更恰当！

To: 装配脑袋，谢谢你提供 internal protected 含义的正确答案！

Posted on 2007-04-05 13:44 Clark Zheng 阅读(31783) 评论(157) 编辑收藏网摘所属分类: A. .NET
Feedback
#1楼    回复引用查看
2007-04-05 13:54 by 亚历山大同志
很重要的基础概念，每个C#的开发人员都应该弄明白先，不过......
#2楼    回复引用查看
2007-04-05 13:58 by 亚历山大同志
还有，我很喜欢用sb，呵呵，个人作品，公司的东西还是严格按照公司规范来
#3楼    回复引用查看
2007-04-05 14:09 by 非我
我先自测了一遍，按100分算只能打80+，惭愧……
#4楼    回复引用查看
2007-04-05 14:24 by 随风流月
什么时候做个 Visual Basic 的测验？
这些东西基本都看不懂，除了一些 CLR 共通的……
#5楼    回复引用
2007-04-05 14:56 by fly_bluewolf [未注册用户]
还有"unbox"和"box"这两个概念,很容易被人忽略.
#6楼 [楼主]   回复引用查看
2007-04-05 15:23 by Clark Zheng
@亚历山大同志
：）
#7楼 [楼主]   回复引用查看
2007-04-05 15:24 by Clark Zheng
@非我
不要以偶的参考答案评分，里面可能错误多多呢
#8楼 [楼主]   回复引用查看
2007-04-05 15:24 by Clark Zheng
@随风流月
我不会推出VB.NET的版本了，如果感兴趣，你可以写一个？
#9楼 [楼主]   回复引用查看
2007-04-05 15:26 by Clark Zheng
@fly_bluewolf
关于装箱和拆箱。。。我再看看吧，个人感觉真的没什么好写的
#10楼    回复引用查看
2007-04-05 15:45 by 波→ONLINE
不错，不错。收藏了。
#11楼    回复引用查看
2007-04-05 16:01 by 装配脑袋
@随风流月
如果想要VB的话……

1.静态变量和非静态变量的区别？
2.Const和Shared Readonly 区别？
3.Declare是什么意思？
4.MustInherit/MustOverride是什么意思？
5.Friend修饰符起什么作用？
6.NotInheritable/NotOverridable修饰符是干什么的？
7.Overrides和 Overloads的区别？
8.什么是默认属性？
9.Shadows修饰符是起什么作用？
10.Me关键字的含义？
11.可以使用抽象函数重写基类中的虚函数吗？(答案与C#不同）
12.不可继承类可以有虚函数吗？
13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有 Get 和 Set 两个呢？（答案与C#不同）
14.MustOverride可以和 Overridable一起使用吗？可以和 Overrides一起使用吗？
15.接口可以包含哪些成员？
16.类和结构体的区别？
17.接口的多继承会带来哪些问题？
18.抽象类和接口的区别？
19.Global关键字是什么？
20.如何释放非托管资源？
21.P/Invoke是什么？
22.StringBuilder 和 String 的区别？
23.Narrowing和 Widening的含义？
24.ParamArray有什么用？
25.什么是反射？
#12楼    回复引用查看
2007-04-05 16:22 by charleschen
不错的文章，
追问：
静态方法和普通方法的区别？
显示接口与隐式接口的区别？
为什么要使用Get／Set 而不是直接操作类成员？
GC释放资源有哪几种方法？
#13楼    回复引用查看
2007-04-05 16:56 by Huacn Lee
不错的文章
以前看着这些名词都不知道什么意思，其实自已一直在用，呵呵
#14楼    回复引用查看
2007-04-05 16:57 by Huacn Lee
我来回答@charleschen
用 Get/Set 因为是可以独立设置只写或只能写吧
#15楼    回复引用查看
2007-04-05 17:19 by Dflying Chen
@装配脑袋
真厉害…………人工翻译阿
#16楼    回复引用查看
2007-04-05 17:24 by 流浪的狗
汗... 我连及格都不行.
基础太差.
#17楼    回复引用查看
2007-04-05 17:40 by 没剑
override 表示重载，用于同一个类中同名方法不同参数（包括类型不同或个数不同）的实现
------------
这里的override应为overload
#18楼 [楼主]   回复引用查看
2007-04-05 19:01 by Clark Zheng
@装配脑袋
汗，真是C#.NET和VB.NET同时精通的人才呀。。。
#19楼 [楼主]   回复引用查看
2007-04-05 19:04 by Clark Zheng
@没剑
感谢你的细心，正文已修正！
#20楼    回复引用查看
2007-04-05 20:01 by Aの扬凡
是一次做复习的机会
#21楼    回复引用
2007-04-05 21:16 by 戴眼镜的太阳 [未注册用户]
呵呵，不错，学了不少，用C#写了一段时间的程序了，但是你里面的东西我还有好多没用过，继续研究C#：）
#22楼    回复引用
2007-04-05 21:18 by 郭志坚 [未注册用户]
嗯,不错,基本上都清楚这些概念.
这一年没白混,呵呵
#23楼    回复引用查看
2007-04-05 21:18 by Boler Guo
很好很好，图文并茂。11、12还是有点儿迷惑，主要是new, virtual, abstract, sealed 这几个概念容易混淆~
#24楼 [楼主]   回复引用查看
2007-04-05 21:35 by Clark Zheng
@charleschen

1.静态方法和普通方法的区别？
答：静态方法是通过类型调用，在对象未实例化前就可以使用，因此在其实现中不能使用非静态的成员（如：非静态的变量、非静态的方法）

2.显式接口和隐式接口？
答：你是指显式接口成员吗？

3.为什么要使用Get／Set 而不是直接操作类成员？
答：get/set 是C#为实现属性而设计的访问器，提出这概念主要是为了实现OO中的“封装”。根据该思想，字段{zh0}设为private，一个精巧的类{zh0}不要直接把字段设为公有提供给客户调用端直接访问
另外，在设计模式中提到如果你有一个public的方法，那么{zh0}再设计一个protected的虚函数以方便子类中对该方法进行扩展，属性访问器的设计可以让我们完成该模式，不是吗？

4.GC释放资源有哪几种方法？
答：我不太理解这个题目，你想问什么呢？GC释放资源的流程？

以上回答还希望大家多多提意见，确认比较全面并且无误后，我会加到随笔正文

#25楼 [楼主] 回复引用查看
2007-04-05 21:52 by Clark Zheng
@Boler Guo
new 比较特殊，这个关键字既是修饰符又是运算符，做为运算符时用于实例化类型，做为修饰符时，请参照第9点的答案

sealed 起密封作用，意味该类型或成员不会再有继承，所以虚函数会自动变成非虚函数。非函数在CLR查找其实现时速度会快一点，这也是我提到sealed有时可以提高程序运行效率的原因

virtual 没什么好说的吧，虚函数OO中多态的基础呀

abstract 请参照第4点的答案
#26楼    回复引用查看
2007-04-05 21:58 by watson hua
大体上正确，但不xx，建议参照框架设计，说的深入一些。
还有一些个人看法，不算纠正，只算补充。
索引指示器实质是含参属性，也就是说，它的参数不限于int，把它比作数组未免...
可以使用抽象函数重写基类中的虚函数吗？这个问题我觉得楼主理解有一些问题，不需要加new修饰。所谓abstract,new,virtual只是虚函数的版本元数据的几个向量而已，当然你也可以把那个函数理解为new的，但这个new不是atttribute，而是函数的元数据里的一个标志位。所以你即便不加new修饰，编译器也不会报warning。
其他还有几个地方用词也值得斟酌。
算然已经很好了，但我们应该有更高的目标。
#27楼    回复引用查看
2007-04-05 22:00 by watson hua
@Clark Zheng
quote"静态方法是通过类型调用，在类未实例时就可以使用"
类事例化前是不能使用的，我想你的意思应该是对象实例化前吧。
#28楼    回复引用查看
2007-04-05 22:14 by lavy
关于THIS的用法
限定被相似的名称隐藏的成员，例如：

public Employee(string name, string alias)
{
this.name = name;
this.alias = alias;
}

我有疑问:
什么是被相似的名称隐藏的成员??
相似指什么?什么时候会出现隐藏?
#29楼    回复引用
2007-04-05 22:51 by 小鬼 [未注册用户]
真强，我一直想做这么一件事情，可一直都没有做，谢谢你为我提供了这么好的快速复习小册子。
#30楼 [楼主]   回复引用查看
2007-04-05 23:23 by Clark Zheng
@watson hua
谢谢你关于索引指示器的讲解，正文我已修订，并将示例更新了

关于”使用抽象函数重写基类中的虚函数“，如果不加 new 修饰符编译时会给警告。你可以把Example11示例中，DeriveClass的F函数去掉 new 修饰符，然后编译试一下

关于类实例化和对象实例化，我还是听从了你的意见，上面的回复也已改正

ps：非常希望你能帮其它几处用词不当的地方指出，我们就是应该有更高的目标！
#31楼 [楼主] 回复引用查看
2007-04-05 23:30 by Clark Zheng
@lavy
我的原文是”this 保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身“，并没有”限定被相似的名称隐藏的成员“

针对{dy}个用处，我再详细说明一下：

//正确，由于类本身的变量c和构造函数的参数c重名，这时就需要使用this显式指出是将参数的c赋值给类的变量c
private double c;
public Class1(double c)
{
//限定同名的隐藏成员
this.c = c;
}

//错误，会给出一个警告：对同一变量赋值。编译器没有看到我们实际想赋值的成员变量c，所以我们称它”隐藏“了
private double c;
public Class1(double c)
{
c = c;
}

#32楼 [楼主]   回复引用查看
2007-04-05 23:36 by Clark Zheng
@Huacn Lee
@Aの扬凡
@戴眼镜的太阳
@郭志坚
@Boler Guo
@小鬼
谢谢你们的支持！
#33楼    回复引用查看
2007-04-06 00:08 by watson hua
@Clark Zheng
能够严肃的讨论技术实在是人生快事。
11.可以使用抽象函数重写基类中的虚函数吗？
不知这个重写是override还是overload，还是重名函数就算。
若是override，当然是可以的，但不要忘了加override修饰，编译器推倒不出的。
若是overload，当然是可以的，但凡不写new，是要抛warning的。

#34楼 [楼主] 回复引用查看
2007-04-06 00:26 by Clark Zheng
@watson hua
本文把overload译为重载，把override译为重写，请参见第7点答案

我的问题是抽象函数(abstract)是否可以重写（override）基类中的虚函数，而 abstract 和 override修饰符是不可以同时使用的，会产生二义性，所以谈不上把 override 忘了

出本题的目的缘于我在引用一个类库时发现其中一个基类设计不合理，仅仅设为虚函数（virtual）并没有设成抽象函数（abstract）--具体情况这里略去。所以我想把它改成抽象函数，以便使用我的类库的开发人员如果继承该类必须强制性的重写(override)该函数。So，我碰到了一个警告，通过增加 new 修饰符解决了该问题。
#35楼回复引用查看
2007-04-06 01:02 by watson hua
using System;
using System.Collections.Generic;
using System.Text;

namespace Example11
{
class BaseClass
{
public virtual void F()
{
Console.WriteLine("BaseClass.F");
}
}
abstract class DeriveClass : BaseClass
{
public abstract override void F();
}
class Program
{
static void Main(string[] args)
{
}
}
}
试一下吧
#36楼 [楼主]   回复引用查看
2007-04-06 01:55 by Clark Zheng
@watson hua
请原谅我的浅见拙识，原文中已改正了所有关于 abstract 和 override 关系的地方，下载文件也已替换。
在此只好是”再次“感谢你了 :)
#37楼    回复引用查看
2007-04-06 03:36 by watson hua
再补充一点我的理解吧，我觉得@Clark Zheng的这篇文章写得相当用心，也足见@Clark Zheng做人，做程序员的责任心。
1.静态变量和非静态变量的区别？
静态变量在类实例化时创建，非静态变量在对象实例化时创建，
即静态变量在类构造函数调用的时候创建，非静态变量在对象构造函数调用时创建。
@Clark Zheng的sample里用的是一个可以使用一条语句就可以完成创建的静态变量，所以掩盖了这个问题。
@Clark Zheng说静态变量是类被装载时创建的，我不清楚他说的类被装载是什么时候。
assembly被装载到appdomain时是不会的，类在被使用前的一瞬，会调用静态构造函数完成类的实例化。
2.const 和 static readonly 区别？
xx正确，不再补充。
3.extern 是什么意思？
不知道存不存在其他功能，如cpp里的extern "C"。
4.abstract 是什么意思？
6.sealed 修饰符是干什么的？
7.override 和 overload 的区别？
可以参考这篇">http://www.cnblogs.com/huazhihao/archive/2007/04/06/702083.html可以参考这篇。
5.internal 修饰符起什么作用？
没什么好说的，搞清楚和protected的区别就可以了，当然internal protected的语意是internal && protected
8.什么是索引指示器？
已经补充过了。
9.new 修饰符是起什么作用？
不是很喜欢这种关键词重载。
10.this 关键字的含义？
this很好理解。java里可以使用对象访问类属属性，相比起来，更喜欢c#里的设计。
11.可以使用抽象函数重写基类中的虚函数吗？
讨论过，答案是可以。absolutely。
12.密封类可以有虚函数吗？
问题是"密封类可以有虚函数吗"，结果回答的是"密封类的父类可以有虚函数"。照clark兄的意思是密封类可以包含虚的成员方法，我觉这个问题问得没有意义。sealed的类最起码是object的派生类，object有ToString()，答案是明显的。
13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有 get 和 set 两个呢？
属性的实质是方法，若有一个virtual方法自然可以override。所以，派生类可以override父类的get，只要父类有get，set同理。
quote"如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后也应只有一个。如果基类中有 get 和 set 两个属性访问器，那么继承类中可以只有一个也可以同时有两个属性访问器" zhang 表述的不够准确。
14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？
参见
15.接口可以包含哪些成员？
interface可以包含所有的可以被继承且可以被派生类实例化的成员,并且interface自己不能被实例化。interface遵照此原则。因为比较宽松，所以才会出现范型接口这种病态的但又不可或缺的东西。
16.类和结构的区别？
class和struct的区别再不交互时是很容易辨认的，当class里有struct，struct里又有class就很热闹了。
class和struct的比较重要的问题是，eqauls方法和原型方法的逻辑。当class里有struct，或struct里有class，不能靠object.equals了，既要考虑怎样重用父类里的equals，又要考虑便于派生类拓展，怎么样才算equals，非常复杂。而原型方法就是(iclonable).clone，深的还是浅的，多深多浅，要结合equals方法考虑。当然不要忘了重载==。
再提一句，stuct A{}的实质是class A:System.ValueType{}，但是这个System.ValueType是一个class。想来有趣，有一点像夏娃，是用亚当的一根肋骨做程的。
17.接口的多继承会带来哪些问题？
这个问题改成"多接口的继承会带来哪些问题？"比较好。@clark zhang解释的还是正确的，只要不造成二义性，可以不用显示转型。
18.抽象类和接口的区别？
抽象类的原则是存在不可以被实例化的方法的类，接口的原则前面提到过。
19.别名指示符是什么？
using的一个作用，作用范围是using的所在名空间内，并且在using的语句后面。并非只在一个单元文件内起作用。
当然别名像多接口继承一样，也是要"去二义化"的。
20.如何释放非托管资源？
问题改成"如何强制释放资源"比较好。
不建议强制释放资源，除非逼不得已。gc，人间凶器阿...
21.P/Invoke是什么？
没怎么用过，不敢发表意见。
22.StringBuilder 和 String 的区别？
区别还是很大的。倒是string和值类型的近似行为更值得讲解。
另外cycle = 100000还是少一到两个零比较好，意思一下就好了么。
23.explicit 和 implicit 的含义？
例子很形象。Explicit存在的意义相当于c++里的拷贝构造函数。
24.params 有什么用？

public static void UseParams(int id, params object[] list)
{
Console.WriteLine(id);
for (int i = 0; i < list.Length; i++)
{
Console.WriteLine(list[i]);
}
}
...
UseParams(2, "d", 100, 33.33, new double[] { 1.1, 2.2 });
{zh1}会输出System.Double[]是因为cw((object)o)的逻辑是cw(o.ToString())，而(object).ToString()默认输出(object).GetType().ToString()
params的实质是一个ParamArrayAttribute，因为c#不支持默认参数，所以不定秩的形参只有靠它来。对比c++，可读性无疑增强了。c++里好像也有vlist ...的东西，名称记不得了，好像还要加一个头文件，用起来非常麻烦，还不可以做编译期的类型检查。不过c#里没有默认参数，如果要和vb,c++交互的话，要用Type.Missing来补空位，不可以用null。曾经调用office的com，一个函数里用了40个Type.Missing，无语啊。
25.什么是反射？
用string可以在runtime为所欲为的东西。实际上就是一个.net framework内建的{wn}工厂。
结：
这里的大部分问题的讨论结果已经不能算是基础概念了，而是底层概念了，希望能对大家有帮助。如果有不足的地方还请大家补充，如果我有理解错误的地方还请多指教。

#38楼 [楼主] 回复引用查看
2007-04-06 04:44 by Clark Zheng
@watson hua
关于”类实例化“和”对象实例化“，有没有更好的说法？我一直表达不清楚两个概念，请教一下这两个词的”xx“程度如何？

关于extern，本文只讨论C#语言范畴，前面有说

internal protected的语意是internal && protected，perfect!

关于第12题，密封类可以有虚函数吗？你的这个object举得非常恰当，我也感觉这个问题没有意义了。。。

索引指示器的实质是带参属性、属性的实质是方法，佩服你的见解
偶再补充一句：事件的实质是属性

关于第19题，我的试验结果是只在一个单元文件内起作用

关于第20题我觉得你的提法比我强

关于cycle = 100000，不知道是不是偶的机器太过强悍，少一个零后，输出结果如下：（我只是想让第二个不是0呀，另外特别声明一个常量做为循环次数就是方便各位朋友修改，不是我编码风格有多好。。。）
String: 343 MSEL
StringBuilder: 0 MSEL

ps:偶的名字是Clark Zheng，不是@Clark Zheng。 :)
#39楼    回复引用查看
2007-04-06 08:38 by ddr888
Attribute 重要不？
#40楼    回复引用查看
2007-04-06 08:47 by watson
不错，很详细~
#41楼    回复引用查看
2007-04-06 09:28 by Sephil
@watson hua
void writeError(int err, ...)
{
va_list vaList;
va_start(vaList, err);
// your code here
va_end(vaList);
}
#42楼    回复引用
2007-04-06 10:05 by 天下 [未注册用户]
@watson hua
静态变量在类实例化时创建，非静态变量在对象实例化时创建 --没明白这句话的意思。

我想对象实例化就是通过new来调用构造器吧

那什么叫类实例化呢？
#43楼 [楼主]   回复引用查看
2007-04-06 10:13 by Clark Zheng
@ddr888
嗯，很重要，不过按这种一回一答的方式好象不容易写好。
我考虑一下，正好把那个第12题换掉
#44楼    回复引用查看
2007-04-06 10:50 by 天龙之吻
signed :)
#45楼    回复引用
2007-04-06 10:52 by xiao [未注册用户]
@天下
类实例化指的是调用类的静态构造器,一个类只能有一个无参无修饰符的静态构造器,它只能调用一次,用于初始化类中静态字段的状态
对象实例化指的是调用通常意义上的构造器,它用于创建类的一个具体实例,这种构造器一个类中可以有多个重载版本
代码如下:
sealed class Xiao{
private static string str;
//此为类构造器,可查看IL,其中编译为cctor
static Xiao()
{
str = "qpppp";
}
//此为实例构造器,可查看IL,其中编译为ctor
public Xiao()
{
//当然实例构造器也能作用于静态字段
str = "eeeeeeeeeee";
}
}
#46楼    回复引用查看
2007-04-06 11:03 by lavy
@Clark Zheng
this "限定被相似的名称隐藏的成员"
是MSDN的解释 :)
你的解释,我懂了!~谢谢!
#47楼    回复引用查看
2007-04-06 11:11 by watson hua
@Clark Zheng
类实例化和对象实例化xiao兄已经举例，不赘述。最初听到类实例化是在李建忠老师那里，我的理解也是建立在他翻译的applied .net framework programming,这里的问题书上都有讲道。
谢谢Sephil兄，帮我复习一下久违的c++，怀念...
关于第19题，我说的语气没表述出来。我的语气是带一点反话的。我的意思是using只在它所在的名空间内有用，换而言之，如果单个文件有多个嵌套名空间，using只在它所直接隶属的名空间内可用。当然，如果它没有放在名空间内的话，作用域就是整个文件了。
#48楼 [楼主]   回复引用查看
2007-04-06 11:17 by Clark Zheng
@lavy
MSDN。。。不是忘看了就是看了忘记了，谢谢你的提醒
#49楼    回复引用查看
2007-04-06 11:22 by watson hua
@Clark Zheng
clark兄，关于称呼抱歉抱歉。:)我有的地方是直接粘的。
这篇post貌似very popular。
clark兄可以整理一下，再置顶于个人主页上，长期讨论...
当然欢迎clark兄就其他技术问题作讨论。
#50楼 [楼主]   回复引用查看
2007-04-06 12:17 by Clark Zheng
@xiao
感谢，正文已修改
#51楼 [楼主]   回复引用查看
2007-04-06 13:07 by Clark Zheng
@watson hua
改了第20题的提法
改了第22题的内容和示例，增加了对String的解释

示例下载已更新
#52楼 [楼主] 回复引用查看
2007-04-06 13:38 by Clark Zheng
@charleschen
你的追问中关于静态函数与非静态函数的问题，我已在第1题中做了修改
关于属性访问器的用处，也已在第8题中做了修改

其它两个问题我还不能理解题面的意思，期待着你的回复
#53楼    回复引用查看
2007-04-06 13:49 by yunhuasheng
楼主挺认真的！！;)
#54楼    回复引用查看
2007-04-06 14:26 by 想飞的猪
支持LZ,让俺重温了一遍....
#55楼    回复引用查看
2007-04-06 14:31 by 装配脑袋
internal protected的语意应该是internal | protected，而不是internal && protected。相信不少没有用过的老手也不知道。
#56楼    回复引用查看
2007-04-06 14:58 by 阿齐
类实例化指的是把一个类实例化的过程，即把类的静态成员初始化的过程；
而对象实例化，就是构造一个该类的实例，然后初始化该实例的实例成员
#57楼    回复引用查看
2007-04-06 15:38 by 装配脑袋
我尝试从这些语法的最直接效果作答这些问题：

1.静态成员和非静态成员的区别？
静态字段为类型所有实例所共享，而实例字段则为每个对象实例所专有。
静态方法不能访问实例成员，而且无需对象实例即可调用。
静态构造方法仅在AppDomain初始化类型时执行一次，而且具有AppDomain级别的线程安全性。而实例构造函数则在对象初始化时执行。

2.const 和 static readonly 区别？
const的字段在编译时会将其字面值直接写到引用它的地方，而且必须用字面常量在编译时初始化。
static readonly可以在运行时初始化。

3.extern 是什么意思？
extern表示函数体在其他地方定义。因此这样的函数只有声明没有定义。

4.abstract 是什么意思？
abstract用于类表示该类不能实例化，用于成员表示它是子类必须重写的过程。

5.internal 修饰符起什么作用？
表示该类型或成员仅在同一程序集中可被其他类型所访问。

6.sealed 修饰符是干什么的？
表示该类型不能被继承，或该（虚拟）成员不能再被子类所重写。

7.override 和 overload 的区别？
我其实不太愿意讨论两个范畴的东西有什么区别，因为硬要说区别就等于把两者的定义分别写一遍。

8.什么是索引指示器？
是一种带参数的属性，通过obj[params]的语法进行调用。

9.new 修饰符是起什么作用？
它指示该过程在MethodTable中开启一个新的“slot”，从而断开基类同名虚成员对其的调用关系。

10.this 关键字的含义？
在引用类型中，它表示所调用的对象实例的引用。在值类型中，它是一个符号，将this上的各种操作转嫁给所调用的值类型对象实例。

11.可以使用抽象函数重写基类中的虚函数吗？
当且仅当基类中相应的函数也为抽象函数。

12.密封类可以有虚函数吗？
可以，甚至有些封闭类带有新声明的虚函数（所有委托类型）。

13.什么是属性访问器？
使用访问变量的语法访问属性时，实际被调用的过程。

14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？
可以和override一起使用，当且仅当重写一个父类的虚成员时。

15.接口可以包含哪些成员？
接口仅可以包含过程，即方法、属性、事件。而且只能定义过程的签名，不能定义他们的方法体、访问级别等。

16.类和结构的区别？
类为引用类型
结构为值类型
结构没有终结器
结构不能继承
结构必须有一个默认构造方法，且不能自定义无参数构造方法
结构的成员不能在声明时赋值
结构默认有专门实现的不同==和GetHashCode方法

17.接口的多继承会带来哪些问题？
任何特性均在正确使用时发挥正确的效果。因此我们应该看到多继承的优势。

18.抽象类和接口的区别？
抽象类可以有构造方法
抽象类可以有终结器
抽象类可以有字段
抽象类可以有静态成员
抽象类可以没有抽象方法
抽象类可以有实例方法
一个类只能继承一个抽象类，而可以实现多个接口
抽象类的成员可以带有访问性级别
抽象类之间不能多继承，接口则可以
抽象类可以有静态构造方法

19.别名指示符是什么？
命名空间别名限定符::专名用来限定所用的名字要从指定别名所表示的范围开始搜索。别名为extern或using关键字定义的命名空间或根别名。

20.如何手工释放资源？
没有手工释放托管资源的功能，尽管有些看其来是在释放其实不是。只能手工释放非托管资源。

21.P/Invoke是什么？
通过Runtime进行封送（Marshal），调用公开方式的非托管代码，包括DLL和COM等。

22.StringBuilder 和 String 的区别？
基本上是写出两者定义的那种“区别”

23.explicit 和 implicit 的含义？
这是两个类型转换运算符，explicit运算符需要明确指出目标类型名，而implicit会根据上下文自动调用。

24.params 有什么用？
一种提供参数数目可变的参数传递方法。任意数目的参数可转化为一个数组。

25.什么是反射？
通过程序基内的元数据和Runtime的支持在运行时读取程序集、模块、类型和成员的信息，以及在运行时通过这种途径访问对象的成员或执行对象的方法。甚至动态改变类型和方法的组成。