C#笔试题目(综合版样题) （转载）

C#笔试题目(综合版样题)

C#/.Net/数据库笔试资料
题记:一年一度的招聘黄金时间来临了,本人决定整理C#.Net的资料为本人和园子里的朋友共享!
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）的类可以象数组那样使用其实例后的对象，但与数组不同的是索引指示器的参数类型不仅限于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(http://huazhihao.cnblogs.com/)的指点

    //索引指示器的实质是含参属性，参数并不只限于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 是一个保留字，仅限于构造函数和方法成员中使用

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

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(http://huazhihao.cnblogs.com/)的指点

    //是他提醒了我还可以用这种方法抽象重写基类的虚方法

    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）中的封装思想。根据该思想，字段最好设为private，一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问
另外要注意属性本身并不一定和字段相联系

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.类和结构的区别？

答：类：类是引用类型在堆上分配，类的实例进行赋值只是复制了引用，都指向同一段实际对象分配的内存
类有构造和析构函数
类可以继承和被继承

结构：
结构是值类型在栈上分配（虽然栈的访问速度比较堆要快，但栈的资源有限放），结构的赋值将分配产生一个新的对象。
结构没有构造函数，但可以添加。结构没有析构函数
结构不可以继承自另一个结构或被继承，但和类一样可以继承自接口

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

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

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# 中类取消了多继承的原因之一），这时在实现时最好使用显式的声明

示例：

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 则不会。所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder，不要使用 String
另外，对于 String 我们不得不多说几句：
1.它是引用类型，在堆上分配内存
2.运算时会产生一个新的实例
3.String 对象一旦生成不可改变（Immutable）
4.定义相等运算符（== 和 !=）是为了比较 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）
隐式转换可以让我们的代码看上去更漂亮、更简洁易懂，所以最好多使用 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

        //第一个参数必须是整型，但后面的参数个数是可变的。

        //而且由于定的是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内建的万能工厂

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

示例：

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)

                //获取第一个类型的构造函数信息

                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
总结:通过以上我们可以理解C#中难以理解的概念和示例代码.
软件测试题目
一、判断题 (每题2分，20)

1、软件测试就是为了验证软件功能实现的是否正确，是否完成既定目标的活动，所以软件测试在软件工程的后期才开始具体的工作。（初级）（ × ）

2、发现错误多的模块，残留在模块中的错误也多。( √ ) （初级）

3、测试人员在测试过程中发现一处问题，如果问题影响不大，而自己又可以修改，应立即将此问题正确修改，以加快、提高开发的进程。（ × ）（初级）

4、单元测试通常应该先进行“人工走查”，再以白盒法为主，辅以黑盒法进行动态测试。

（ √ ）（中级）

5、功能测试是系统测试的主要内容，检查系统的功能、性能是否与需求规格说明相同。（ √ ）（中级）

6、软件质量管理即QM由QA和QC构成，软件测试属于QC的核心工作内容。（√）（高级）

7、软件测试只能发现错误，但不能保证测试后的软件没有错误。(√)

8、软件就是程序。(X)

9、测试只要做到语句覆盖和分支覆盖，就可以发现程序中的所有错误。(X)

10、I18N测试是指对产品做出具有国际性的规划，而L10N测试则是指对软件做出符合本地需求更改工作。（√）【高级】

二、选择题 (每题2分 20 )

1、进行软件质量管理的重要性有：（ABCD）【中级】

A、维护降低成本 B、法律上的要求 C、市场竞争的需要

D、质量标准化的趋势 E、软件工程的需要 F、CMM过程的一部分

G、方便与客户进一步沟通为后期的实施打好基础

2、以测试的形态分测试可以分为：（ABC）【中级】

A、建构性测试 B、系统测试 C、专项测试

D、单元测试 E、组件测试 F、集成测试

3、选出属于黑盒测试方法的选项（ABC）【初级】

A、测试用例覆盖 B、输入覆盖 C、输出覆盖

D、分支覆盖 E、语句覆盖 F、条件覆盖

4、编写测试计划的目的是：（ABC）【中级】

A、使测试工作顺利进行 B、使项目参与人员沟通更舒畅 C、使测试工作更加系统化

D、软件工程以及软件过程的需要 E、软件过程规范化的要求 F、控制软件质量

5、依存关系有4种分别是：（ABCD）【高级】

A、开始－结束 B、开始－开始 C、结束－开始

D、结束－结束 E、开始－实施－结束 F、结束－审核－开始

6、软件质量管理（QM）应有质量保证（QA）和质量控制（QC）组成，下面的选项属于QC得是：（ABC）【高级】

A、测试 B、跟踪 C、监督

D、制定计划 E、需求审查 F、程序代码审查

7、实施缺陷跟踪的目的是：（ABCD）【中级】

A、软件质量无法控制 B、问题无法量化 C、重复问题接连产生

D、解决问题的知识无法保留 E、确保缺陷得到解决 F、使问题形成完整的闭环处理

8、使用软件测试工具的目的：（ABC）【中级】

A、帮助测试寻找问题 B、协助问题的诊断 C、节省测试时间

D、提高Bug的发现率 E、更好的控制缺陷提高软件质量 F、更好的协助开发人员

9、典型的瀑布模型的四个阶段是：（ABCD）【高级】

A、分析 B、设计 C、编码

D、测试 E、需求调研 F、实施

10、PSP是指个人软件过程，是一种可用于（ A ）、（ B ）和（ C ）个人软件工作方式的自我改善过程。【高级】

A、控制 B、管理 C、改进

D、高效 E、充分 F、适宜

三、问答题

1、测试人员在软件开发过程中的任务是什么？（初级）(5分)

答：1、寻找Bug；

2、避免软件开发过程中的缺陷；

3、衡量软件的品质；

4、关注用户的需求。

总的目标是：确保软件的质量。

2、在您以往的工作中，一条软件缺陷（或者叫Bug）记录都包含了哪些内容？如何提交高质量的软件缺陷（Bug）记录？（初级）(6分)

答：一条Bug记录最基本应包含：编号、Bug所属模块、Bug描述、Bug级别、发现日期、发现人、修改日期、修改人、修改方法、回归结果等等；要有效的发现Bug需参考需求以及详细设计等前期文档设计出高效的测试用例，然后严格执行测试用例，对发现的问题要充分确认肯定，然后再向外发布如此才能提高提交Bug的质量。

3、界面测试题及设计题。请找出下面界面中所存在的问题并分别列出；用黑盒测试的任何一种方法设计出此登陆窗体的测试用例。（中级）(6分)

答：1、窗体的标题栏中为空，没有给出标题。

2、用户名和密码控件的字体不一致并且没有对齐。

3、文本框的大小不一致没有对其。

4、确定和取消按钮控件的大小不一致。

4、黑盒测试和白盒测试是软件测试的两种基本方法，请分别说明各自的优点和缺点！（中级）(5分)

答：黑盒测试的优点有：
1）比较简单，不需要了解程序内部的代码及实现；

2）与软件的内部实现无关；

3）从用户角度出发，能很容易的知道用户会用到哪些功能，会遇到哪些问题；

4）基于软件开发文档，所以也能知道软件实现了文档中的哪些功能；

5）在做软件自动化测试时较为方便。

黑盒测试的缺点有：
1）不可能覆盖所有的代码，覆盖率较低，大概只能达到总代码量的30%；

2）自动化测试的复用性较低。

白盒测试的优点有：

帮助软件测试人员增大代码的覆盖率，提高代码的质量，发现代码中隐藏的问题。

白盒测试的缺点有：

1）程序运行会有很多不同的路径，不可能测试所有的运行路径；

2）测试基于代码，只能测试开发人员做的对不对，而不能知道设计的正确与否，可能会漏掉一些功能需求；

3）系统庞大时，测试开销会非常大。

5、根据自己的理解回答什么是软件测试，软件测试分为哪几个阶段。（初级）(5分)

答：软件测试是一个为了寻找软件中的错误而运行软件的过程，一个成功的测试是指找到了迄今为止尚未发现的错误的测试。

软件测试一般分为单元测试、集成测试和系统测试。

6、根据自己的理解什么是测试用例和测试规程，设计一个测试用例应当从哪几方面考虑？（中级）(10分)

答：狭义的讲，一个测试用例就是测试人员用以测试被测软件的某个特性或特性组合的一组数据。这组数据可能是从用户处得来的实际的一组数据，也可能是测试人员专门设计出来的测试软件某些功能的一组数据。

测试规程就是详细的对测试用例设计方法、测试方法、测试工具、测试环境和测试数据进行描述的文档，还可以包括能把某个或某一组测试用例应用到被测软件上完成某项测试的一系列的操作步骤。

设计测试用例应当从以下几方面考虑：边界值，等价类划分，有效/无效值等。

7、什么是软件质量保证？软件质量保证人员与开发人员的关系如何？（高级） (10分)

答：软件质量保证就是通过确保软件过程的质量，来保证软件产品的质量。

软件质量保证人员和开发人员之间具有管理上的严格的独立性，两个小组的管理员都不能越权管理另一组，但都可以向更高层的管理者汇报软件开发中的问题

四、设计题

1）.输入三个整数，判断三个整数能否构成一个三角形，请用黑盒测试方法中的一种设计出相应的测试用例并详细说明所使用的黑盒测试方法。(中高级) (15分)

.NET工程(三)

1.面向对象的思想主要包括什么？

继承多态封装

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

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

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

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

2.什么是ASP.net中的用户控件

用户控件就是.ascx扩展名的东西喽,可以拖到不同的页面中调用,以节省代码.比如登陆可能在多个页面上有,就可以做成用户控件,但是有一个问题就是用户控件拖到不同级别的目录下后里面的图片等的相对路径会变得不准确,需要自已写方法调整.

问这样的问题,一般是迷惑你.因为新手还是分不清楚用户控件和服务器控件(也称自定义控件)..用户控件一般用在内容多为静态,或者少许会改变的情况下..用的比较大..类似ASP中的include..但是功能要强大的多..

在C＃中，string str = null 与 string str = “”的区别。
答：string str = null 是不给他分配内存空间,而string str = "" 给它分配长度为空字符串的内存空间
请详述在dotnet中类(class)与结构(struct)的异同
Class可以被实例化,属于引用类型,是分配在内存的堆上的,Struct属于值类型,是分配在内存的栈上的.

DataReader和DataSet的异同
DataReader和DataSet最大的区别在于,DataReader使用时始终占用SqlConnection,在线操作数据库..任何对SqlConnection的操作都会引发DataReader的异常..因为DataReader每次只在内存中加载一条数据,所以占用的内存是很小的..因为DataReader的特殊性和高性能.所以DataReader是只进的..你读了第一条后就不能再去读取第一条了..
DataSet则是将数据一次性加载在内存中.抛弃数据库连接..读取完毕即放弃数据库连接..因为DataSet将数据全部加载在内存中.所以比较消耗内存...但是确比DataReader要灵活..可以动态的添加行,列,数据.对数据库进行回传更新操作.

8.C#中的接口和类有什么异同。

接口和类都是类，不同的事，接口只包含方法或属性的声明，不包含具体实现方法的代码，接口可以实现多继承，而类只能是单继承，继承接口的类必须实现接口中声明的方法或属性。接口主要定义一种规范，统一调用方法，在大型项目中接口正发挥日益重要的作用

类是方法功能的实现和集合,接口是规范类.约束类.
接口,是可以多继承,类只有单继承.接口强调了你必须实现,而没有具本实现的方法和虚类有点相似

Override与重载有什么区别？
一个是重写父类函数，一个是同一个函数的几种形式

触发器的作用

触发器可以查询其它表，而且可以包含复杂的 SQL 语句。它们主要用于强制复杂的业务规则或要求。触发器还有助于强制引用完整性，以便在添加、更新或删除表中的行时保留表之间已定义的关系。
保证数据库操作变更能接到通知

<%# %> 和 <% %> 有什么区别？
<%# %>表示绑定的数据源
<% %>是服务器端代码块

常见的设计模式

抽象工厂模式、适配器模式、外观模式 command命令模式,桥接模式,组合模式,装饰模式,状态模式,备忘录模式等。
软件设计模式太多，就我的理解简单说一下最常见的MVC模式。
MVC模式是1996年由Buschmann提出的：
模型（Model）：就是封装数据和所有基于对这些数据的操作。
视图（View）：就是封装的是对数据显示，即用户界面。
控制器（Control）：就是封装外界作用于模型的操作和对数据流向的控制等。



3.什么叫应用程序域？什么是受管制的代码？什么是强类型系统？什么是装箱和拆箱？什么是重载？CTS、CLS和CLR分别作何解释？

4.列举一下你所了解的XML技术及其应用

5.值类型和引用类型的区别？写出C#的样例代码。

在dotnet中有两大类数据类型，即值类型和引用类型，值类型存贮在栈中，而引用类型存贮在动态的堆中，栈是先进先出的有系统管理的空间，而堆是由应用程序控制的可随时申请和释放该空间，在Donnet中一般情况下有垃圾收集器处理，他们的不同导致在编程上的不同。
        例：                     StringBuilder a=new StringBuilder();//将StringBuilder的一个首地址传给a
                                     StringBuilder b=a;//将StringBuilder的一个首地址传给b
                                      b.Append("mxh");
                                      Console.WriteLine(a);
                                       a=null;
                                       Console.WriteLine(b);
               输出结果：mxh
                                   mxh
       "a=null"的意思是：a的引用置为空但此时StringBuilder的堆空间并没有被释放，因此在此之后，输出b时，仍然可以输出mxh

6.ADO.net中常用的对象有哪些？分别描述一下。

7.如何理解委托？

C# 中的委托类似于 C 或 C++ 中的函数指针。使用委托使程序员可以将方法引用封装在委托对象内。然后可以将该委托对象传递给可调用所引用方法的代码，而不必在编译时知道将调用哪个方法。与 C 或 C++ 中的函数指针不同，委托是面向对象、类型安全的，并且是安全的。

9.。net中读写数据库需要用到哪些类？他们的作用

10.UDP连接和TCP连接的异同。

11.ASP.net的身份验证方式有哪些？分别是什么原理？

window验证:为每个用户开启window帐号,验证其身份.安全性较高.
forms验证:为每个登陆用户写入一个身份验证票据..在web使用最广的验证方式..灵活方便.

12.进程和线程分别怎么理解？

13.什么是code-Behind技术。

新建一个VS.NET下的项目..看到ASPX,RESX和CS三个后缀的文件了吗??这个就是代码分离.实现了HTML代码和服务器代码分离.方便代码编写和整理.

14.活动目录的作用。

活动目录是window2000的最重要的功能.可以将用户信息全部集成起来,登陆以后可以访问多个不同的网络服务..

15..net中读写XML的类都归属于哪些命名空间？

System.XML类

16.解释一下UDDI、WSDL的意义及其作用。

17.什么是SOAP,有哪些应用。

simple object access protocal,简单对象接受协议.以xml为基本编码结构,建立在已有通信协议上(如http,不过据说ms在搞最底层的架构在tcp/ip上的soap)的一种规范
是微软大力推广的Web Service使用的协议..

18.如何部署一个ASP.net页面。

19.如何理解.net中的垃圾回收机制。

如果发现内存不够,则垃圾回收器,将全部对象作为无效对象(被回收对象),然后先将全局变量,static,处于活动中的局部变量,以及当前CG指针指向的对象放入一个表中.然后
会搜索新列表中的对象所引用的对象.加入列表中,其他没有被加入列表的对象都会被回收.

20.常用的调用webservice方法有哪些？

我一般用的是WSDL..或者web引用..

21列举一下你所了解的XML技术及其应用
.xml可以用来做网页(xslt) xml可以当作数据库 xml可以用来保存对象的系列化
xml用于配置,用于保存静态数据类型.接触XML最多的是web Services..和config

C#中 property 与 attribute的区别，他们各有什么用处，这种机制的好处在哪里？
一个是属性，用于存取类的字段，一个是特性，用来标识类，方法等的附加性质

C#可否对内存进行直接的操作？
可以

维护数据库的完整性、一致性、你喜欢用触发器还是自写业务逻辑？为什么

触发器，性能好，事务性

ADO。NET相对于ADO等主要有什么改进？

新增dataset等，不需要随时保持连接，性能提高

ASP。NET与ASP相比，主要有哪些进步？
asp解释型，aspx编译型，性能提高，有利于保护源码

C#中的委托是什么？事件是不是一种委托？
委托是一种安全的函数指针，事件是一种消息机制

你对XMLHTTP、WEBSERVICE 了解吗？简单描述其特点、作用
xmlhttp可以主动获取远端web代码，类似HttpWebRequest

接口和抽象类有什么区别？你选择使用接口和抽象类的依据是什么？
接口用于规范，抽象类用于共性。

存储过程和函数的区别
存储过程是编译好的存储在数据库的操作，函数不用说了.

事务是什么？
具有原子性特点

游标的作用？如何知道游标已经到了最后？
指示当前记录的位置,检查NULL

触发器分为事前触发和事后触发，这两种触发有和区别。语句级触发和行级触发有何区别。
一个是操作前，一个是操作后

请说明在.net中常用的几种页面间传递参数的方法，并说出他们的优缺点。
session(viewstate) 简单，但易丢失
application 全局
cookie 简单，但可能不支持，可能被伪造
input type="hidden" 简单，可能被伪造
url参数简单，显示于地址栏，长度有限
数据库稳定，安全，但性能相对弱

请说明.net中的错误处理机制，并举例
try catch final

请说出强名的含义
具有自己的key，可以在GAC为公用

请列出c＃中几种循环的方法，并指出他们的不同
for wile foreach

请指出.net中所有类型的基类
object

请指出GAC的含义
全局程序集缓存

值类型与引用类型有什么区别？
值和指针的区别

怎样理解静态变量？
所有实例公用一个的变量

向服务器发送请求有几种方式？
get post

如果在一个B/S结构的系统中需要传递变量值，但是又不能使用Session、Cookie、Application，您有几种方法进行处理？
input type=""
url
数据库

用.net做B/S结构的系统，您是用几层结构来开发，每一层之间的关系以及为什么要这样分层？
三层，表现，逻辑，数据，安全性，维护性

软件开发过程一般有几个阶段？每个阶段的作用？
需求分析，架构设计，代码编写，QA，部署

通过超链接怎样传递中文参数？
URLEncode URLDecode

请编程遍历页面上所有TextBox控件并给它赋值为string.Empty
foreach

有哪几种方法可以实现一个类存取另外一个类的成员函数及属性,并请举列来加以说明和分析.
同一个名称控件直接，或者反射

如果需记录类的实例个数,该如何实现,请写一个简单的类于以证明.
const static int classNum=0;
classNum++;

A类是B类的基类,并且都有自己的构造,析构函数,请举例证明B类从实例化到消亡过程中构造,析构函数的执行过程.
构造先父后子，析够反之

需要实现对一个字符串的处理,首先将该字符串首尾的空格去掉,如果字符串中间还有连续空格的话,仅保留一个空格,即允许字符串中间有多个空格,但连续的空格数不可超过一个.
string inputStr=" xx xx ";
inputStr=Regex.Replace(inputStr.Trim()," *"," ");

在c#中using和new这两个关键字有什么意义，请写出你所知道的意义？

using 指令和语句 new 创建实例 new 隐藏基类中方法
using 引入名称空间或者使用非托管资源
new 新建实例或者隐藏父类方法

谈谈类和结构的区别？
类是引用类型、结构是值类型

什么叫做SQL注入，如何防止？请举例说明。
利用sql关键字对网站进行攻击。过滤关键字'等

下面这段代码输出什么？为什么？
int i=5;
int j=5;
if (Object.ReferenceEquals(i,j))
Console.WriteLine("Equal");
else
Console.WriteLine("Not Equal");

写一个实现对一段字符串翻转的方法，附加一些条件，如其中包括“，”、“.”，对其设计测试用例
inputStr=inputStr.ToCharArray().Reverse().ToString();

什么是反射？
动态获取程序集信息

用Singleton如何写设计模式
static属性里面new ,构造函数private

C#中的垃圾回收机制是怎样的？
三个generation,当每个generation内存满了的时候检查引用，无引用就回收内存

什么是Application Pool？
Web应用，类似Thread Pool，提高并发性能

链表和数组的区别，各有什么优缺点.
一个可以动态增长，一个固定(VB中可以Redim),性能数组教好

什么是友元函数？
friendly声明，可以访问protect级别方法

什么是虚函数？
可以被重写

什么是抽象函数？
必须被重写

什么是内存泄漏，怎样最简单的方法判断被存泄漏 ?
C++,C中忘了释放内存，内存不会再次分配

1SQL Server的两种索引是何形式？索引的作用？索引的优缺点？
cluster和非cluster,加速查找，占用额外控件，维护索引耗费时间

什么是XML？
可扩展标记语言，可以做配置文件，可以传输数据，可以存储数据

简述 private、 protected、 public、 internal 修饰符的访问权限。
private : 私有成员, 在类的内部才可以访问。
protected : 保护成员，该类内部和继承类中可以访问。
public : 公共成员，完全公开，没有访问限制。
internal: 在同一命名空间内可以访问。

进程和线程的区别

进程是系统进行资源分配和调度的单位；线程是CPU调度和分派的单位，一个进程可以有多个线程，这些线程共享这个进程的资源。

成员变量和成员函数前加static的作用

它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数。分别用来反映类的状态。比如类成员变量可以用来统计类实例的数量，类成员函数负责这种统计的动作。

malloc和new的区别

new是C++的关键字。malloc在分配内存时必须按给出的字节分配，new可以按照对象的大小自动分配，并且能调用构造函数。可以说new是对象的对象，而malloc不是。本质上new分配内存时，还会在实际内存块的前后加上附加信息，所以new所使用的内存大小比malloc多。

堆和栈的区别

栈：由编译器自动分配、释放。在函数体中定义的变量通常在栈上。
堆：一般由程序员分配释放。用new、malloc等分配内存函数分配得到的就是在堆上。
栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。
栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。

在.Net中，类System.Web.UI.Page 可以被继承么？
可以

你觉得ASP.NET 2.0（VS2005）和你以前使用的开发工具（.Net 1.0或其他）有什么最大的区别？你在以前的平台上使用的哪些开发思想（pattern / architecture）可

1 ASP.NET 2.0 把一些代码进行了封装打包,所以相比1.0相同功能减少了很多代码.
2 同时支持代码分离和页面嵌入服务器端代码两种模式,以前1.0版本,.NET提示帮助只有在分离的代码文件,无法在页面嵌入服务器端代码获得帮助提示,
3 代码和设计界面切换的时候,2.0支持光标定位.这个我比较喜欢
4 在绑定数据,做表的分页.UPDATE,DELETE,等操作都可以可视化操作,方便了初学者
5, 在ASP.NET中增加了40多个新的控件,减少了工作量

.net的错误处理机制是什么
.net错误处理机制采用try->catch->finally结构，发生错误时，层层上抛，直到找到匹配的Catch为止。

重载与覆盖的区别
1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
3、覆盖要求参数列表相同；重载要求参数列表不同。
4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

简要谈一下您对微软.NET 构架下remoting和webservice两项技术的理解以及实际中的应用。
WS主要是可利用HTTP，穿透防火墙。而Remoting可以利用TCP/IP，二进制传送提高效率。

C#中的委托是什么？事件是不是一种委托？
委托是一种安全的函数指针，事件是一种消息机制

new有几种用法
第一种:new Class();
第二种:覆盖方法
public new XXXX(){}
第三种:new 约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。
如何把一个array复制到arrayList里
foreach( object o in array )arrayList.Add(o);
datagrid.datasouse可以连接什么数据源
dataset,datatable,dataview , IList
概述反射和序列化
反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性
序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
概述o/r mapping 的原理>
利用反射，配置将类于数据库表映射
用sealed修饰的类有什么特点
sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其他类的基类，则会发生编译时错误。
密封类不能同时为抽象类。
sealed 修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化。具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数成员的调用可以转换为非虚拟调用来处理。

什么叫应用程序域？什么是受管制的代码？什么是强类型系统？什么是装箱和拆箱？什么是重载？CTS、CLS和CLR分别作何解释？
答:装箱就是把值类型转成引用类型,从MS IL角度看好像是boxing,没记错的话是把值从堆栈转到堆中.拆箱相反,重载就是指一个方法名同,参数个数不同,返回值可以相同的方法.CLR是通用语言运行时,其它的不清楚.
如何理解委托？
答:据说相当于函数指针,定义了委托就可以在不调用原方法名称的情况下调用那个方法.
委托具有以下特点：
委托类似于 C++ 函数指针，但它是类型安全的。
委托允许将方法作为参数进行传递。
委托可用于定义回调方法。
委托可以链接在一起；例如，可以对一个事件调用多个方法。
方法不需要与委托签名精确匹配。有关更多信息，请参见协变和逆变。
C# 2.0 版引入了匿名方法的概念，此类方法允许将代码块作为参数传递，以代替单独定义的方法。
UDP连接和TCP连接的异同。
前者只管传,不管数据到不到,无须建立连接.后者保证传输的数据准确,须要连结.
进程和线程分别怎么理解？
进程是老子,线程是儿子,没有老子就没有儿子,一个老子可以有多个儿子.一个儿子可以成为别人的儿子,一个老子也可以为别的老子生儿子.
什么是SOAP,有哪些应用。
答:SOAP（Simple Object Access Protocol ）简单对象访问协议是在分散或分布式的环境中交换信息并执行远程过程调用的协议，是一个基于XML的协议。使用SOAP，不用考虑任何特定的传输协议（最常用的还是HTTP协议），可以允许任何类型的对象或代码，在任何平台上，以任何一直语言相互通信。这种相互通信采用的是XML格式的消息.

1. 填空: (1)面向对象的语言具有___继承性、封装性、多态性。

(2)能用foreach遍历访问的对象需要实现 IEnumerable接口或声明GetEnumerator 方法的类型

(3)列举ADO.net中的五个主要对象

Command、Connection、DataSet、DataAdapter、DataReader。

2. 不定项选择：

(1) 以下叙述正确的是：

A. 接口中可以有虚方法。 B. 一个类可以实现多个接口。

C. 接口不能被实例化。 D. 接口中可以包含已实现的方法。

(2) 从数据库读取记录，你可能用到的方法有：

A. ExecuteNonQuery B. ExecuteScalar

C. Fill D. ExecuteReader

3. 简述 private、 protected、 public、 internal 修饰符的访问权限。

4. 写出一条Sql语句：取出表A中第31到第40记录（SQLServer, 以自动增长的ID作为主键, 注意：ID

可能不是连续的。）

5 .列举ASP.NET 页面之间传递值的几种方式。

三种比较常见的方式，一种是可以通过用QueryString来传送相应的值，再一种是通过session变量来传送相应的值，还有就是通过Server.Transfer方法来实现

(1)queryString
(2)session
(3)cookie
(4)server.transfer
(5)hidden control/view state
(6)static member.
(7)cache
(8)application
(9)DataBase
(10)xml or other Files
(11)XMLHTTP or Hidden iFrame/frame
(12)Context.user.identity

我正在做一个通用提示叶面，所有叶面出现问题都要，传递几个变量字符串到同一个叶面 hitMsg.aspx 变量字符串包括提示语言，即将跳转的叶面，跳转时间。在1-11种方案中哪个更好些?
(1)queryString的毛病是无法传递很长字符串，比如系统错误信息往往就一整个屏幕。
(2)session的毛病是不能过多使用，依赖Cookie,容易丢失。
(3)cookie的毛病是依赖客户端设置，不可靠。
(4)server.transfer的毛病是接收叶面要为发送叶面准备好，只能定制专门一个叶面接受定制好的叶面。
不能是一个叶面接受任何叶面。
(5)hidden control/view state只能传递本页。除非特殊制作。
(6)static member.无法保证线程安全，可能会此处栽瓜他处得豆。
(7)cache不适合使用一次就扔的变量。
(8)application全局的，开销大。
(9)DataBase全局固化的,开销更大，除非做日志跟踪。
(10)xml or other Files全局固化的,开销大，除非做日志跟踪。
(11)XMLHTTP or Hidden iFrame/frame，做这个过于烦琐。
(12)Context这个占用了用户id，不适合做这个。

6. 写出程序的输出结果

class Class1 {

private string str = "Class1.str";

private int i = 0;

static void StringConvert(string str) {

str = "string being converted.";

}

static void StringConvert(Class1 c) {

c.str = "string being converted.";

}

static void Add(int i) {

i++;

}

static void AddWithRef(ref int i) {

i++;

}

static void Main() {

int i1 = 10;

int i2 = 20;

string str = "str";

Class1 c = new Class1();

Add(i1);

AddWithRef(ref i2);

Add(c.i);

StringConvert(str);

StringConvert(c);

Console.WriteLine(i1);

Console.WriteLine(i2);

Console.WriteLine(c.i);

Console.WriteLine(str);

Console.WriteLine(c.str);

}

7.写出程序的输出结果

public abstract class A

{

public A()

{

Console.WriteLine('A');

}

public virtual void Fun()

{

Console.WriteLine("A.Fun()");

}

public class B: A

{

public B()

{

Console.WriteLine('B');

}

public new void Fun()

{

Console.WriteLine("B.Fun()");

}

public static void Main()

{

A a = new B();

a.Fun();

}

8. 写出程序的输出结果：

public class A

{

public virtual void Fun1(int i)

{

Console.WriteLine(i);

}

public void Fun2(A a)

{

a.Fun1(1);

Fun1(5);

}

public class B : A

{

public override void Fun1(int i)

{

base.Fun1 (i + 1);

}

public static void Main()

{

B b = new B();

A a = new A();

a.Fun2(b);

b.Fun2(a);

}

9. 一列数的规则如下: 1、1、2、3、5、8、13、21、34......

求第30位数是多少，用递归算法实现。(C#语言)

-------------------------------------------

a0 = 0,a1 = 1,An = An-1 + An-2(n>=2)
int[] iArray = new int[31];
iArray[0] = 0;
iArray[1] = 1;

for (int i = 2; i <= 30; i++)
{
iArray[i] = iArray[i - 1] + iArray[i - 2];
}
---------------参考答案二---------------------------------

int i=0,ii=1,s=1,num=0;
while(num<=30)
{
s=i+ii;
Response.Write(i+"+"+ii+"="+s+"<br>");
if(s==1)
{
i=1;
}
else
{
i=s-i;
}
ii=s;
num++;
}

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

10. 程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。(C#语言)

要求： 1.要有联动性，老鼠和主人的行为是被动的。

2.考虑可扩展性，猫的叫声可能引起其他联动效应。

三个类,猫,老鼠和主人

猫

public sealed class Cat

{

// 猫叫时引发的事件

public event EventHandler Calling;

public void Call()

{

Console.WrietLine("猫叫了...");

if(Calling != null) // 检查是否有事件注册

Calling(this, EventArgs.Empty); // 调用事件注册的方法。

}

// 老鼠，提供一个方法表示逃跑

public sealed calss Mouse

{

public void Escape(object sender, EventArgs e)

{

Console.WriteLine("老鼠逃跑了...");

}

// 主人，发生猫叫的时候惊醒

public sealed class Master

{

public void Wakened(object sender, EventArgs e)

{

Console.WriteLine("主人惊醒了...);

}

// 用于测试的执行方法

// 程序入口点

public static Program

{

public static int Main(string[] args)

{

// 建立猫

Cat cat = new Cat();

// 建立老鼠

Mouse mouse = new Mouse();

// 建立主人

Master master = new Master();

// 注册事件

cat.Calling += new EventHandler(mouse.Escape);

cat.Calling += new EventHandler(master.Wakened);

// 猫开始叫

cat.Call();

}

要点：1. 联动效果，运行代码只要执行Cat.Cryed()方法。2. 对老鼠和主人进行抽象
评分标准: <1>.构造出Cat、Mouse、Master三个类，并能使程序运行(2分)
<2>从Mouse和Master中提取抽象（5分）
<3>联动效应，只要执行Cat.Cryed()就可以使老鼠逃跑，主人惊醒。(3分)

    public interface Observer
    {
        void Response();    //观察者的响应，如是老鼠见到猫的反映
    }
    public interface Subject
    {
        void AimAt(Observer obs); //针对哪些观察者，这里指猫的要扑捉的对象---老鼠
    }
    public class Mouse : Observer
    {
        private string name;
        public Mouse(string name, Subject subj)
        {
            this.name = name;
            subj.AimAt(this);
        }

        public void Response()
        {
            Console.WriteLine(name + " attempt to escape!");
        }
    }
    public class Master : Observer
    {
        public Master(Subject subj)
        {
            subj.AimAt(this);
        }

        public void Response()
        {
            Console.WriteLine("Host waken!");
        }
    }

    public class Cat : Subject
    {
        private ArrayList observers;
        public Cat()
        {
            this.observers = new ArrayList();
        }
        public void AimAt(Observer obs)
        {
            this.observers.Add(obs);
        }
        public void Cry()
        {
            Console.WriteLine("Cat cryed!");
            foreach (Observer obs in this.observers)
            {
                obs.Response();
            }
        }
    }
    class MainClass
    {
        static void Main(string[] args)
        {
            Cat cat = new Cat();
            Mouse mouse1 = new Mouse("mouse1", cat);
            Mouse mouse2 = new Mouse("mouse2", cat);
            Master master = new Master(cat);
            cat.Cry();
        }
    }

-----------------------------

问题：

1．ASP.NET中的身份验证有那些？你当前项目采用什么方式验证请解释

Windows | Forms | Passport

2．什么是WEB控件？使用WEB控件有那些优势？

3．请解释ASP。NET中以什么方式进行数据验证？

4．请谈谈对正则表达式的看法？

5．ASP。NET中共有几种类型的控件？各有什么区别？

6．WEB控件可以激法服务端事件，请谈谈服务端事件是怎么发生并解释其原理？自动传回是什么？为什么要使用自动传回。

7．WEB控件及HTML服务端控件能否调用客户端方法？如果能，请解释如何调用？

8．ASP。NET与ASP相比有什么优势？

9．请解释web.config文件中的重要节点

10．请解释ASP。NET中的web页面与其隐藏类之间的关系？

11．什么是viewstate，能否禁用？是否所用控件都可以禁用?

13．当发现不能读取页面上的输入的数据时很有可能是什么原因造成的？怎么解决

14．请解释一个WEB页面中代码执行次序。

15．请解释什么是上下文对象，在什么情况下要使用上下文对象

16．请解释转发与跳转的区别？

17．请解释ASP.NET中不同页面之间数据传递有那些方式？

18．请解释ASP。NET中button linkbutton imagebutton 及hyperlink这四个控件之间的功别

19．请解释一下。NET多层应用程序中层与层之间以那几种方式进行数据传递。并解释你自己的项目中采用那种方式进行。

20．如果出现ASP。NET中的事件不能触发可能由于什么原因造成？

21．如果需要在datagride控件中的某一列中添加下拉列表框并绑定数据怎么解决？

22．请解释asp.net中的数据绑定与传统数据绑定有什么区别？

23．请解释.net采用委托实现的事件模型与JAVA中采用接口实现的事件模型有什么区别，以图示方式解释。

24．请解释接口的显式实现有什么意义？

Q：您在什么情况下会用到虚方法？它与接口有什么不同？

Q：值类型与引用类型有什么区别？

Q：怎样理解静态变量？

Q：向服务器发送请求有几种方式？

Q：如果在一个B/S结构的系统中需要传递变量值，但是又不能使用Session、Cookie、Application，您有几种方法进行处理？

Q：用.net做B/S结构的系统，您是用几层结构来开发，每一层之间的关系以及为什么要这样分层？

Q：软件开发过程一般有几个阶段？每个阶段的作用？

需求分析，概要设计，详细设计，软件编码，软件测试

一，可行性分析
二，需求分析
三，实施和编码
四，测试
五，维护

Q：微软推出了一系列的Application Block，请举出您所知道的Application Block并说明其作用？

Q：请列举一些您用到过的设计模式以及在什么情况下使用该模式？

Q：您对WebService的体会？

以下几道题目如果您不会，请较为详细的描述您的解决思路和方法

Q：通过超链接怎样传递中文参数？

Q：请编程遍历页面上所有TextBox控件并给它赋值为string.Empty？

For(i=0;i<this.control.count;i++)

If(control is TextBox)

{

(control as TextBox).Text = string.Empty;

}

Q：请编程实现一个冒泡排序算法？

using System;

namespace BubbleSorter

{

public class BubbleSorter

{

public void Sort(int [] list)

{

int i,j,temp;

bool done=false;

j=1;

while((j<list.Length)&&(!done))

{

done=true;

for(i=0;i<list.Length-j;i++)

{

if(list[i]>list[i+1])

{

done=false;

temp=list[i];

list[i]=list[i+1];

list[i+1]=temp;

}

j++;

}

public class MainClass

{

public static void Main()

{

int[] iArrary=new int[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47};

BubbleSorter sh=new BubbleSorter();

sh.Sort(iArrary);

for(int m=0;m<iArrary.Length;m++)

Console.Write("{0} ",iArrary[m]);

Console.WriteLine();

}

.NET技术(四)

[.NET(C#)]
把attribute翻译成特性，用来标识类，方法
把property翻译为属性,性质,用于存取类的字段
把markup翻译成标记，tag还是翻译成标签比较好

[.NET(C#)]
.NET Framework的核心是其运行库的执行环境。
称为公共语言运行库（CLR）或.NET运行库.
通常将在CLR的控制下运行的代码称为托管代码（managed code).
在CLR执行开发的源代码之前，需要编译它们为中间语言（IL），CLR再把IL编译为平台专用的代码。

程序集(assembly)是包含编译好的,面向.NET Framework的代码的逻辑单元.
可执行代码和库代码使用相同的程序集结构.
程序集的一个重要特性是它们包含的元数据描述了对应代码中定义的类型和方法.

[.NET(C#)]
ASP页面有时显示比较慢，因为服务器端代码是解释性的不是编译的.
由于ASP代码不是结构化的所以难于维护，加上ASP不支持错误处理和语法检查。
而ASP.NET页面是结构化的。每个页面都是一个继承了.NET类System.Web.UI.Page的类。
另外ASP.NET的后台编码功能允许进一步采用结构化的方式.
页面请求是和WEB服务器在编译后高速缓存ASP.NET页面。

[.NET(C#)]
覆盖（override）和重载（overload）:
覆盖是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
其实，重载的概念并不属于“面向对象编程”，
重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰
然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。
如，有两个同名函数：function func(p:integer):integer; 和function func(p:string):integer;。
那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。
对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。
也就是说，它们的地址在编译期就绑定了（早绑定），
因此，重载和多态无关！真正和多态相关的是“覆盖”。
当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，
这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。
因此，这样的函数地址是在运行期绑定的（晚邦定）。
结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！

[.NET(C#)]
C#中ref和out的区别:
方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。
当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
当希望方法返回多个值时，声明 out 方法非常有用。
使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。
若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。
属性不是变量，不能作为 out 参数传递。

方法参数上的 ref 方法参数关键字使方法引用传递到方法的同一个变量。
当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
若要使用 ref 参数，必须将参数作为 ref 参数显式传递到方法。
ref 参数的值被传递到 ref 参数。传递到 ref 参数的参数必须最先初始化。
将此方法与 out 参数相比，后者的参数在传递到 out 参数之前不必显式初始化。
属性不是变量，不能作为 ref 参数传递。

两者都是按地址传递的，使用后都将改变原来的数值。
ref可以把参数的数值传递进函数，但是out是要把参数清空
就是说你无法把一个数值从out传递进去的，out进去后，参数的数值为空,所以你必须初始化一次。
两个的区别:ref是有进有出，out是只出不进。

[.NET(C#)]
ADO和ADO.NET的区别:
ADO使用OLE DB接口并基于微软的COM技术
而ADO.NET拥有自己的ADO.NET接口并且基于微软的.NET体系架构。
ADO以Recordset存储，而ADO.NET则以DataSet表示。
Recordset看起来更像单表，如果让Recordset以多表的方式表示就必须在SQL中进行多表连接。
反之，DataSet可以是多个表的集合。ADO 的运作是一种在线方式，这意味着不论是浏览或更新数据都必须是实时的。
ADO.NET则使用离线方式，在访问数据的时候ADO.NET会利用XML制作数据的一份幅本
ADO.NET的数据库连接也只有在这段时间需要在线。
　　
由于ADO使用COM技术，这就要求所使用的数据类型必须符合COM规范
而ADO.NET基于XML格式，数据类型更为丰富并且不需要再做COM编排导致的数据类型转换，从而提高了整体性能。
ADO.NET为.NET构架提供了优化的数据访问模型，和基于COM的ADO是完全两样的数据访问方式。

ado.net与ado存在着比较大的差异：
1．ado.net遵循更通用的原则，不那么专门面向数据库。
ado.net集合了所有允许数据处理的类。这些类表示具有典型数据库功能（如索引，排序和视图）的数据容器对象。
尽管ado.net是.net数据库应用程序的权威解决方案
但从总体设计上看，它不像ado数据模型那样以数据库为中心，这是ado.net的一大特点。
2．目前，ado.net提供了两种数据库访问类库：一种用于sql server 7.0 或更高版本
另一种用于其他所有您可能已经安装的ole db提供程序。
在这两种情况下，您分别使用不同的类，但遵循相似的命名规则。
除前缀，名称都是相同的。前一种情况前缀为sql，后一种情况则是oledb。
同时，.net框架还提供了odbc .net的数据访问模式。
odbc .net data provider是 .net 框架的增强组件，它可以访问原始的 odbc 驱动程序
就像 ole db .net data provider 可以访问原始的 ole db providers 一样。
目前它仅在下列驱动程序中测试过：
microsoft sql odbc driver，microsoft odbc driver for oracle，microsoft jet odbc driver。
3．ado.net提供了两个队形来处理从数据源中抽取数据，它们是dataset和datareader对象。
前者是记录在内存中的缓存，您可以从任何方向随意访问和修改。
后者是高度优化的对象，专为以仅向前方式滚动只读记录而设计。
4．ado.net统一了数据容器类编程接口，无论您打算编写何种应用程序，windows窗体，web窗体还是web服务
都可以通过同一组类来处理数据。
不管在后端的数据源数sql server数据库，ole db，xml文件还是一个数组
您都可以通过相同的方法和属性来滚动和处理它们的内容。
5．在ado中，xml只不过是输入和输出格式。
然而在ado.net中，xml是一种数据格式，提供了操作，组织，共享和传递数据的手段。

ADO。NET相对于ADO等主要有什么改进？
1:ado.net不依赖于ole db提供程序,而是使用.net托管提供的程序,
2:不使用com
3:不在支持动态游标和服务器端游
4:,可以断开connection而保留当前数据集可用
5:强类型转换
6:xml支持

[.NET(C#)]
new 关键字用法
(1)new 运算符用于创建对象和调用构造函数。
(2)new 修饰符用于向基类成员隐藏继承成员。
(3)new 约束用于在泛型声明中约束可能用作类型参数的参数的类型。
指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。

[.NET(C#)]
C#中，string str = null 与 string str ="",说明区别。
string str =""初始化对象分配空间
而string str=null初始化对象

[.NET(C#)]
DataGrid的Datasouse可以连接什么数据源
DataTable DataView DataSet DataViewManager 任何实现IListSource接口的组件任何实现IList接口的组件

[.NET(C#)]
概述反射和序列化
反射:公共语言运行库加载器管理应用程序域。
这种管理包括将每个程序集加载到相应的应用程序域以及控制每个程序集中类型层次结构的内存布局。
程序集包含模块，而模块包含类型，类型又包含成员。
反射则提供了封装程序集、模块和类型的对象。
您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。
然后，可以调用类型的方法或访问其字段和属性。

序列化:序列化是将对象状态转换为可保持或传输的格式的过程。
与序列化相对的是反序列化，它将流转换为对象。
这两个过程结合起来，可以轻松地存储和传输数据。

[.NET(C#)]
可访问性级别有哪几种
public 访问不受限制。
protected 访问仅限于包含类或从包含类派生的类型。
internal 访问仅限于当前程序集。
protected internal 访问仅限于从包含类派生的当前程序集或类型。
private 访问仅限于包含类型。

[.NET(C#)]
O/R Mapping 的原理:利用反射，配置将对象和数据库表映射。

[.NET(C#)]
sealed 修饰符有什么特点?
sealed 修饰符表示密封,用于类时，表示该类不能再被继承
不能和 abstract 同时使用，因为这两个修饰符在含义上互相排斥
用于方法和属性时，表示该方法或属性不能再被继承，必须和 override 关键字一起使用
因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员
通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱
恰当的利用 sealed 修饰符也可以提高一定的运行效率，因为不用考虑继承类会重写该成员

[.NET(C#)]
详述.NET里class和struct的异同
结构与类共享几乎所有相同的语法，但结构比类受到的限制更多：
尽管结构的静态字段可以初始化，结构实例字段声明还是不能使用初始值设定项。
结构不能声明默认构造函数（没有参数的构造函数）或析构函数。
结构的副本由编译器自动创建和销毁，因此不需要使用默认构造函数和析构函数。
实际上，编译器通过为所有字段赋予默认值（参见默认值表）来实现默认构造函数。
结构不能从类或其他结构继承。
结构是值类型 -- 如果从结构创建一个对象并将该对象赋给某个变量，变量则包含结构的全部值。
复制包含结构的变量时，将复制所有数据，对新副本所做的任何修改都不会改变旧副本的数据。
由于结构不使用引用，因此结构没有标识 -- 具有相同数据的两个值类型实例是无法区分的。
C# 中的所有值类型本质上都继承自 ValueType，后者继承自 Object。
编译器可以在一个称为装箱的过程中将值类型转换为引用类型。

结构具有以下特点：
结构是值类型，而类是引用类型。
向方法传递结构时，结构是通过传值方式传递的，而不是作为引用传递的。
与类不同，结构的实例化可以不使用 new 运算符。
结构可以声明构造函数，但它们必须带参数。
一个结构不能从另一个结构或类继承，而且不能作为一个类的基。
所有结构都直接继承自 System.ValueType，后者继承自 System.Object。
结构可以实现接口。
在结构中初始化实例字段是错误的。

类与结构的差别
1. 值类型与引用类型
结构是值类型：值类型在堆栈上分配地址，所有的基类型都是结构类型
例如：int 对应System.int32 结构，string 对应 system.string 结构，通过使用结构可以创建更多的值类型
类是引用类型：引用类型在堆上分配地址堆栈的执行效率要比堆的执行效率高
可是堆栈的资源有限，不适合处理大的逻辑复杂的对象。
所以结构处理作为基类型对待的小对象，而类处理某个商业逻辑
因为结构是值类型所以结构之间的赋值可以创建新的结构，而类是引用类型，类之间的赋值只是复制引用注：
1.虽然结构与类的类型不一样，可是他们的基类型都是对象（object）,c#中所有类型的基类型都是object
2.虽然结构的初始化也使用了New 操作符可是结构对象依然分配在堆栈上而不是堆上
如果不使用“新建”(new)，那么在初始化所有字段之前，字段将保持未赋值状态，且对象不可用
2．继承性
结构：不能从另外一个结构或者类继承，本身也不能被继承
虽然结构没有明确的用sealed声明，可是结构是隐式的sealed .
类：完全可扩展的，除非显示的声明sealed 否则类可以继承其他类和接口，自身也能被继承
注：虽然结构不能被继承可是结构能够继承接口，方法和类继承接口一样
例如:结构实现接口
interface IImage
{
void Paint();
}
struct Picture : IImage
{
public void Paint()
{
// painting code goes here
}
private int x, y, z; // other struct members
}

3．内部结构：
结构：
没有默认的构造函数，但是可以添加构造函数
没有析构函数
没有 abstract 和 sealed(因为不能继承)
不能有protected 修饰符
可以不使用new 初始化
在结构中初始化实例字段是错误的
类：
有默认的构造函数
有析构函数
可以使用 abstract 和 sealed
有protected 修饰符
必须使用new 初始化

[.NET(C#)]
如何选择结构还是类
1．堆栈的空间有限，对于大量的逻辑的对象，创建类要比创建结构好一些
2．结构表示如点、矩形和颜色这样的轻量对象
例如，如果声明一个含有 1000 个点对象的数组，则将为引用每个对象分配附加的内存。
在此情况下，结构的成本较低。
3．在表现抽象和多级别的对象层次时，类是最好的选择
4．大多数情况下该类型只是一些数据时，结构时最佳的选择

[.NET(C#)]
abstract class和interface有什么区别?
答：声明方法的存在而不去实现它的类被叫做抽像类（abstract class）
它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。
不能创建abstract 类的实例。
然而可以创建一个变量，其类型是一个抽像类，并让它指向具体子类的一个实例。
不能有抽像构造函数或抽像静态方法。
Abstract 类的子类为它们父类中的所有抽像方法提供实现，否则它们也是抽像类。
取而代之，在子类中实现该方法。
知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽像类的变体。
在接口中，所有方法都是抽像的。
多继承性可通过实现这样的接口而获得。
接口中的所有方法都是抽像的，没有一个有程序体。
接口只可以定义static final成员变量。
接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。

当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。
然后，它可以在实现了该接口的类的任何对像上调用接口的方法。
由于有抽像类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。
引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

接口可以继承接口。
抽像类可以实现(implements)接口
抽像类是否可继承实体类(concrete class)，但前提是实体类必须有明确的构造函数。

[.NET(C#)]
什么叫应用程序域？什么是托管代码？什么是强类型系统？
什么是装箱和拆箱？什么是重载？CTS、CLS和CLR分别作何解释？

应用程序域:
应用程序域为安全性、可靠性、版本控制以及卸载程序集提供了隔离边界。
应用程序域通常由运行库宿主创建，运行库宿主负责在运行应用程序之前引导公共语言运行库。
应用程序域提供了一个更安全、用途更广的处理单元，公共语言运行库可使用该单元提供应用程序之间的隔离。
应用程序域可以理解为一种轻量级进程。起到安全的作用。占用资源小。

托管代码:
使用基于公共语言运行库的语言编译器开发的代码称为托管代码；托管代码具有许多优点，
例如：跨语言集成、跨语言异常处理、增强的安全性、版本控制和部署支持、简化的组件交互模型、调试和分析服务等。

装箱和拆箱:
从值类型接口转换到引用类型：装箱。
从引用类型转换到值类型：拆箱。
装箱和拆箱使值类型能够被视为对象。
对值类型装箱将把该值类型打包到 Object 引用类型的一个实例中。
这使得值类型可以存储于垃圾回收堆中。
拆箱将从对象中提取值类型。

重载:
每个类型成员都有一个唯一的签名。
方法签名由方法名称和一个参数列表（方法的参数的顺序和类型）组成。
只要签名不同，就可以在一种类型内定义具有相同名称的多种方法。
当定义两种或多种具有相同名称的方法时，就称作重载。

CTS通用类型系统 (common type system) :
一种确定公共语言运行库如何定义、使用和管理类型的规范。

CLR公共语言运行库:
.NET Framework 提供了一个称为公共语言运行库的运行时环境.
它运行代码并提供使开发过程更轻松的服务。

CLS公共语言规范:
要和其他对象完全交互，而不管这些对象是以何种语言实现的.
对象必须只向调用方公开那些它们必须与之互用的所有语言的通用功能。
为此定义了公共语言规范 (CLS)，它是许多应用程序所需的一套基本语言功能。

强类型:
C# 是强类型语言；因此每个变量和对象都必须具有声明类型。

[.NET(C#)]
值类型和引用类型的区别？
基于值类型的变量直接包含值。
将一个值类型变量赋给另一个值类型变量时，将复制包含的值。
这与引用类型变量的赋值不同，引用类型变量的赋值只复制对对象的引用，而不复制对象本身。

所有的值类型均隐式派生自 System.ValueType。
与引用类型不同，从值类型不可能派生出新的类型。但与引用类型相同的是，结构也可以实现接口。
与引用类型不同，值类型不可能包含 null 值。然而，可空类型功能允许将 null 赋给值类型。
每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。
值类型主要由两类组成：结构、枚举
结构分为以下几类：
Numeric（数值）类型、整型、浮点型、decimal、bool、用户定义的结构。
引用类型的变量又称为对象，可存储对实际数据的引用。
声明引用类型的关键字：class、interface、delegate、内置引用类型： object、string

                    值类型                   引用类型

内存分配地点     分配在栈中                  分配在堆中
效率           效率高，不需要地址转换          效率低，需要进行地址转换
内存回收        使用完后，立即回收             使用完后，不是立即回收，等待GC回收
赋值操作         进行复制，创建一个同值新对象   只是对原有对象的引用
函数参数与返回值是对象的复制                 是原有对象的引用，并不产生新的对象
类型扩展   不易扩展    容易扩展，方便与类型扩展

[.NET(C#)]
如何理解委托
委托类似于 C++ 函数指针，但它是类型安全的。
委托允许将方法作为参数进行传递。
委托可用于定义回调方法。
委托可以链接在一起；例如，可以对一个事件调用多个方法。
方法不需要与委托签名精确匹配。有关更多信息，请参见协变和逆变。
C# 2.0 版引入了匿名方法的概念，此类方法允许将代码块作为参数传递，以代替单独定义的方法。

[.NET(C#)]
C#中的接口和类有什么异同。
异：
不能直接实例化接口。
接口不包含方法的实现。
接口、类和结构可从多个接口继承。
但是C# 只支持单继承：类只能从一个基类继承实现。
类定义可在不同的源文件之间进行拆分。

同：
接口、类和结构可从多个接口继承。
接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。
接口可以包含事件、索引器、方法和属性。
一个类可以实现多个接口。

[.NET(C#)]
ASP.net的身份验证方式有哪些
Windows 身份验证提供程序
提供有关如何将 Windows 身份验证与 Microsoft Internet 信息服务 (IIS) 身份验证
结合使用来确保 ASP.NET 应用程序安全的信息。

Forms 身份验证提供程序
提供有关如何使用您自己的代码创建应用程序特定的登录窗体并执行身份验证的信息。
使用 Forms 身份验证的一种简便方法是使用 ASP.NET 成员资格和 ASP.NET 登录控件
它们一起提供了一种只需少量或无需代码就可以收集、验证和管理用户凭据的方法。

Passport 身份验证提供程序
提供有关由 Microsoft 提供的集中身份验证服务的信息，该服务为成员站点提供单一登录和核心配置

[.NET(C#)]
活动目录的作用
Active Directory存储了有关网络对象的信息，并且让管理员和用户能够轻松地查找和使用这些信息。
Active Directory使用了一种结构化的数据存储方式，并以此作为基础对目录信息进行合乎逻辑的分层组织。

[.NET(C#)]
解释一下UDDI、WSDL的意义及其作用
UDDI:统一描述、发现和集成协议(UDDI, Universal Description, Discovery and Integration)
是一套基于Web的、分布式的、为Web服务提供的信息注册中心的实现标准规范，
同时也包含一组使企业能将自身提供的Web服务注册以使得别的企业能够发现的访问协议的实现标准。
UDDI 提供了一组基于标准的规范用于描述和发现服务，还提供了一组基于因特网的实现。

WSDL:WSDL描述Web服务的公共接口。
这是一个基于XML的关于如何与Web服务通讯和使用的服务描述；
服务 URL 和命名空间
网络服务的类型
（可能还包括 SOAP 的函数调用，正像我所说过的，WSDL 足够自如地去描述网络服务的广泛内容）
有效函数列表
每个函数的参数
每个参数的类型
每个函数的返回值及其数据类型

[.NET(C#)]
什么是SOAP,有哪些应用。
答:SOAP（Simple Object Access Protocol ）简单对象访问协议
是在分散或分布式的环境中交换信息并执行远程过程调用的协议，是一个基于XML的协议。
使用SOAP，不用考虑任何特定的传输协议（最常用的还是HTTP协议）
可以允许任何类型的对象或代码，在任何平台上，以任何一直语言相互通信。
这种相互通信采用的是XML格式的消息。

SOAP也被称作XMLP，为两个程序交换信息提供了一种标准的工作机制。
在各类机构之间通过电子方式相互协作的情况下完全有必要为此制定相应的标准。

SOAP描述了把消息捆绑为XML的工作方式。
它还说明了发送消息的发送方、消息的内容和地址以及发送消息的时间。
SOAP是Web Service的基本通信协议。
SOAP规范还定义了怎样用XML来描述程序数据（Program Data）,怎样执行RPC（Remote Procedure Call）。
大多数SOAP解决方案都支持RPC-style应用程序。
SOAP还支持 Document-style应用程序（SOAP消息只包含XML文本信息）。

最后SOAP规范还定义了HTTP消息是怎样传输SOAP消息的。
MSMQ、SMTP、TCP/IP都可以做SOAP的传输协议。

SOAP 是一种轻量级协议，用于在分散型、分布式环境中交换结构化信息。
SOAP 利用 XML 技术定义一种可扩展的消息处理框架，它提供了一种可通过多种底层协议进行交换的消息结构。
这种框架的设计思想是要独立于任何一种特定的编程模型和其他特定实现的语义。

SOAP 定义了一种方法以便将 XML 消息从 A 点传送到 B 点。
为此，它提供了一种基于 XML 且具有以下特性的消息处理框架：
1) 可扩展
2) 可通过多种底层网络协议使用
3) 独立于编程模型。

[.NET(C#)]
如何部署一个ASP.net页面
VS 2005和VS 2003都有发布机制。
2003可以发布然后再复制部署。
VS2005基本上可以直接部署到对应位置。

[.NET(C#)]
GC是什么? 为什么要有GC?
答：GC是垃圾收集器。
程序员不用担心内存管理，因为垃圾收集器会自动进行管理。
要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()
不过在C#中不能直接实现Finalize方法，而是在析构函数中调用基类的Finalize()方法

[.NET(C#)]
如何理解.net中的垃圾回收机制
.NET Framework 的垃圾回收器管理应用程序的内存分配和释放。
每次您使用 new 运算符创建对象时，运行库都从托管堆为该对象分配内存。
只要托管堆中有地址空间可用，运行库就会继续为新对象分配空间。
但是，内存不是无限大的。最终，垃圾回收器必须执行回收以释放一些内存。
垃圾回收器优化引擎根据正在进行的分配情况确定执行回收的最佳时间。
当垃圾回收器执行回收时，它检查托管堆中不再被应用程序使用的对象并执行必要的操作来回收它们占用的内存。

[.NET(C#)]
列举ASP.NET 页面之间传递值的几种方式。并说出他们的优缺点。
答. 1).使用QueryString, 如....?id=1; response. Redirect()....
2).使用Session变量
3).使用Server.Transfer

session(viewstate) 简单，但易丢失
application   全局
cookie    简单，但可能不支持，可能被伪造
input ttype="hidden" 简单，可能被伪造
url   参数简单，显示于地址栏，长度有限数据库稳定，安全，但性能相对弱

[.NET(C#)]
C#中索引器的实现过程，可以用任何类型进行索引？（比如数字）

[.NET(C#)]
CTS、CLS、CLR分别作何解释？
CTS：通用语言系统。
CLS：通用语言规范。
CLR：公共语言运行库。

[.NET(C#)]
.net中读写数据库需要用到那些类？他们的作用？
DataSet: 数据存储器。
DataCommand: 执行语句命令。
DataAdapter: 数据的集合，用语填充。

[.NET(C#)]
在.net中，配件的意思是：程序集。（中间语言，源数据，资源，装配清单）

[.NET(C#)]
常用的调用WebService的方法有哪些？
答：1.使用WSDL.exe命令行工具。
2.使用VS.NET中的Add Web Reference菜单选项

[.NET(C#)]
微软.NET 构架下remoting和webservice两项技术的理解以及实际中的应用。
.net Remoting 的工作原理是：服务器端向客户端发送一个进程编号，一个程序域编号，以确定对象的位置。
WS主要是可利用HTTP，穿透防火墙。而Remoting可以利用TCP/IP，二进制传送提高效率。
remoting是.net中用来跨越machine,process,appdomain进行方法调用的技术
对于三成结构的程序，就可以使用remoting技术来构建．
它是分布应用的基础技术.相当于以前的DCOM
Web Service是一种构建应用程序的普通模型
并能在所有支持internet网通讯的操作系统上实施。
Web Service令基于组件的开发和web的结合达到最佳

[.NET(C#)]
启动一个线程是用run()还是start()?
答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态。
这意味着它可以由JVM调度并执行。
这并不意味着线程就会立即运行。
run()方法可以产生必须退出的标志来停止一个线程。

[.NET(C#)]
构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

[.NET(C#)]
abstract的method不可同时是static,不可同时是native，不可同时是synchronized

[.NET(C#)]
final, finally, finalize的区别。
final：修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
因此一个类不能既被声明为 abstract的，又被声明为final的。
将变量或方法声明为final，可以保证它们在使用中不被改变。
被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
被声明为 final的方法也同样只能使用，不能重载
finally：在异常处理时提供 finally 块来执行任何清除操作。
  如果抛出一个异常，那么相匹配的 catch 子句就会执行.
  然后控制就会进入 finally 块（如果有的话）。
finalize：方法名。
  Java 技术允许使用 finalize() 方法在垃圾收集器将对像从内存中清除出去之前做必要的清理工作。
  这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。
  它是在 Object 类中定义的，因此所有的类都继承了它。
  子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。
  finalize() 方法是在垃圾收集器删除对像之前对这个对象调用的。

[.NET(C#)]
进程和线程的区别：
进程是系统进行资源分配和调度的单位；
线程是CPU调度和分派的单位.
一个进程可以有多个线程，这些线程共享这个进程的资源。

[.NET(C#)]
堆和栈的区别:
栈：由编译器自动分配、释放。在函数体中定义的变量通常在栈上。
堆：一般由程序员分配释放。用new、malloc等分配内存函数分配得到的就是在堆上。

[.NET(C#)]
成员变量和成员函数前加static的作用：
它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数。
分别用来反映类的状态。
比如类成员变量可以用来统计类实例的数量，类成员函数负责这种统计的动作。

[.NET(C#)]
在c#中using和new这两个关键字有什么意义:
using 引入名称空间或者使用非托管资源
new 新建实例或者隐藏父类方法

[.NET(C#)]
XML即可扩展标记语言。
eXtensible Markup Language.标记是指计算机所能理解的信息符号
通过此种标记，计算机之间可以处理包含各种信息的文章等。
如何定义这些标记，即可以选择国际通用的标记语言
比如HTML，也可以使用象XML这样由相关人士自由决定的标记语言，这就是语言的可扩展性。
XML是从SGML中简化修改出来的。它主要用到的有XML、XSL和XPath等。

[.NET(C#)]
什么是code-Behind技术。
答：ASPX,RESX和CS三个后缀的文件，这个就是代码分离.
实现了HTML代码和服务器代码分离.方便代码编写和整理.

[.NET(C#)]
XML 与 HTML 的主要区别
1. XML是区分大小写字母的，HTML不区分。
2. 在HTML中，如果上下文清楚地显示出段落或者列表键在何处结尾，
那么你可以省略</p>或者</li>之类的结束标记。
在XML中，绝对不能省略掉结束标记。
3. 在XML中，拥有单个标记而没有匹配的结束标记的元素必须用一个 / 字符作为结尾。
这样分析器就知道不用查找结束标记了。
4. 在XML中，属性值必须分装在引号中。在HTML中，引号是可用可不用的。
5. 在HTML中，可以拥有不带值的属性名。在XML中，所有的属性都必须带有相应的值。

[.NET(C#)]
.net的错误处理机制是什么？
答：.net错误处理机制采用try->catch->finally结构.
发生错误时，层层上抛，直到找到匹配的Catch为止。

[.NET(C#)]
Static Nested Class 和 Inner Class的不同:
Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。
而通常的内部类需要在外部类实例化后才能实例化。

[.NET(C#)]
error和exception有什么区别:
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。
不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。
也就是说，它表示如果程序运行正常，从不会发生的情况。

[.NET(C#)]
UDP连接和TCP连接的异同:
前者只管传,不管数据到不到,无须建立连接.后者保证传输的数据准确,须要连结.

[.NET(C#)]
C#中所有对象共同的基类是:System.Object.

[.NET(C#)]
System.String 和System.StringBuilder有什么区别？
System.String是不可变的字符串。String类是final类故不可以继承。
System.StringBuilder存放了一个可变的字符串，并提供一些对这个字符串修改的方法。

[.NET(C#)]
const和readonly有什么区别？
const 可以用于局部常量
readonly 实际是类的initonly字段，显然不能是局部的。