asp.net一些面试题（转）

基础知识

什么是面向对象

         面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程OOP；

         通俗的解释就是万物皆对象，把全部的事物都看做一个个能够独立的对象(单元)，它们能够本身完成本身的功能，而不是像C那样分红一个个函数；

         如今纯正的OO语言主要是java和C#，C++也支持OO，C是面向过程的。

阐述面向接口、面向对象、面向方面编程的区别

面向对象很差解释，能够理解为以一切元素都是对象，在设计时以对象为单位，考虑它的属性及方法。设计中采用了封装、继承、抽象的手法

面向接口自己就是面向对象的，无所谓区别，只不过面向接口的好处是耦合性低

面向方面Aspect-Oriented Programming (AOP)就是大名鼎鼎的AOP。其实有点象struts里的拦截。

         举例：假设有在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个数据封装在数据对象中，称为Data Class，同时，将有多个访问类，专门用于在同一时刻访问这同一个数据对象。

为了完成上述并发访问同一资源的功能，须要引入锁Lock的概念，也就是说，某个时刻，当有一个访问类访问这个数据对象时，这个数据对象必须上锁Locked，用完后就当即解锁unLocked，再供其它访问类访问。

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

继承：子类拥有父类的全部数据和操做。

封装：用抽象的数据类型将数据和基于数据的操做封装在一块儿，数据被保护在抽象数据类型内。

多态：一个程序中同名的不一样方法共存的状况。有两种形式的多态–重载与重写。

抽象类是否能够继承实体类?

抽象类能够继承实体类，可是有个条件，条件是，实体类必需要有明确的构造函数。

当类T只声明了私有实例构造函数时，则在T的程序文本外部，是否能够从T派生出新的类，是否能够直接建立T的任何实例。

不能够，不能够

C#中有没有静态构造函数，若是有是作什么用的？

    有. 静态构造函数用于初始化类。在建立第一个实例或引用任何静态成员以前，将自动调用静态构造函数来初始化类。静态构造函数既没有访问修饰符，也没有参数。在建立第一个实例或引用任何静态成员以前，将自动调用静态构造函数来初始化类。没法直接调用静态构造函数。在程序中，用户没法控制什么时候执行静态构造函数。静态构造函数的典型用途是：当类使用日志文件时，将使用这种构造函数向日志文件中写入项。

什么是.net?

     .net是一种平台和框架, .net 不是单纯的语言也不是单纯的工具,它是从底层平台开始构建起来的一个总体框架

请以图示方式解释.net framework?

VB   C++   C#   Jscript   …     Common Language Specification     XML Web services   Web Forms   Windows Forms       Data and XML     Base Class Library   CLR   CLI

Visual Studio .NET

程序集与命名空间有什么不一样？

         命名空间是用于避免命名冲突，专用于组织代码，当代码要在其余某个应用程序中重用时，能够下降复杂性。

         程序集是重用代码的一种方式 验证控件

不一样: 能够将相同命名空间中的类部署到不一样的程序集中，也能够命名空间中的类部署到一个程序集中 

命名空间 程序集 有逻辑编译时机制 有物理编译时机制 不是运行时实体 是运行时实体 为源代码元素的名称提供逻辑结构 为可执行文件的运行时提供物理结构

 

什么是WEB控件？使用WEB控件有那些优点？

         WEB控件是能拖放在WEB页面上的控件

         WEB控件分为：内部控件, 列表控件, 复杂控件,

•WEB控件优点:

l  Web 控件是对象,与对象同样，Web 控件拥有方法和属性，而且响应事件

l  一旦将 Web 控件包括在 Web 页中，就能够设置其属性并调用其方法

l  能够为 Web 控件编写服务器端代码以响应在客户端上发生的事件

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

         WEB控件分为：内部控件, 列表控件, 复杂控件, 验证控件

         内部控件：内部控件的使用方法与 HTML 控件相同,它们映射到 HTML 元素并经过使用 runat = "server" 属性在服务器上执行

         列表控件：用于在 Web 页中建立数据列表

         复杂控件：当但愿控件拥有复杂的功能或使用 HTML 元素没法建立的功能丰富的用户界面时，能够使用复杂控件

         验证控件：输入控件的数据须要进行准确性和取值范围方面的检查

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

    因为ASP。NET是Web页面和服务端分离的，所以要产生了服务端事件.

         使用_doPostBack函数可以自动地把客户端的javascript事件转变为一个服务器端的事件

，Asp.net框架自动为咱们处理有关的细节简化工做。

 

     使用自动传回的特性：在检测到一个特定用户动做时,自动传回可以将这个页面传回服务器以处理

事件.

    在web控件发生事件时，客户端采用提交的形式将数据交回服务端，服务端先调用Page_Load事件,而后根据传回的状态信息自动调用服务端事件自动传回是当咱们在点击客户端控件时，采用提交表单的形式将数据直接传回到务端。只有经过自动传回才能实现服务端事件的机制，若是没有自动回传机制就只能调用客户端事件，而不能调用服务端事件

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

    Aps.net 中有非空验证，比较验证，取值范围验证，正则表达式验证及客户自定义验证五大控件，另还有一个集中验证信息处理控件

什么是ASP.Net中的用户控件

用户控件是可以在其中放置标记和 Web 服务器控件的容器。而后，能够将用户控件做为一个单元对待，为其定义属性和方法。

用户控件以。ascx为扩展名，能够拖到不一样的页面中调用，以节省代码。好比登录可能在多个页面上有，就能够作成用户控件，可是有一个问题就是用户控件拖到不一样级别的目录下后里面的图片等的相对路径会变得不许确，须要自已写方法调整。

问这样的问题，通常是迷惑你。由于新手仍是分不清楚用户控件和服务器控件(也称自定义控件)，用户控件通常用在内容多为静态，或者少量会改变的状况下，用的比较大，相似ASP中的include。。可是功能要强大的多。

WEB控件及HTML服务端控件可否调用客户端方法？若是能，请解释如何调用？

能够调用

例如:<asp:TextBox id="TextBox1" onclick="clientfunction();" runat="server"></asp:TextBox>

<INPUT id="Button2" value="Button" name="Button2"runat="server" onclick="clientfunction();">

C#, Java 和 c++的特色，有什么相同的地方，不一样的地方， C#分别从c++和java中吸收了他们那些优势？

C#看起来与Java有着惊人的类似;它包括了诸如单一继承,界面,与Java几乎一样的语法,和编译成中间代码再运行的过程.可是C#与Java有着明显的不一样,它借鉴了Delphi的一个特色,与COM(组件对象模型)是直接集成。

微软c#语言定义主要是从C和C++继承而来的,并且语言中的许多元素也反映了这一点.C#在设计者从C++继承的可选选项方面比Java要普遍一些(好比说 structs),它还增长了本身新的特色(比方说源代码版本定义).

C#从Java继承而来的特色

类：在C#中类的声明与Java很类似。特色看起来与Java相比没有变化.

布尔运算：条件表达式的结果是布尔数据类型,布尔数据类型是这种语言中独立的一种数据类型.从布尔类型到其余类型没有直接的转换过程.布尔常量true和false是C#中的关键字.

错误处理：如Java中那样,经过抛出和捕捉异常对象来管理错误处理过程.

内存管理：由底层.NET框架进行自动内存垃圾回收.

C#从C和C++继承的特色

编译：程序直接编译成标准的二进制可执行形式.

结构体：一个C#的结构体与C++的结构体是类似的,由于它可以包含数据声明和方法.可是,不象C++,C#结构体与类是不一样的并且不支持继承.可是,与Java相同的是,一个结构体能够实现界面.

预编译：C#中存在预编译指令支持条件编译,警告,错误报告和编译行控制. #error

C#独有的特色

中间代码：微软在用户选择什么时候MSIL应该编译成机器码的时候是留了很大的余地.微软公司很当心的声称MSIL不是解释性的,而是被编译成了机器码.它也明白许多--若是不是大多数的话--程序员认为Java程序要不可避免的比C编写的任何东西都要慢.而这种实现方式决定了基于MSIL的程序(指的是用 C#,Visual Basic,"Managed C++"--C++的一个符合CLS的版本--等语言编写的程序)将在性能上超过"解释性的"Java代码.固然,这一点还须要获得事实证实,由于C#和其余生成MSIL的编译器尚未发布.可是Java JIT编译器的广泛存在使得Java和C#在性能上相对相同.象"C#是编译语言而Java是解释性的,"之类的声明只是商业技巧.Java的中间代码和 MSIL都是中间的汇编形式的语言,它们在运行时或其它的时候被编译成机器代码.

命名空间中的声明：当你建立一个程序的时候,你在一个命名空间里建立了一个或多个类.同在这个命名空间里(在类的外面)你还有可能声明界面,枚举类型和结构体.必须使用using关键字来引用其余命名空间的内容.

基本的数据类型：C#拥有比C,C++或者Java更普遍的数据类型.这些类型是bool, byte, ubyte, short, ushort, int, uint, long, ulong, float, double,和decimal.象Java同样,全部这些类型都有一个固定的大小.又象C和C++同样,每一个数据类型都有有符号和无符号两种类型.与 Java相同的是,一个字符变量包含的是一个16位的Unicode字符.C#新的数据类型是decimal数据类型,对于货币数据,它能存放28位10 进制数字.

两个基本类：一个名叫object的类是全部其余类的基类.而一个名叫string的类也象object同样是这个语言的一部分.做为语言的一部分存在乎味着编译器有可能使用它--不管什么时候你在程序中写入一句带引号的字符串,编译器会建立一个string对象来保存它.

参数传递：方法能够被声明接受可变数目的参数.缺省的参数传递方法是对基本数据类型进行值传递.ref关键字能够用来强迫一个变量经过引用传递,这使得一个变量能够接受一个返回值.out关键字也能声明引用传递过程,与ref不一样的地方是,它指明这个参数并不须要初始值.

与COM 的集成：C#对Windows程序最大的卖点可能就是它与COM的无缝集成了,COM就是微软的Win32组件技术.实际上,最终有可能在任何.NET语言里编写COM客户和服务器端.C#编写的类能够子类化一个以存在的COM组件;生成的类也能被做为一个COM组件使用,而后又能使用,比方说, JScript语言子类化它从而获得第三个COM组件.这种现象的结果是致使了一个运行环境的产生,在这个环境里的组件是网络服务,可用用任何.NET语言子类化.

索引下标：一个索引与属性除了不使用属性名来引用类成员而是用一个方括号中的数字来匿名引用(就象用数组下标同样)之外是类似的.

代理和反馈：一个代理对象包括了访问一个特定对象的特定方法所需的信息.只要把它当成一个聪明的方法指针就好了.代理对象能够被移动到另外一个地方,而后能够经过访问它来对已存在的方法进行类型安全的调用.一个反馈方法是代理的特例.event关键字用在将在事件发生的时候被当成代理调用的方法声明中.

在C＃中，string str = null与string str = “”的区别。

string str = null是不给他分配内存空间，而string str = ""给它分配长度为空字符串的内存空

怎样理解静态变量？静态成员和非静态成员的区别？

静态变量属于类，而不属于对象；并对全部对象所享；静态成员在加类的时候就被加载。

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

    静态变量使用 static 修饰符进行声明，静态成员在加类的时候就被加载（在类被实例化时建立，哪一个对），经过类进行访问

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

    一个类的全部实例的同一静态变量都是同一个值，同一个类的不一样实例的同一非静态变量能够是不一样的值

 

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

DataReader和DataSet的异同

DataReader和DataSet最大的区别在于，DataReader使用时始终占用SqlConnection，在线操做数据库，任何对SqlConnection的操做都会引起DataReader的异常，由于DataReader每次只在内存中加载一条数据，因此占用的内存是很小的，由于DataReader的特殊性和高性能。因此DataReader是只进的，你读了第一条后就不能再去读取第一条了。

DataSet则是将数据一次性加载在内存中。抛弃数据库链接，读取完毕即放弃数据库链接，由于DataSet将数据所有加载在内存中。因此比较消耗内存，可是确比DataReader要灵活，能够动态的添加行，列，数据。对数据库进行回传更新操做。

简述静态类和静态成员

         静态类中的成员都必须是静态的。静态类无构造方法，而且是密封类没法被继承。

         静态成员访问时只能经过类名来访问，不能经过对象访问（和JAVA有区别），this也没法访问静态成员。

描述接口的做用

充当类的功能界面，接口里的成员属于抽象描述，必须经过类的实现才能使用。如：某个项目有多个模块组成，每一个模块由一个开发者完成，开发者只需编写完模块功能实现后，留下的接口供其余人使用。其余人在程序中，使用接口时，只需知道接口的功能，不了解如何实现。

当功能模块没法知足须要或功能模块的需求变动时，程序员只需将该功能模块的实现代码进行修改和扩充，而其余调用接口的程序无须改动。接口的这种应用模式成为brige模式（即意图和实现分离）

接口反映了面向对象的多态特征，即经过相同方法获得不一样实现。接口也反映了面向对象的封装特征，使用者能够不清楚接口成员的实现细节。

注意：由于接口成员默认的访问权限是public，因此在实现接口时，类的成员必须为public，且方法名和参数必须一致。

描述抽象类

         用abstract修饰的类。抽象类能够包含实现的成员。未实现的成员隐含的是virtual属性，子类实现时必须用override关键字。

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

     接口是其余类型为确保它们支持某些操做而实现的引用类型。接口从不直接建立并且没有实际的表示形式，其余类型必须转换为接口类型。一个接口定义一个协定。实现接口的类或结构必须遵照其协定。接口能够包含方法、属性、索引器和事件做为成员。

 

在项目中为何使用接口？接口的好处是什么？什么是面向接口开发？

         接口只是一种约束。使用 interface 去定义某些特定的功能，为的是不要将代码写死在自定义类里，以便在系统开发、过后维护、功能扩充 上更有扩展性。

         接口用于描述一组类的公共方法/公共属性. 它不实现任何的方法或属性，只是告诉继承它的类至少要实现哪些功能,继承它的类能够增长本身的方法. 使用接口能够使继承它的类： 命名统一/规范,易于维护。提供永远的接口。 当类增长时，现有接口方法可以知足继承类中的大多数方法，不必从新给新类设计一组方法，也节省了代码，提升了开发效率。

         面向接口开发的好处有结构清晰，类间通讯简单易懂，扩展性好，提升复用性等等。

         面向接口开发就是指面向抽象协议编程，实现者在实现时要严格按协议来办。

接口和类有什么异同。

不一样点：

1、不能直接实例化接口。

二、接口只包含方法或属性的声明，不包含方法的实现。

三、接口能够多继承，类只能单继承。

四、类有分部类的概念，定义可在不一样的源文件之间进行拆分。

五、表达的含义不一样，接口主要定义一种规范，统一调用方法，也就是规范类，约束类，类是方法功能的实现和集合

相同点：

一、接口、类和结构均可以从多个接口继承。

二、接口相似于抽象基类：继承接口的任何非抽象类型都必须实现接口的全部成员。

三、接口和类均可以包含事件、索引器、方法和属性。

您在什么状况下会用到虚方法或抽象类，接口？

         若是某个方法可能性在派生类中会被重写。这时就将该方法写为虚方法。

         抽象类：是一个类型，与派生类之间的关系是一个“ISA”的关系。用来作基类，抽象类不能建立对象，类中包括抽象方法和实例方法。

         接口：是设计一个规范，描述了Can do ；与实现类之间是中”LINE A 的关系，C#中接口不能包含字段访问修饰符。

对比抽象基类和接口的使用 

         抽象类能有具体实现，而接口只定义行为规范，不能有具体实现。一个类只能继承一个父类，但能实现多个接口。 

C#中的接口和抽象类有什么异同。你选择使用接口和抽象类的依据是什么？

         一、继承：接口支持多继承；抽象类不能实现多继承。

         二、表达的概念：接口用于规范，抽象类用于共性。抽象类是一类事物的高度聚合，那么对于继承抽象类的子类来讲，对于抽象类来讲，属于"是"的关系；而接口是定义行为规范，所以对于实现接口的子类来讲，相对于接口来讲，是"行为须要按照接口来完成"。

         三、方法实现：对抽象类中的方法，便可以给出实现部分，也能够不给出；而接口的方法（抽象规则）都不能给出实现部分，接口中方法不能加修饰符。

         四、子类重写：继承类对于二者所涉及方法的实现是不一样的。继承类对于抽象类所定义的抽象方法，能够不用重写，也就是说，能够延用抽象类的方法；而对于接口类所定义的方法或者属性来讲，在继承类中必须重写，给出相应的方法和属性实现。

         五、新增方法的影响：在抽象类中，新增一个方法的话，继承类中能够不用做任何处理；而对于接口来讲，则须要修改继承类，提供新定义的方法。

         六、接口能够做用于值类型（枚举能够实现接口）和引用类型；抽象类只能做用于引用类型。

         七、接口不能包含字段和已实现的方法，接口只包含方法、属性、索引器、事件的签名；抽象类能够定义字段、属性、包含有实现的方法。

         八、接口能够用于支持回调（CallBack）；抽象类不能实现回调，由于继承不支持。

以下给出二者的简单对比表格。

	接口	抽象类
多继承	支持	不支持
类型限制	没有	有，只能是引用类型
方法实现	继承类型中必须给出方法实现	继承类中能够不给出
扩展性	比较麻烦	相对比较灵活
多层继承	比较麻烦，须要借助虚函数	比较灵活

如何选择：

一、看是否须要多继承，若是须要就只能使用接口

二、看你在累里定义的方法是否须要有实现的代码，若是要，就使用抽象类

三、使不一样的类型有共同的特性的时候使用接口，由于它支持多继承，只想从一个类型继承出不一样的行为的子类的时候使用抽象类，能够在基类里有代码实现。
从实现接口和现实抽象类的方法来看，接口是死的，抽象类是活的，固然实现接口的类是活的。

结构和类的区别

简单的说成class能够被实例化,属于引用类型struct属于值类型,

1）、类型，空间分配。结构是值类型，是分配在内存的栈上的.类时引用类型，,是分配在内存的堆上的。结构实例化能够不用new，即便用new操做也不会在堆里分配内存。做参数是按值传递，类时引用传递，变量用完自动解除内存分配，类须要垃圾回收期

2）、基类。结构继承自System.ValueType类，所以不具多态性。可是注意，System.ValueType是个引用类型。类继承自System.Object类；

3）、职能。struct经常使用于存储数据；而class表现为行为

4)、结构没有类的特性，不支持继承。但能够实现接口。

5）、结构没法声明无参的构造函数，但能够声明有参的构造函数

6）、结构的实例成员不能直接赋初值，必须经过构造函数来赋值，但静态成员能够直接赋初值

7）、无抽象结构，但有抽象类（abstract）

8）、class 能够声明protected成员、virtual成员、sealed成员和override成员；而struct不能够，可是值得注意的是，struct 能够重载System.Object的3个虚方法，Equals()、ToString()和GetHashTable()。

 

接口与继承的区别？何时使用接口，何时使用继承？

（1） 接口定义一个类型须要实现的方法，属性，索引和事件，包括可能的参数类型和返回值类型，而把具体的实现交由相应的类或结构来作，从而为组件提供多态能力。

（2） 继承经常使用于在一个现有父类的基础上的功能扩展，每每是咱们将几个类中相同的成员提取出来放在父类中实现，而后在各自的子类中加以继承。

（3） 接口能够实现多接口继承，而继承只能实现单继承。

（4） 实现继承可继承父类型的实现，因为接口中没有定义方法的实现，所以必须实现继承后该接口的全部方法。

（5） 为父类型添加方法可能不影响使用继承自该类型实现的用户，而为接口添加方法致使用户必须为新方法添加实现。

（6） 当派生类和基类是is-a的关系是使用"继承"，典型案例"苹果 is-a 水果"，存在can-do的关系时使用"接口"

重载(Overload )和覆写(Override)的区别

    简单的说，一个是同一个函数的几种形式,一个是重写父类函数，

         重载：当类包含两个名称相同但签名不一样(方法名相同,参数列表不相同)的方法时发生方法重载。用方法重载来提供在语义上完成相同而功能不一样的方法。

         覆写：在类的继承中使用，经过覆写子类方法能够改变父类虚方法的实现。

区别：

         一、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。

    二、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。

    三、覆盖要求参数列表相同；重载要求参数列表不同。

    四、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

<%# %> 和 <% %> 有什么区别？

<%# %>表示绑定的数据源

<% %>是服务器端代码块

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

值类型包括简单类型、结构体类型和枚举类型，引用类型包括自定义类、数组、接口、委托等

一、赋值方式：将一个值类型变量赋给另外一个值类型变量时，将复制包含的值。这与引用类型变量的赋值不一样，引用类型变量的赋值只复制对象的引用，而不复制对象自己。

二、派生：值类型不可能派生出新的类型，全部的值类型均隐式派生自 System.ValueType。但与引用类型相同的是，结构也能够实现接口。

三、null：与引用类型不一样，值类型不可能包含 null 值。然而，可空类型功能容许将 null 赋给值类型。

四、每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。

值类型主要由两类组成：结构、枚举

结构分为如下几类：Numeric（数值）类型、整型、浮点型、decimal、bool、用户定义的结构。

引用类型的变量又称为对象，可存储对实际数据的引用。声明引用类型的关键字：class、interface、delegate、内置引用类型： object、string

五、值类型存贮在栈中，而引用类型存贮在动态的堆中，栈是先进先出的有系统管理的空间，而堆是由应用程序控制的可随时申请和释放该空间，在Donnet中通常状况下有垃圾收集器处理，他们的不一样致使在编程上的不一样。

例：

"a=null"的意思是：a的引用置为空但此时StringBuilder的堆空间并无被释放，所以在此以后，输出b时，仍然能够输出mxh

using System;

using System.Text;

class EventDel

{

    static void Main(string[] args)

    {

        StringBuilder a=new StringBuilder();//将StringBuilder的一个首地址传给a

        StringBuilder b=a;                  //将StringBuilder的一个首地址传给b

        b.Append("mxh");

        Console.WriteLine(a);

        a=null;

        Console.WriteLine(b);

    }

}

输出结果：

mxh

mxh

请按任意键继续. . .

 

C#中的委托是什么？如何理解委托？

简单的说：委托是一种方法容器，里面能够装载若干个具备相同签名的方法引用地址，那么调用委托，就至关于同时调用了该容器内的全部方法。

委托能够看作一种新的对象类型，具备面向对象的特色，定义时可签名接收参数，委托实例化时，能够把方法名做为一个参数传递给委托对象，委托能够理解为指向函数的引用。生成的委托对象能够代理所传递的方法，能够接收方法的参数。也就是定义了委托，能够在不用调用原方法的状况下，调用那个方法

 

例：

例：

    public delegate string MyDel(string nm,string pwd); //定义委托签名接收两个参数

    static void Main(string[] args)

    {

      MyDel md=new MyDel(方法名)        //定义委托对象，其引用变量指向参数中的方法

      string result=md("张三"，"1234"); //调用委托对象，传递所指方法的参数

    }

委托相似于 C或 C++中的函数指针。但不一样的是委托是面向对象、类型安全的。

委托容许将方法做为参数进行传递。

委托可用于定义回调方法。

委托能够连接在一块儿；建立多个对象，使用“+=”累加到同一个委托对象上的引用上，例如，能够对一个事件调用多个方法。

public delegate string MyDel(string nm,string pwd); //定义委托签名接收两个参数

static void Main(string[] args)

{

    MyDel md=new MyDel(方法1);          //委托对象，其引用变量指向参数中的方法

    md+=new MyDel(方法2);

    md+=new MyDel(方法3);

    string result=md("张三"，"1234");   //调用委托对象，传递所指方法的参数

}

方法不须要与委托签名精确匹配。有关更多信息，请参见协变和逆变。

C# 2。0 版引入了匿名方法的概念，此类方法容许将代码块做为参数传递，以代替单独定义的方法。如：

using System;

class Name

{

    private string pName;

    //定义委托类型

    public delegate void myEventHandler(object sender, NameEventArgs e);

    //定义Get事件

    public event myEventHandler Get;

    internal string Text

    {

        get { return this.pName; }

        set{

            //-----------------------------------------------------------2

            this.pName=value;

            this.OnGet(new NameEventArgs("Text属性被更改了"));

        }

    }

    void OnGet(NameEventArgs e)//----------------------------------------3

    {

        this.Get(this, e);  //触发事件

    }

    public override string ToString()

    {

        return "Name类的对象";

    }

    public class NameEventArgs : EventArgs  //自定义事件信息类

    {

        string pArgs;

        public NameEventArgs(string s)

        {

            pArgs = s;

        }

        public override string ToString()

        { return pArgs; }

    }

}

class EventDel

{

    static void Main(string[] args)

    {

        Name myname = new Name();

        myname.Get += new Name.myEventHandler(myname_get); //--------------4

        myname.Text = "张三";//--------------------------------------------1

    }

    //用于订阅事件的myname_get()方法

    static void myname_get(object sender, Name.NameEventArgs e) //---------5

    {

        //输出事件信息，和事件发布者的属性

        Console.WriteLine("事件信息：{0}", e.ToString());

        Console.WriteLine("事件发布者:{0}", sender.ToString());

        Console.WriteLine("你输入的名字是：{0}",((Name)sender).Text);

    }

}

结果：

事件信息：Text属性被更改了

事件发布者:Name类的对象

你输入的名字是：张三

请按任意键继续. . .

使用匿名方法，直接将方法体的代码和委托对象关联而不须要单独定义此方法

class EventDel

{

     static void Main(string[] args)

    {

         Name myname=new Name();

        myname.Get += delegate(object sender, Name.NameEventArgs e)

        {

        };

    }

}

也能够用Lambda表达式把delegate隐藏

class EventDel

{

     static void Main(string[] args)

    {

         Name myname=new Name();

        myname.Get += (object sender, Name.NameEventArgs e) =>

        {

        };

    }

}

 

 

 

事件是否是一种委托？

委托是一种安全的函数指针，事件是一种消息机制

委托与事件是什么关系？为何要使用委托

         委托提供了封装方法的方式,事件是某动做已发生的说明,事件是创建于委托之上的

         程序运行时同一个委托可以用来调用不一样的方法，只要改变它的引用方法便可,所以委托调节器用的方法不是在编译时决定的,而是在运行时肯定的.

请解释这种语法现象Session[“name”]=20;

    给类的索引器赋值.

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

Asp.net的身份验证有有三种，分别是"Windows | Forms | Passport"，

window验证: ASP.NET 会结合信息服务 (IIS),为每一个用户开启window账号，验证其身份，安全性较高。

forms验证:为每一个登录用户写入一个身份验证票据，在web使用最广的验证方式，灵活方便。

passport验证:由 Microsoft 提供的集中身份验证服务，该服务为成员站点提供单一登陆和核心配置

什么是code-Behind技术。

就是代码隐藏，在ASP.NET中经过ASPX页面指向CS文件的方法实现显示逻辑和处理逻辑的分离，这样有助于web应用程序的建立。好比分工，美工和编程的能够个干各的，不用再像之前asp那样都代码和html代码混在一块儿，难以维护。

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

活动目录。

活动目录是window2000的最重要的功能。能够将用户信息所有集成起来，登录之后能够访问多个不一样的网络服务。。

活动目录包括两个方面：目录和与目录相关的服务。安装了活动目录的计算机称为“域控制器”，对于用户而言，只要加入并接受域控制器的管理就能够在一次登陆以后全网使用，方便地访问活动目录提供的网络资源。对于管理员，则能够经过对活动目录的集中管理就可以管理全网的资源。

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

System.XML命名空间，任何类型的项目均可以经过System.XML命名空间进行XML处理。使用System.Xml命名空间中的XmlDocument类来操做xml的数据

C#中 Socket所在的命名空间是？

System.Net.Sockets。 Socket 类为网络通讯提供了一套丰富的方法和属性。Socket 类容许您使用 ProtocolType 枚举中所列出的任何一种协议执行异步和同步数据传输。

什么是SOAP，有哪些应用。

SOAP（Simple Object Access Protocol ）简单对象访问协议是在分散或分布式的环境中交换信息并执行远程过程调用的协议，是一个基于XML的协议。使用SOAP，不用考虑任何特定的传输协议（最经常使用的仍是HTTP协议），能够容许任何类型的对象或代码，在任何平台上，以任何一直语言相互通讯。这种相互通讯采用的是XML格式的消息。

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

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

垃圾回收器每次进行垃圾回收时，对堆上的对象进行检查，把没有被任何变量引用的对象销毁。但并非检查堆上的每一个对象，而是将对象进行分类，将全部对象分类三代（generation）。生命周期越短（新建立的对象）代数越小，反之越大。

在堆空间不够用时，垃圾回收器回收垃圾，检查第0代对象，若是发现没有被引用的对象，则标记这些为“垃圾”，并销毁。而幸存的部分的第0代对象将升级为第1代对象，某些标记为“垃圾”的对象也会幸存而升级。这时若是堆空间仍然不够用（如建立比较大的新对象），垃圾收集器将会检查第1代对象，将没有引用的对象进行销毁。幸存部分升级为第2代对象，当内存堆空间仍然不够用时，检查第2代对象，不过第2代对象检查后仍然是第2代对象，不会继续升级。

 

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

垃圾回收器优化引擎根据正在进行的分配状况肯定执行回收的最佳时间。当垃圾回收器执行回收时，它检查托管堆中再也不被应用程序使用的对象并执行必要的操做来回收它们占用的内存。

    三个generation，当每一个generation内存满了的时候检查引用，无引用就回收内存

经常使用的调用webservice方法有哪些？

1.使用WSDL.exe命令行工具。

2.使用VS.NET中的Add Web Reference菜单选项

什么是XML？列举一下你所了解的XML技术及其应用

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

    xml能够用来作网页(xslt)；xml能够看成数据库；xml能够用来保存对象的系列化；xml用于配置；用于保存静态数据类型。接触XML最多的是web Services和config

XML 与 HTML 的主要区别

1. XML是区分大小写字母的，HTML不区分。

2. XML中，绝对不能省略掉结束标记。在HTML中，若是上下文清楚地显示出段落或者列表键在何处结尾，那么你能够省略</p>或者</li>之类的结束 标记。

3. 在XML中，拥有单个标记而没有匹配的结束标记的元素必须用一个 / 字符做为结尾。这样分析器就知道不用 查找结束标记了。

4. 在XML中，属性值必须在引号中。在HTML中，引号是可用可不用的。

5. 在XML中，全部的属性都必须带有相应的值。在HTML中，能够拥有不带值的属性名。

C#中property与attribute的区别，他们各有什么用处，这种机制的好处在哪里？

    property和attribute汉语都称之为属性。

    property一个是属性，用于存取类的字段，类向外提供的数据区域,

         attribute一个是特性，用来标识类，方法等的附加性质, 描述对象在编译时或运行时属性的.

C#能否对内存进行直接的操做？

         这个问题比较难回答，也是个很大的问题。可是能够这样问答。C#是能够对内存进行直接操做的，虽然不多用到指针，可是C#是能够使用指针的，在用的时候须要在前边加unsafe,，在.net中使用了垃圾回收机制（GC）功能，它替代了程序员，不过在C#中不能够直接使用finalize方法，而是在析构函数中调用基类的finalize()方法。

用最有效的方法算出2的3次方8等于几？

2<<3.

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

触发器，性能好，事务性

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

    简单的说，ADO.NET新增dataset等，不须要随时保持链接，性能提升.

1:ADO.Net不依赖于ole db提供程序,而是使用.net托管提供的程序,

2:不使用com

3:不在支持动态游标和服务器端游

4:,能够断开connection而保留当前数据集可用

5:强类型转换

6:xml支持

         您能够经过将 ADO.NET 的各项功能与 ActiveX 数据对象 (ADO) 的特定功能进行比较来理解 ADO.NET 的功能。

         1、数据的内存中表示形式

         在 ADO 中，数据的内存中表示形式为记录集。在 ADO.NET 中，它为数据集。它们之间有重要的差别。

         2、表的个数

         记录集看起来像单个表。若是记录集将包含来自多个数据库表的数据，则它必须使用 JOIN 查询，未来自各个数据库表的数据组合到单个结果表中。 相反，数据集是一个或多个表的集合。数据集内的表称为数据表；明确地说，它们是 DataTable 对象。若是数据集包含来自多个数据库表的数据，它一般将包含多个 DataTable 对象。即，每一个 DataTable 对象一般对应于单个数据库表或视图。这样，数据集能够模仿基础数据库的结构。

         数据集一般还包含关系。数据集内的关系相似于数据库中的外键关系，即它使多个表中的行彼此关联。例如，若是数据集包含一个有关投资者的表和另外一个有关每一个投资者的股票购买状况的表，则数据集可能还包含一个关系来链接投资者表的各个行和购买表的对应行。

         因为数据集能够保存多个独立的表并维护有关表之间关系的信息，所以它能够保存比记录集丰富得多的数据结构，包括自关联的表和具备多对多关系的表。

         3、数据导航和游标

         在 ADO 中，您使用 ADO MoveNext 方法顺序扫描记录集的行。在 ADO.NET 中，行表示为集合，所以您能够像依次经过任何集合那样依次经过表，或经过序号索引或主键索引访问特定行。DataRelation 对象维护有关主记录和详细资料记录的信息，并提供方法使您能够获取与正在操做的记录相关的记录。例如，从 Investor 表的"Nate Sun"的行开始，能够定位到 Purchase 表中描述其购买状况的那组行。

         "游标"是数据库元素，它控制记录导航、更新数据的能力和其余用户对数据库所作更改的可见性。ADO.NET 不具备固有的游标对象，而是包含提供传统游标功能的数据类。例如，在 ADO.NET DataReader 对象中提供只进、只读游标的功能。有关游标功能的更多信息，请参见数据访问技术。

         4、将打开链接的时间降至最低

         在 ADO.NET 中，打开链接的时间仅足够执行数据库操做，例如"选择"(Select) 或"更新"(Update)。您能够将行读入数据集中，而后在不保持与数据源的链接的状况下使用它们。

         在 ADO 中，记录集能够提供不链接的访问，但 ADO 主要是为链接的访问设计的。

         ADO 和 ADO.NET 中的不链接处理之间存在一个显著差别。在 ADO 中，经过调用 OLE DB 提供程序来与数据库通讯。但在 ADO.NET 中，您经过数据适配器（OleDbDataAdapter、SqlDataAdapter、OdbcDataAdapter 或 OracleDataAdapter 对象）与数据库通讯，这将调用 OLE DB 提供程序或基础数据源提供的 API。ADO 和 ADO.NET 之间的主要区别在于：

         在 ADO.NET 中，数据适配器容许您控制将对数据集所作的更改传输到数据库的方式，方法是实现性能优化、执行数据验证检查或添加其余任何额外处理。

         注意：数据适配器、数据链接、数据命令和数据读取器是组成 .NET Framework 数据提供程序的组件。Microsoft 和第三方供应商可能会提供其它提供程序，这些提供程序也可集成到 Visual Studio 中。有关不一样 .NET 数据提供程序的信息，请参见 .NET 数据提供程序。

         5、在应用程序间共享数据

         在应用程序间传输 ADO.NET 数据集比传输 ADO 不链接的记录集要容易得多。若要将 ADO 不链接的记录集从一个组件传输到另外一个组件，请使用 COM 封送。若要在 ADO.NET 中传输数据，请使用数据集，它能够传输 XML 流。 相对于 COM 封送，XML 文件的传输提供如下便利之处：

 

更丰富的数据类型 COM 封送提供一组有限的数据类型（由 COM 标准定义的那些类型）。因为 ADO.NET 中的数据集传输基于 XML 格式，因此对数据类型没有限制。所以，共享数据集的组件能够使用这些组件通常会使用的任何丰富的数据类型集。

         6、性能

         传输大型 ADO 记录集或大型 ADO.NET 数据集会使用网络资源；随着数据量的增加，施加于网络的压力也在增长。ADO 和 ADO.NET 都使您能够最大限度地下降所传输的数据。但

         ADO.NET 还提供另外一个性能优点：ADO.NET 不须要数据类型转换。而须要 COM 封送来在组件间传输记录集的 ADO，则须要将 ADO 数据类型转换为 COM 数据类型。

         7、穿透防火墙

         防火墙能够影响试图传输不链接的 ADO 记录集的两个组件。请记住，防火墙一般配置为容许 HTML 文本经过，但防止系统级请求（如 COM 封送）经过。 由于组件使用 XML 交换 ADO.NET 数据库，因此防火墙能够容许数据集经过。

ASP.Net与ASP相比，主要有哪些进步？

asp解释型，aspx编译型，性能提升，有利于保护源码

ASP的缺点:

l  VBScript和JavaScript是在ASP中仅可以使用的两种脚本语言。它们是基本的非类型化语言。在ASP中不能使用强类型语言.

l  ASP页面须要解释,使得它执行速度较慢。

l  ASP页面很是凌乱。

l  在使用ASP建立WEB应用程序时，程序员和设计人员必须在同一文件上一块儿工做。

l  在ASP中，必须经过编写代码来提供所需的任何功能。

l  在ASP中没有对代码给予太多的关注。

l  在ASP中没有调试机制。

l  在ASP中。必须中止WEB服务器才能安装DLL的新版本，而且在应用程序中使用DLL的新版本以前，必须先在注册表中注册它，并且，DLL注册过程很是复杂。

ASP.NET的优势：

l  ASP.Net中支持强类型语言.

l  ASP.Net页将被编译而不是解释，这样它们的执行速度就比ASP页快。

l  ASP.Net提供声明性服务器控件。

l  ASP.Net经过继承机制来支持代码的重用。

l  ASP.Net具备Trace的内置方法，能够帮助对页面进行调试。

l  在ASP.Net中，置于应用程序的BIN目录中的任何组件将自动对应用程序可用.

你对XML，HTTP、WEBSERVICE了解吗？简单描述其特色、做用

xmlhttp能够主动获取远端web代码，相似HttpWebRequest

存储过程和函数的区别

存储过程是编译好的存储在数据库的操做，函数不用说了。

Session,ViewState,Application,cookie的区别?

Session:用于保持状态的基于 Web 服务器的方法。Session 容许经过将对象存储在Web 服务器的内存中在整个用户会话过程当中保持任何对象。主要用于保持代码隐藏类中对象的状态。为每一个用户建立的,用于存储单个用户,由于他是相对每一个用户的.因此可能来取得在线人数等。

ViewState:主要用于保持 Web 页上控件的状态。当 Web 页上的控件被绑定到代码隐藏类中的对象。

Application用于存储全部用户均可视的信息.因此它存储的是要让全部用户共享的一些信息.如总访问数等Cache，页面缓存。

Cookie:一般咱们都把它放在客户端,也能够存储在服务器端。主要用它存储用户的个性设制,和登录信息。

 

请说明在.Net中经常使用的几种页面间传递参数的方法，并说出他们的优缺点。

一、queryString  url参数 简单，显示于地址栏，长度有限

优势：简单易用；资源占用比较少。

缺点：传递数据大小有限制，只能传递基本类型的数据，安全性差

二、session(viewstate)

优势：简单，灵活性强，能传递复杂的对象

缺点：但易丢失，资源消耗大

三、cookie

优势：简单，

缺点：但可能不支持，可能被伪造，大小有限制不能超过4KB 不恩可以存储复杂对象

四、this.Server.Transfer,

优势：URL地址不变，安全性高，灵活性强，能传递复杂的对象

缺点：资源消耗大

五、hidden control/viewstate  简单，可能被伪造

六、static member。 

七、cache 

八、application

优势：全局

缺点：资源消耗大

九、DataBase  数据库 稳定，安全，但性能相对弱

十、xml or other   Files 

十一、XMLHTTP or Hidden iFrame/frame 

十二、Context.user.identity 

    我正在作一个通用提示页面，全部页面出现问题都要，传递几个变量字符串到同一个页面 hitMsg。aspx变量字符串包括提示语言，即将跳转的页面，跳转时间。在上面的种方案中哪一个更好些? 

   (1)queryString的毛病是没法传递很长字符串，好比系统错误信息每每就一整个屏幕。  

   (2)session的毛病是不能过多使用，容易丢失。  

   (3)cookie的毛病是依赖客户端设置，不可靠。  

   (4)server.transfer的毛病是接收页面要为发送页面准备好，只能定制专门一个页面接受定制好的页面。不能是一个页面接受任何页面。  

   (5)hidden control/viewstate只能传递本页。除非特殊制做。  

   (6)static member。没法保证线程安全，可能会此处栽瓜他处得豆。  

   (7)cache不适合使用一次就扔的变量。  

   (8)application全局的，开销大。  

   (9)DataBase全局固化的，开销更大，除非作日志跟踪。  

   (10)xml or othe Files全局固化的，开销大，除非作日志跟踪。  

   (11)XMLHTTP or Hidden iFrame/frame，作这个过于烦琐。  

   (12)Context这个占用了用户id，不适合作这个。

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

input type="hidden" 简单，可能被伪造

url参数 简单，显示于地址栏，长度有限

数据库 稳定，安全，但性能相对弱

this.Server.Transfer，在新页面得到值的代码以下：

if (Page.PreviousPage != null)

{

    TextBox st =

        (TextBox)Page.PreviousPage.FindControl("TextBox1");

    if (st != null)

    {

        Label1.Text = SourceTextBox.Text;

    }

}

ASP.NET页面跳转的几种方法

超连接跳转

<a>标签

1. <a href=”test.aspx”></a>

2.这是最多见的一种转向方法;

HyperLink控件

1.Asp.net 服务器端控件属性NavigateUrl指定要跳转到的Url地址

2. NavigateUrl是能够在服务器端使用代码修改，这个区别于<a>

3.因为HyperLink自己没有事件因此要在服务器端其它事件中设置NavigateUrl

4.代码示例

<Asp:HyperLink id=”hyperlink” runat=”server” NavigatoeUrl=”test.aspx”>

ok</Asp:HyperLink>

Response.Redirect()方法

1.过程：发送一个Http响应到客户端，通知客户端跳转到一个新的页面，而后客户端再发送跳转请求到服务器端。

2.页面跳转以后内部控件保存的全部信息丢失，当A跳转到B，B页面将不能访问A页面提交的数据信息。

3.使用这个方法使用这个方法跳转后浏览器地址栏的Url信息改变

4.能够使用Session Cookies Application等对象进行页面间的数据传递

5.重定向操做发生在客户端，总共涉及到两次与Web服务器的通讯：一次是对原始页面的请求，另外一次是重定向新页面的请求

Server.Transfer()方法

1.实现页面跳转的同时将页面的控制权进行移交

2.页面跳转过程当中Request Session等保存的信息不变，跳转以后能够使用上一个页面提交的数据

3.跳转以后浏览器地址栏的Url不变

4.这种方法的重定向请求是在服务器端的进行的，浏览器不知道页面已经发生了一次跳转

Server.Execute()方法

1.该方法容许当前页面执行同一个Web服务器上的另外一个页面

2.页面执行完毕以后从新回到原始页面发出Server.Execute()的位置。

3.这种方式相似针对页面的一次函数调用被请求的页面能够使用原始页面的表单数据和查询字符串集合

4.被调用页面的Page指令的EnableViewStateMac属性设置为False

经过超连接怎样传递中文参数？

URLEncode URLDecode

请说出强名的含义

对程序集，进行公钥/私钥对签名，称为强名。用名称，版本，文化，公钥惟一肯定程序集

具备本身的key，能够在GAC为公用

请列出c＃中几种循环的方法，并指出他们的不一样

For :使用于肯定次数的循环

Foreach:使用于遍历的元素只读

While:次数不肯定条件随机变化

Do…while:次数不肯定条件随机变化，但至少要保证能被执行一次

请指出.Net中全部类型的基类

Object

C#中有没有运算符重载？可否使用指针？

         有，重载操做符意味着使该操做符具备不一样的行为；使用操做符能够使方程式简单易懂；重载运算符使用operator关键字来建立一个运算符方法，只能在类或结构中使用 Operator

         例：下面的代码示例使用 Operator 语句定义一个结构的大纲，该结构包括 And、Or运算符的运算符过程。And 和 Or 每一个都采用两个类型为 abc 的操做数，并返回类型 abc。这些定义容许调用代码经过 abc 类型的操做数来使用 And、Or。

Public Structure abc

    Public Shared Operator And(ByVal x As abc, ByVal y As abc) As abc

        Dim r As New abc

        ' Insert code to calculate And of x and y.

        Return r

    End Operator

    Public Shared Operator Or(ByVal x As abc, ByVal y As abc) As abc

        Dim r As New abc

        ' Insert code to calculate Or of x and y.

        Return r

    End Operator

End Structure

         能使用指针, 在 C# 中不多须要使用指针，但仍有一些须要使用的状况。例如，在下列状况中使用容许采用指针的不安全上下文是正确的：

l  处理磁盘上的现有结构

l  涉及内部包含指针的结构的高级 COM 或平台调用方案

l  性能关键代码

         不鼓励在其余状况下使用不安全上下文。具体地说，不该该使用不安全上下文尝试在 C# 中编写 C 代码。

C#能否对内存进行直接的操做？(这但是个难点哦？要注意！）

         C#在unsafe 模式下能够使用指针对内存进行操做, 但在托管模式下不能够使用指针，C#NET默认不运行带指针的，须要设置下，选择项目右键->属性->选择生成->“容许不安全代码”打勾->保存

using System;

public class Program

{

    public static void Main()

    {

        int n = 123;

        unsafe

        {

            int* p = &n;

            Console.WriteLine("{0:X}", n);

            Console.WriteLine("{0:X}", *p);

            Console.WriteLine("{0}", p->ToString());

        }

    }

}

结果：

7B

7B

123

请按任意键继续. . .

用Visual C++ 6.0编写的代码(unmanaged code)，如何在CLR下和其余dot net component结合？

 

         net 与 Com 互操做 在.net中能够经过添加引用的方式将COM 加载在CLR下，将原有的COM中的类型相应变化为.Net 下可识别的类型

私有程序集与共享程序集有什么区别？

         一个私有程序集一般为单个应用程序所使用，而且存储于这个应用程序所在的目录之中，或此目录下面的一个子目录中。共享程序集一般存储在全局程序集缓存（Global Assembly Cache）之中，这是一个由.NET运行时所维护的程序集仓库。共享程序集一般是对许多应用程序都有用的代码库，好比.NET Framework类。

私有程序集:

l  默认状况下，C# 程序编译为私有程序集

l  须要放在应用程序所在的文件夹中

l  程序集的名称在应用程序中应当是惟一的

共享程序集:

l  能够被不一样的应用程序共享

l  在全部使用程序集的应用程序中，程序集名称应当是惟一的

l  放在全局程序集缓存中

什么是GAC？它解决了什么问题?

         Gloal Assembly Cache，全局应用程序集缓存。它解决了几个程序共享某一个程序集的问题。没必要再将那个被共享的程序集拷贝到应用程序目录了，其实这道理很简单，.net应用程序在加载的时候，会首先查看全局应用程序集缓存，若是有就能够直接使用，没有再到应用程序目录进行查找。

请指出GAC的含义

    全局程序集缓存（Global Assembly Cache）可全局使用的程序集的缓存。大多数共享程序集都安装在这个缓存中，其中也安装了一些私有程序集。存放共享程序的文件夹，可被任何项目使用

在全局程序集缓存中部署的应用程序必须具备强名称。.Net提供的命令行工具gacutil.exe用于支持这一功能。gacutil.exe能够将具备强名称的程序集添至全局程序集缓存。

怎样理解静态变量？

全部实例公用一个的变量

向服务器发送请求有几种方式？区别？

get post get通常为连接方式，post通常为按钮方式。主要区别以下：

一、get从服务器上获取数据，post向服务器传送数据

二、get把参数队列加到表单Action所指定的URL地址中，值和表单内的各个字段一一对应，在URL中能够显示出来。post把表单中的各个字段及其内容放到HTML Header里，一块儿传送到Action所指定的URL地址中，不会在URL中能够显示出来

三、对于get，服务器端用Request.QueryString获取变量提交的值，对于post服务器端用Request.Form获取提交的数据。

四、因受到URL长度的限制，get传输的数据量少，不能大于2K，post传输的数据量较大，通常默认没限制。理论上IIS5中为100K，最大能够达到2M

五、get安全性低，post安全性高

软件开发过程通常有几个阶段？每一个阶段的做用？

需求分析，架构设计，代码编写，QA，部署

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

可行性分析，需求分析 ，实施和编码，测试，维护

分析（须要，概要，详细），开发（编程，单元测试），测试（集成测试），维护。

有哪几种方法能够实现一个类存取另一个类的成员函数及属性，并请举列来加以说明和分析。

取：类在封装时将属性及函数设置成public

存：继承

同一个名称控件直接，或者反射

若是需记录类的实例个数，该如何实现，请写一个简单的类于以证实。

const static int classNum=0;

classNum++;

A类是B类的基类，而且都有本身的构造，析构函数，请举例证实B类从实例化到消亡过程当中构造，析构函数的执行过程。

构造先父后子，析够反之

须要实现对一个字符串的处理，首先将该字符串首尾的空格去掉，若是字符串中间还有连续空格的话，仅保留一个空格，即容许字符串中间有多个空格，但连续的空格数不可超过一个。

string inputStr=" xx xx ";

inputStr=Regex.Replace(inputStr.Trim()，" *"，" ");

new有几种用法

一、new 运算符，建立对象，调用构造函数

二、new 修饰符 覆盖方法，隐藏父类的成员。public new XXXX(){}

三、new 约束 用于在泛型声明中，约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。当泛型类建立类型的新实例时，将此约束应用于类型参数，当与其余约束一块儿使用时，new() 约束必须最后指定。如：

public class ItemFactory<T> where T : IComparable, new()

{

}

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

using引入名称空间或者使用非托管资源

new新建实例或者隐藏父类方法

下面这段代码输出什么？为何？

    int i=5;

    int j=5;

    if (Object.ReferenceEquals(i,j))

        Console.WriteLine("Equal");

    else

        Console.WriteLine("Not Equal");

输出Not Equal 。不相等，由于比较的是对象。ReferenceEquals(object a,object b)，里面的两个参数是object对象

写一个实现对一段字符串翻转的方法，附加一些条件，如其中包括“，”、“。”，对其设计测试用例

inputStr=inputStr.ToCharArray().Reverse().ToString();

用Singleton如何写设计模式

static属性里面new ，构造函数private

什么是Application Pool？

Web应用，相似Thread Pool，提升并发性能

链表和数组的区别，各有什么优缺点。

一个能够动态增加，一个固定(VB中能够Redim)，性能数组教好

什么是友元函数？

friendly声明，能够访问protect级别方法

什么是虚函数？

能够被重写

什么是抽象函数？

必须被重写

什么是内存泄漏，怎样最简单的方法判断内存泄漏 ?

C++，C中忘了释放内存，内存不会再次分配

C#中有不少类被定义为public有什么意义？

         public 关键字将公共访问权限授予一个或多个被声明的编程元素。对公共元素的可访问性没有限制。

Internal修饰符有什么含义？

         internal 关键字是类型和类型成员的访问修饰符。内部成员只有在同一程序集中的文件内才是可访问的。内部访问一般用于基于组件的开发，由于它使一组组件可以以私有方式进行合做，而没必要向应用程序代码的其他部分公开。例如，用于生成图形用户界面的框架能够提供“控件”类和“窗体”类，这些类经过使用具备内部访问能力的成员进行合做。因为这些成员是内部的，它们不向正在使用框架的代码公开。在定义具备内部访问能力的成员的程序集外部引用该成员是错误的。

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

private : 私有成员， 在类的内部才能够访问。

protected : 保护成员，该类内部和继承类中能够访问。

public : 公共成员，彻底公开，没有访问限制。

internal: 在同一命名空间内能够访问。

JAVA的代码是半编译半解释的C#的代码是否也是这样

         C#源码通过语言编译器执行第一次编译，变为中间语言，而后再由CLR编译成可执行代码.

进程和线程的区别

一、单位：进程是系统进行资源分配和调度的单位；线程是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为止。

如何把一个array复制到arrayList里

例一、foreach( object o in array )

arrayList.Add(o);

例二、string[] s ={ "111", "22222" }; ArrayList list = new ArrayList(); list.AddRange(s);

例三、string[] s ={ "111", "22222" }; ArrayList list = new ArrayList(s);

 

DataGrid.Datasouse能够链接什么数据源

DataTable、DataView、DataSet、DataViewManager

任何实现IListSource或IList接的组件

概述反射和序列化

反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您能够使用反射在运行时动态地建立类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。而后，能够调用类型的方法或访问其字段和属性

经过反射命名空间中的类以及 System.Type，能够使用反射在运行时动态地建立类型的实例,而后调用和访问这些实例。也能够获取有关已加载的程序集和在其中定义的类型（如类、接口和值类型）的信息。

序列化:序列化是将对象转换为容易传输的格式的过程。例如，能够序列化一个对象，而后使用 HTTP 经过 Internet 在客户端和服务器之间传输该对象。在另外一端，反序列化将从该流从新构造对象。

概述o/r mapping 的原理

利用反射，配置 将类于数据库表映射

用sealed修饰的类有什么特色

sealed 修饰符用于防止从所修饰的类派生出其它类。若是一个密封类被指定为其余类的基类，则会发生编译时错误。

密封类不能同时为抽象类。

sealed 修饰符主要用于防止非有意的派生，可是它还能促使某些运行时优化。具体说来，因为密封类永远不会有任何派生类，因此对密封类的实例的虚拟函数成员的调用能够转换为非虚拟调用来处理。

UDP链接和TCP链接的异同。

         UDP是用户数据报协议，是一个简单的面向数据报的传输协议，是不可靠的链接。

         TCP是传输控制协议，提供的是面向链接的，是可靠的，字节流服务，当用户和服务器彼此进行数据交互的时候，必须在他们数据交互前要进行TCP链接以后才能传输数据。TCP提供超时重拨，检验数据功能。

         前者只管传，无论数据到不到，无须创建链接。后者保证传输的数据准确，需要连结。

.net中读写数据库须要用到哪些类？列举ADO.Net中的五个主要对象，他们的做用

         Connection用来建立一个到数据库的链接

         DataAdapter用来将数据填充到DataSet，在数据源和DataSet间起数据传输

         DataSet能够视为一个暂存区（Cache），把从数据库中所查询到的数据保留起来用来无链接的储存多个表的数据，并包含表与表之间的关联关系。

    DataTable 用来存储一个表的数据

         DataReader用来顺序读取数据。由于DataReader 在读取数据的时候限制了每次只读取一笔，并且只能只读，因此使用起来不但节省资源并且效率很好。使用DataReader 对象除了效率较好以外，由于不用把数据所有传回，故能够下降网络的负载。

         Command用来执行SQL语句

是否能够继承string类

String类是sealed类故不能够继承。

.net Remoting 的工做原理是什么？

服务器端向客户端发送一个进程编号，一个程序域编号，以肯定对象的位置。

Remoting的做用？

         采用分布式进行编程的一种技术，Remoting主要用于管理跨应用程序域的同步和异步RPC （远程过程调用协议Remote Procedure Call protocol）会话。在默认状况下，Remoting使用 HTTP 或 TCP 协议，并使用 XML 编码的 SOAP 或本机二进制消息格式进行通讯。.NET Remoting 提供了很是灵活和可扩展的编程框架,而且他能够管理对象的状态。

讲一讲你理解的web service,在dot net framework中，怎么很好的结合xml?

    从表面上看，Web Service就是一个应用程序，它向外界暴露出一个可以经过Web进行调用的API。这就是说，你可以用编程的方法经过Web调用来实现某个功能的应用程序。从深层次上看，Web Service是一种新的Web应用程序分支，它们是自包含、自描述、模块化的应用，能够在网络(一般为Web)中被描述、发布、查找以及经过Web来调用。可扩展的标记语言XML是Web Service平台中表示数据的基本格式。除了易于创建和易于分析外，XML主要的优势在于它既与平台无关，又与厂商无关。XML是由万维网协会(W3C)建立，W3C制定的XML SchemaXSD定义了一套标准的数据类型，并给出了一种语言来扩展这套数据类型。Web Service平台是用XSD来做为数据类型系统的。当你用某种语言如VB.NET或C#来构造一个Web Service时，为了符合Web Service标准，全部你使用的数据类型都必须被转换为XSD类型。如想让它使用在不一样平台和不一样软件的不一样组织间传递，还须要用某种东西将它包装起来。这种东西就是一种协议，如 SOAP。

remoting和webservice（简述webservice中概念和原理）

    简单的说，WS主要是可利用HTTP，穿透防火墙。而Remoting能够利用TCP/IP，二进制传送提升效率。 

一、Remoting能够灵活的定义其所基于的协议，若是定义为HTTP，则与Web Service就没有什么区别了，通常都喜欢定义为TCP，这样比Web Service稍为高效一些。

二、Remoting不是标准，而Web Service是标准。

三、Remoting通常须要经过一个WinForm或是Windows服务进行启动，而Web Service则须要IIS进行启动。

四、在VS.net开发环境中，专门对Web Service的调用进行了封装，用起来比Remoting方便。

我建议仍是采用Web Service好些，对于开发来讲更容易控制。Remoting通常用在C/S的系统中，Web Service是用在B/S系统中，后者仍是各语言的通用接口，相同之处就是都基于XML。

为了能清楚地描述Web Service 和Remoting之间得区别,我打算从他们的体系结构上来讲起:

Web Service大致上分为5个层次:

1.HTTP 传输信道

2.XML 数据格式

3.SOAP 封装格式

4.WSDL 描述方式

5.UDDI 体系框架

整体上来说，.NET 下的 Web Service结构比较简单，也比较容易理解和应用，通常来说在.NET结构下的WebService应用都是基于.net framework以及IIS的架构之下，因此部署(Dispose)起来相对比较容易点。

从实现的角度来说，首先WebService必须把暴露给客户端的方法所在的类继承于：System.Web.Services.WebService这个基类；其次所暴露的方法前面必须有[WebMethod]或者[WebMethodAttribute] 。

WebService的运行机理。首先客户端从服务器的到WebService的WSDL，同时在客户端声称一个代理类(Proxy Class)

这个代理类负责与WebService服务器进行Request 和Response，当一个数据（XML格式的）被封装成SOAP格式的数据流发送到服务器端的时候，就会生成一个进程对象而且把接收到这个Request的SOAP包进行解析，而后对事物进行处理，处理结束之后再对这个计算结果进行SOAP包装，而后把这个包做为一个Response发送给客户端的代理类(Proxy Class)，一样地，这个代理类也对这个SOAP包进行解析处理，继而进行后续操做。这就是WebService的一个运行过程。

下面对.NET Remoting进行归纳的阐述：

.NET Remoting是在DCOM等基础上发展起来的一种技术，它的主要目的是实现跨平台、跨语言、穿透企业防火墙，这也是他的基本特色，与WebService有所不一样的是，它支持HTTP以及TCP信道，并且它不只能传输XML格式的SOAP包，也能够传输传统意义上的二进制流，这使得它变得效率更高也更加灵活。并且它不依赖于IIS，用户能够本身开发(Development)并部署(Dispose)本身喜欢的宿主服务器，因此从这些方面上来说WebService其实上是.NET Remoting的一种特例。

一、Remoting是MarshByReference的，能够传变量的引用，直接对服务器对象操做。速度快，适合Intranet（企业内部互联网）。WebService是MarshByValue的，必须传对象的值。速度慢，能够过FIREWALL,配置比较简单，适合Internet（因特网）。

二、通常来讲，Remoting是和平台相关的不跨平台的，须要客户和服务器都是.NET，但可配置特性比较好，能够自定义协议。WebService能够作到跨平台通讯，但必须采用SOAP协议。

三、 SOAP消息有RPC和文档两种样式。文档样式的body元素中包含一个或多个元素，能够是任何内容，只要接受者理解就好了。rpc样式的的body元素中包含调用的方法或远程过程的名称，以及表明方法参数的元素。 

web service 数据传输有什么限制? 为何?DataTable能够做为web service参数传递么?

所传输的数据必须是可序列化的。由于须要转换为XML格式以能够穿越防火墙，作到真正的数据共享。由于DataSet处理DataTable的序列化以便进行封送处理，因此没法传递单个DataTable

在 ADO.NET 的三个基本数据对象 — DataReader、DataTable 和 DataSet 中，只有 DataSet 能够与 Web 服务之间传递。这是由于，为了与 Web 服务进行通讯，对象必须是可序列化的。（序列化是一个过程，它用于将对象的公共属性转换为 XML，而且由于 XML 只是纯文本，因此能够将其从一个应用程序传输到另外一个应用程序，而且能够穿越防火墙，从而克服了 COM 的主要障碍之一。）DataReader 没法序列化，由于它们须要到服务器的开放链接。而且，由于 DataSet 处理 DataTable 的序列化以便进行封送处理，因此您也没法传递单个 DataTable。让咱们研究一些示例。

传递 DataSet

假设咱们正在运行一个订阅 Web 服务，该服务可返回所请求的有价证券在给定日期的收盘价格。用户传入用户 ID 和密码，以及他/她但愿看到的有价证券和收盘价格的 DataTable。Web 服务随后验证他/她的成员身份并返回一个 DataTable，其中包含股票符号和它们的收盘价格，或者包含错误信息。

因为使用者应用程序（即，“消耗”该 Web 服务的应用程序）的开发人员须要知道股票符号和错误信息的指望结构，所以 DataSet 须要遵照您提供的发布规范。出于咱们的目的，咱们将假设如下条件：股票符号将存储在一个 DataTable 中，它包含三个列：一个名为 Symbol、类型为 varchar(5) 的列，一个名为 ClosingDate、类型为 datetime 的列，以及一个名为 Price、类型为 float 的列。若是在此过程当中的任什么时候候生成错误，都将在一个只包含一列的 DataTable 中返回错误信息 — 该列的名称为 ErrorMessage，类型为 varchar(100)，而且包含错误信息。经过简单地引用所返回 DataTable 的列 count，开发人员能够知道该过程是否成功。

经常使用的调用webservice方法有哪些？

能够从浏览器、ASP页或其余WEB服务调用能够使用HTTP-GET   HTTP-POST访问WEB服务也能够从ASP页或其余WEB服务向其余WEB服务发出SOAP请求HTTP-GET   HTTP-POST  SOAP  使用WEB服务代理

使用ASMX的XML Web服务与使用SOAP的.NET Remoting的区别?

SOAP是简单对象访问协议，Web服务正是经过WSDL来约定服务器和客户端基于xml的SOAP来通信，而不管客户端和服务器都不须要知道对方的平台、编程语言等信息。

.NET Remoting本质是为了交互更为复杂的对象，甚至须要管理远程对象的生命周期，因此客户端必须了解服务器对象的详细信息，虽然.NET Remoting支持使用SOAP，但对于客户端来讲仍是必须了解服务器对象的详细信息。

Web服务使用的消息机制，而Remoting采用的RPC. Web Service能用于不一样平台，不一样语言，Remoting只适用于.Net。效率上Remoting高于Xml Web Service

解释一下UDDI、WSDL的意义及其做用。

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

         WSDL描述Web服务的公共接口。这是一个基于XML的关于如何与Web服务通信和使用的服务描述。这是一个基于XML的,关于如何与Web服务通信和使用的服务描述；

装箱和拆箱的含义

装箱：将值类型转换为引用类型。拆箱：将引用类型转换为值类型。

         装箱是值类型到 object 类型或到该值类型所实现的任何接口类型的隐式转换。将一个值的值装箱会分配一个对象实例并将该值复制到新的对象中。

         取消装箱是从 object 类型到值类型或从接口类型到实现该接口的值类型的显式转换。取消装箱操做包括：

n  检查对象实例，确保它是给定值类型的一个装箱值。

n  将该值从实例复制到值类型变量中。

 

int i=0;

Syste.Object obj=i;

    这个过程就是装箱！就是将i装箱！

    拆箱就是将一个引用型对象转换成任意值型！好比：

int i=0;

System.Object obj=i;

int j=(int)obj;

    这个过程前2句是将i装箱，后一句是将obj拆箱！再写个代码，看看进行了几回装拆箱！

int i=0;

System.Object obj=i;

Console.WriteLine(i+","+(int)obj);

    其中共发生了3次装箱和一次拆箱！^_^，看出来了吧？！第一次是将i装箱，第2次是输出的时候将i转换成string类型，而string类型为引用类型，即又是装箱，第三次装箱就是(int)obj的转换成string类型，装箱！拆箱就是(int)obj，将obj拆箱！！

页面生命周期 (关于如下生命周期这部分，建议你们上网找找更详细的资料来看)

页面生命周期执行一系列步骤：页面的初始化、实例化控件、还原和维护状态、运行事件处理程序代码、呈现。为了在合适的阶段执行所需的代码，因此要对页面生命周期很是熟悉。在页生命周期的各个阶段，页面会逐个引起定义的事件，经过对代码开发，在页面的生命事件中执行咱们所须要的程序

页生命周期阶段

一、页请求：发生在页面生命周期以前，用户请求页时，ASP.NET将肯定是否须要分析和编译页，从而肯定是否开始页面的生命周期，或者是否能够在不运行页的状况下发送页面缓存以进行响应。

二、开始：设置页属性，如：HttpContext以及其余属性；在此阶段，页面须要肯定是回发请求仍是新请求，并设置IsPostBack属性；设置页面的UICulture属性。

三、页面初始化：加载全部主题；控件生成，并设置UniqueID；

注：ViewState、ControlState中的值还未加载至控件；若是页面是回发，则回发数据也还未加载；故此时控件能够访问，但值可能出错。

四、加载：若是当前请求是回发请求，则为控件加载ViewState和ControlState中的值。

五、验证：调用全部验证程序控件的Validate方法，此方法将设置验证程序控件和页的IsValid属性。

六、回发事件处理：若是请求是回发请求，则调用全部事件处理程序。

七、呈现：首先对该页和全部控件进行保存视图状态，而后对每一个控件调用Render方法，它会提供一个文本编写器，用于将控件的输入写入页的Response属性的OutputStream中。

八、卸载：完成呈现，并已将页发送至客户端、准备丢弃该页后，调用卸载。将卸载属性如：Response和Request等等。

页生命周期事件：

一、PreInit

完成操做：检查IsPostBack属性来肯定是否是第一次处理该页；

    建立或从新建立动态控件

    动态设置主控页

    动态设置Theme属性

    读取或设置配置文件属性

注：若是请求是回发请求，则控件的值还没有从视图状态恢复，即：不该该在此事件中设置控件属性。

二、Init

完成操做：在全部控件都已经初始化而且应用全部外观设置后引起。使用该事件来读取和初始化控件属性。

三、InitComplete

完成操做：由Page对象引起，使用该事件来处理要求完成全部初始化工做的任务。

四、PreLoad

完成操做：为页和全部控件加载视图状态，而后处理Request 实例包括的任何回发数据。
注：若是须要在Load以前对页或控件进行处理，须要该事件。

五、Load

完成操做：以递归方式加载全部控件。

六、控件事件

完成操做：处理控件引起的事件。

注：在回发请求中，若是页包含验证程序控件，请在执行任何处理以前检查Page和各个验证控件的IsValid属性。

七、LoadComplete

八、PreRender

在控件输出前最后的修改机会。

注：在该事件发生前的操做：

Page对全部控件递归进行EnsureChildControl操做

设置了DataSourceID属性的数据绑定控件会调用DataBind方法。

九、SaveStateComplete

在该事件发生前，已经对控件的ViewState进行了保存。将忽略对页和控件所做的全部修改。

十、Render

方法，便于开发

十一、UnLoad

大概描述一下ASP.NET服务器控件的生命周期

初始化  加载视图状态  处理回发数据  加载  发送回发更改通知  处理回发事件  预呈现  保存状态  呈现  处置  卸载

应用程序生命周期

在应用程序的生命周期期间，应用程序会引起可处理的事件并调用可重写的特定方法。若要处理应用程序事件或方法，能够在应用程序根目录中建立一个名为Global.asax的文件。若是建立了Global.asax文件，ASP.NET 会将其编译为从HttpApplication类派生的类，而后使用该派生类表示应用程序。

HttpApplication进程的一个实例每次只处理一个请求。因为在访问应用程序类中的非静态成员时不须要将其锁定，这样能够简化应用程序的事件处理过程。这样还能够将特定于请求的数据存储在应用程序类的非静态成员中。例如，能够在Global.asax文件中定义一个属性，而后为该属性赋一个特定于请求的值。

Application_Start和Application_End方法是不表示HttpApplication事件的特殊方法。在应用程序域的生命周期期间，ASP.NET 仅调用这些方法一次，而不是对每一个HttpApplication实例都调用一次。

asp.net页面在何时产生？又在何时销毁？

(1)Page_Init();---初始化对象

这一过程主要是初始化包括页面自己的全部控件，每次的页面载入就会执行一次初试过程，而在这里面访问到的也是控件的初始值。还有就是能够经过OnInit()来重载初试化事件

(2) LoadViewState---导入Viewstate数据

在初试化事件后，在loadvireState事件中全部控件将得到他们的第一个属性ViewState属性，这个属性最终将被返回给服务器以判断这个页面是已经被用户访问完毕仍是仍然在被

用户所访问。也可重载loadvireState事件对相应的控件进行值设定。

(3) Load Postback data;---用LoadPostData处理Postback数据

Postback数据也能够理解成就是服务器页面提交的表单数据，每一次表单数据的提交都会触发执行IPostBackDataHandler接口操做的控件。

(4) Page_Load();---导入对象

这个过程就比较熟悉了，也是在页面的每次载入时必定会执行，可是注意和PageInit()之间的区别，全部的对象第一次被布置在DOM页面（在Asp.net中称控件树）里了而且能够经过代码或是相关的位置被引用。这样，对象就能够很容易的从客户端得到诸如宽度、高度、值、可见性等在Html中的属性值。常常会用到的Page.IsPostBack()指示该页是否正为响应客户端回发而加载，或者它是否正被首次加载和访问.

(5) Handle control events;---具体的控件事件

这个过程执行的是相应具体控件事件，好比按钮事件..等。

(6) Page_PreRender();---预先呈递对象

预先呈递对象能够改变对象并将改变保存的最后时刻.能够对控件的属性、控件树的结构等作出最后的修改，同时还不用考虑Asp.net对其做出任何改变，由于此时已经脱离了数据库调用以及viewstate更新了，也能够经过OnPreRender来重载。

(7) Page_Render();---呈递对象呈递页面

全部对页面控件的修改完成后viewstate就被保存了。运用Html建立给浏览器输出的页面的时候Render事件就发生了。在Render事件过程当中，页面调用其中的对象将它们呈递给Html。而后，页面就能够以Html的形式被用户的浏览器访问了。当Render事件被重载时，开发者能够编写自定义的Html代码使得原先生成的Html都无效而按照新的Html来组织页面。

    Render方法将一个HtmlTextWriter对象做为参数并用它将Html在浏览器上以网页的形式显示。这时仍然能够作一些修改动做，不过它们只是客户端的一些变化而已了。亦能够重载Render事件。

(8) Unload event;---卸载对象

当想服务器请求一个对象的时候,就会在内存里生成一个继承页面对象,也就是页面的类,它继承自System.Web.UI.Page.当页面对象从内存中卸载时发生，将触发该事件.

(9) Dispose method called

在呈递给Html完成后，全部的对象都应被销毁。在Dispose事件中，你应该销毁全部在创建这个页面时建立的对象。这时，全部的处理已经完毕，因此销毁任何剩下的对象都是不会产生错误的，包括页面对象。你能够重载Dispose事件。

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

         VS 2005和VS 2003都有发布机制。2003能够发布而后再复制部署。VS2005基本上能够直接部署到对应位置。

Session有什么重大BUG，微软提出了什么方法加以解决？

         是iis中因为有进程回收机制，系统繁忙的话Session会丢失，能够用Sate server或SQL Server数据库的方式存储Session不过这种方式比较慢，并且没法捕获Session的END事件。固然这种种状况是限于MS的IIS的WEB容器，不是每一个容器都有这种问题。

如何处理几十万条并发数据？

         用存储过程或事务。取得最大标识的时候同时更新。注意主键不是自增量方式这种方法并发的时候是不会有重复主键的，取得最大标识要有一个存储过程来获取.

谈谈final, finally, finalize的区别。

    final(.Net中不存在此修饰符)—修饰符（关键字）若是一个类被声明为final，意味着它不能再派生出新的子类，不能做为父类被继承。所以一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，能够保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在之后的引用中只能读取，不可修改。被声明为final的方法也一样只能使用，不能重载

    finally—再异常处理时提供 finally 块来执行任何清除操做。若是抛出一个异常，那么相匹配的 catch 子句就会执行，而后控制就会进入 finally 块（若是有的话）。

    finalize—方法名。Java 技术容许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去以前作必要的清理工做。这个方法是由垃圾收集器在肯定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，所以全部的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其余清理工做。finalize()方法是在垃圾收集器删除对象以前对这个对象调用的。

short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

         short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改成s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

sleep() 和 wait() 有什么区别?

         sleep()：为当前线程指定挂起的时间，是使线程中止一段时间，在sleep 时间间隔期满后，线程不必定当即恢复执行。这是由于在那个时刻，其它线程可能正在运行并且没有被调度为放弃执行，除非(a)"醒来"的线程具备更高的优先级

         wait()：释放对象上的锁，并阻塞当前线程，直到它从新获取该锁。线程交互时，若是线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

数组有没有length()这个方法? String有没有length()这个方法？

数组和string都没有Length()方法，只有Length属性。

Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==仍是equals()? 它们有何区别?

         Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。

         equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

List, Set, Map是否继承自Collection接口?

List，Set是Map不是

abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

         都不能。

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

         不能，一个对象的一个synchronized方法只能由一个线程访问。

swtich是否能做用在byte上，是否能做用在long上，是否能做用在String上?

         switch（expr1）中，expr1是一个整型，字符或字符串，所以能够做用在byte和long上，也能够做用在string上。       

两个对象值相同(x.equals(y) == true)，但却可有不一样的hash code，这句话对不对?

         不对，有相同的hash code。

try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，何时被执行，在return前仍是后?

         会执行，在return前执行。

构造器Constructor是否可被override?

         构造器Constructor不能被继承，所以不能重写Overriding，但能够被重载Overloading。

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

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

启动一个线程是用run()仍是start()?

         启动一个线程是调用start()方法，使线程所表明的虚拟处理机处于可运行状态，这意味着它能够由JVM调度并执行。这并不意味着线程就会当即运行。run()方法能够产生必须退出的标志来中止一个线程。

String s = new String("xyz");建立了几个String Object?

对JAVA来讲两个对象，一个是"xyx"，一个是指向"xyx"的引用对象s。

对.NET来讲该题是错误的，根本就没这样的构造函数

         String a="xyz";首先会到常量池中去查找，若是存在就再也不分配，若是不存在就分配，常量池中的数据是在编译期赋值的，也就是生成class文件时就把它放到常量池里了。

GC是什么? 为何要有GC?

         GC是垃圾收集器。程序员不用担忧内存管理，由于垃圾收集器会自动进行管理。要请求垃圾收集，能够调用下面的方法之一：

  System.gc()

  Runtime.getRuntime().gc()

能用foreach遍历访问的对象须要实现_____接口或声明_____方法的类型。

IEnumerable 、 GetEnumerator。

在.net中，配件的意思是？

程序集。（中间语言，源数据，资源，装配清单）

什么叫应用程序域

一种边界，它由公共语言运行库围绕同一应用程序范围内建立的对象创建（即，从应用程序入口点开始，沿着对象激活的序列的任何位置）。

应用程序域有助于将在一个应用程序中建立的对象与在其余应用程序中建立的对象隔离，以使运行时行为能够预知。隔离正在运行的应用程序。

在一个单独的进程中能够存在多个应用程序域。应用程序域能够理解为一种轻量级进程。起到安全的做用。占用资源小。

就是为安全性，可靠性，隔离性，和版本控制，及卸载程序提供的隔离边界。它一般由运行库宿主建立，应用程序域提供了一个更安全，用途更广的处理单元。

什么是强类型，什么是弱类型？哪一种更好些？为何?

         强类型是在编译的时候就肯定类型的数据，在执行时类型不能更改，而弱类型在执行的时候才会肯定类型。没有好很差，两者各有好处，强类型安全，由于它事先已经肯定好了，并且效率高。通常用于编译型编程语言，如c++,java,c#,pascal等,弱类型相比而言不安全，在运行的时候容易出现错误，但它灵活，多用于解释型编程语言，如javascript,vb等

什么是受管制的代码？什么是强类型和弱类型系统？ CTS、CLS和CLR分别做何解释？

（1）受管制的代码:在.NET环境中运行的任何代码都称为受管制的代码(unmanaged code)，.NET外部的其余代码也运行在Windows上，这些代码称为未受管制的代码(unmanaged code) 。

（2）强类型和弱类型的区别在与，在编码过程当中是否要指定数据类型，做为强类型必须指定数据类型，编译器为其分配相应的存储空间（如   c   ,pascal   )不然编译出错。而弱类型不必定须要指定数据类型，编译器会用相同的空间去分配各类类型，除非你指定了（如basic)。做为强类型语言，在编译阶段的安全性要高于弱语言型。

强类型系统：RTTI：类型识别系统。 

（3）CLR（Common Language Runtime）的全称是公共语言运行库，读者能够把CLR理解为一个包含运行.NET程序的引擎和一堆符合公共语言基础结构的类库的集合。CLR是一个规范的实现，咱们开发的几乎全部的.NET程序都基于CLR的类库来实现，而且运行在CLR提供的运行引擎之上。所谓.NET框架，指的就是公共语言运行库。

         公共语言基础（CLI）是微软公司向ECMA提交的一份语言和数据格式规范，CLR是目前为止惟一一个公共语言基础的实现版本。

         CTS（Common Type System）的全称是通用类型系统。前文已经介绍了公共语言基础（CLI）的概念，微软公司提交的CLI规范，包括了公共类型系统（CTS）、公共中间语言（CIL）、底部文件格式以及元数据格式等。公共类型系统定义了一个可以在CLR上运行的语言规范。尽管有不少语言自己不符合CTS规范，可是经过增强编译器，改变语言附加规范等手段，使得许多语言可以编写出能在CLR上运行的程序。

         一种语言编写的程序编译可以在CLR上运行，并不表明这种语言自己彻底符合CTS的规范。例如C++语言，仍然保持了其不符合CTS规范的部分，而且在编译时把这部分不符合CTS的代码编译成原始代码而非中间代码。　　

CLS（Common Language Specification）的全称是通用语言规范，是CTS的一个子集，它定义了但愿编写在.NET平台上运行的程序的语言所需符合的最小规范。正由于.NET容许由不一样语言编写的程序一块儿执行，因此才制定出CLS规范，用以免不一样语言特性产生的错误。

.net中哪项技术（CLR、CTS、CLS）实现跨多语言？

CLR

CLR与IL分别是什么含义？

         CLR(公共语言运行库)：能管理内存，可以轻松地设计其对象能够跨语言互动的组件和应用程序，编译一次，并能够在任何支持运行库的CPU和操做系统上运行，跨语言集成（特别是跨语言继承）

         公共语言运行时，相似于Java中的JVM，Java虚拟机；在.Net环境下，各类编程语言使用一种共同的基础资源环境，这就是CLR，CLR将直接与操做系统进行通讯，而编程语言如C#.NET将尽可能避免直接与操做系统直接通讯，增强了程序代码的执行安全性，能够这样看：CLR就是具体的编程语言如：C#.NET与操做系统之间的翻译，同时它为具体的编程语言提供了许多资源。

 

         IL(中间语言)：可用于语言互操做性，IL不是字节代码，但很接近字节代码，所以执行应用程序时，IL到机器代码的转换要快不少。独立于CPU的指令集。由CLR转换为特定于CPU的代码。

         IL中间语言，也称MSIL，微软中间语言，或CIL，通用中间语言；全部.NET源代码（无论用哪一种语言编写）在进行编译时都被编译成IL。在应用程序运行时被即时（Just-In-Time，JIT）编译器处理成为机器码，被解释及执行。

对象可否调用静态方法

对象能调用静态方法。

PID是什么？在作系统的故障排除时如何使用它？

         PID是进程编号，在系统发现故障的时候，能够根据它寻找故障所发生的具体进程，而且可经过visual studio.net等ide将故障进程附加到进程中进行调试(debug)

单个TCP/IP端口上可以被多少个进程侦听？

１个

描述一下C#中索引器的实现过程，是否只能根据数字进行索引？

         索引器能够使客户程序很方便地访问类中的集合或数组，相似经过索引访问数组，而且索引器向客户程序隐藏了内部的数据结构。

         相似于属性，访问类或结构的集合或数组时，能够用索引器实现，索引器用this关键字声明，声明方法以下：

数据类型 this[参数列表]

{

         get

{

                   以参数为索引返回集合或数组数据

}

set

{

                   分配值到参数索引的元素

}

}

例：本身创建一个数组

using System;

class MyArray

{

    private string[] str = new string[5];

    //定义索引器，并有可读可写属性，用this声明属性，接收一个整型类型参数

    public string this[int i]

    {

        get

        {

            return str[i];

        }

        set

        {

            str[i] = value;

        }

    }

    //得到数组长度

    public int Length

    {

        get

        {

            return str.Length;

        }

    }

}

public class LxIndex

{

    static void Main(string[] args)

    {

        MyArray ma = new MyArray();

        //给数组赋值

        Console.WriteLine("给数组赋值,请输入数组元素值：");

        for (int i = 0; i < ma.Length; i++)

        {

            ma[i] = Console.ReadLine();

        }

        //输出数组中的元素

        Console.WriteLine("你输入的内容是：");

        for (int i = 0; i < ma.Length; i++)

        {

            Console.Write(ma[i] + " ");

        }

    }

}

结果：

给数组赋值,请输入数组元素值：

78

tom

**

100

23

你输入的内容是：

78 tom ** 100 23 请按任意键继续. . .

         不是。索引器能够用任意类型进行索引。

MVC模式

MVC(Model View Controller)模型－视图－控制器

模型负责业务领域的事情，视图负责显示的事情，控制器把数据读取出来填充模型后把模型交给视图去处理。而各类验证应该是在模型里处理了。它强制性的使应用程序的输入、处理和输出分开。MVC最大的好处是将逻辑和页面分离。

Assembly.Load("foo.dll"); 这句话是否正确？

错误，正确的应该是Assembly.Load("foo"); 或者Assembly.LoadFrom("foo.dll");

DateTime是否能够为null?

不能，由于其为Struct类型，而结构属于值类型，值类型不能为null,只有引用类型才能被赋值null

using() 语法有用吗？什么是IDisposable？它是如何实现肯定性终结的

有用，实现了IDisposiable的类在using中建立，using结束后会自定调用该对象的Dispose方法，释放资源。不明白什么是肯定性终结

三层架构，用.Net作B/S结构的系统，您是用几层结构来开发，每一层之间的关系以及为何要这样分层？

表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。目的即为了“高内聚，低耦合”的思想。

表现层（UI）：通俗讲就是展示给用户的界面，即用户在使用一个系统的时候的所见所得。

         业务逻辑层（BLL）：业务层通常分为二层，业务表观层实现与表示层的沟通，业务规则层实现用户密码的安全等。

表示层：为了与用户交互例如用户添加表单针对具体问题的操做，也能够说是对数据层的操做，对数据业务逻辑处理。

数据访问层（DAL）：该层所作事务直接操做数据库，针对数据的增添、删除、修改、更新、查找等每层之间是一种垂直的关系。

三层结构是N层结构的一种，通常来讲，层次之间是向下依赖的，下层代码未肯定其接口（契约）前，上层代码是没法开发的，下层代码接口（契约）的变化将使上层的代码一块儿变化。

优势： 分工明确，条理清晰，易于调试，并且具备可扩展性。

缺点： 增长成本。

C#函数中无参数修饰符、out修饰符、params修饰符、ref修饰符的区别

无参数修饰符：表示按值传递

out修饰符：表示按引用传递，传递前不需赋初值，但在传入的方法内赋值，不然报错

ref修饰符：表示按引用传递，传递前必须赋初值，不然报错

params修饰符：可将不肯定个数的一组相同类型的数据做为参数传递，函数签名中只能有一个params修饰符，而且应为最后一个参数。

ref 与out有什么不一样？

      方法参数上的 ref 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所作的任何更改都将反映在该变量中。若要使用 ref 参数，必须将参数做为 ref 参数显式传递到方法。ref 参数的值被传递到 ref 参数。传递到 ref 参数的参数必须最早初始化。将此方法与 out参数相比，后者的参数在传递到 out 参数以前没必要显式初始化。属性不是变量，不能做为 ref 参数传递。若是两种方法的声明仅在它们对 ref 的使用方面不一样，则将出现重载。可是，没法定义仅在 ref 和 out 方面不一样的重载。

     方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所作的任何更改都将反映在该变量中。

         当但愿方法返回多个值时，声明 out 方法很是有用。使用 out 参数的方法仍然能够返回一个值。一个方法能够有一个以上的 out 参数。若要使用 out 参数，必须将参数做为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。没必要初始化做为 out 参数传递的变量。然而，必须在方法返回以前为 out 参数赋值。属性不是变量，不能做为 out 参数传递。若是两个方法的声明仅在 out 的使用方面不一样，则会发生重载。不过，没法定义仅在 ref 和 out 方面不一样的重载。

 

extern 是什么意思？

extern 修饰符用于声明由程序集外部实现的成员函数，常常用于系统API函数的调用（经过 DllImport ）。注意，和DllImport一块儿使用时要加上 static 修饰符

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

不能与 abstract 修饰符同时使用

using System.Runtime.InteropServices;

using System;

namespace TestExtern

{

    class ClassHello

    {

        //extern与DllImport一块儿使用时必须再加上一个static修饰符

        [DllImport("User32.dll")]

        public static extern int MessageBox(int Handle, string Message, string Caption, int Type);

        static void Main()

        {

            string myString;

            Console.Write("请输入提示信息: ");

            myString = Console.ReadLine();

            MessageBox(0, myString, "个人测试", 0);

        }

    }

}

结果：

 

 

对象构造器

         使用对象构造器,能够使初始化对象像初始化数组同样简单，即在构造函数后直接添加多个初始化语句代码，并用逗号分隔，总体用{}括起来，定义形式以下：

        类型声明 实例名称 = new 类型名称() {初始化语句1,初始化语句2};

         若是相同成员的不一样初始化语句，则以最右面的语句为准。初始化的顺序是先执行构造函数的语句，而后执行对象构造器中的语句。以下例：

Snake s = new Snake () {name="眼镜蛇",length=12,weight=20};

C#匿名类型的的实际应用

经过var和对象构造器，声明一个没有名称（其名称是由编译器分配的）的类，同时建立并初始化成员。如：var pc1 = new {cpu="Intel",memory="AMD"};

若是程序仅仅须要临时一组数据，则用匿名类型比较合适，匿名类型编译后，仍然是一个普通的密封类，不可派生其余类，只是名称是由编译器分配的，利用对象构造器初始化的成员，具备只读属性。匿名内部类一样有构造函数用于初始化成员，只是建立时不须要显式调用。以下列：

const和readonly区别

均可以标识一个常量。主要有如下区别：

一、初始化位置不一样。const必须在声明的同时赋值；readonly便可以在声明处赋值，也能够在静态构造方法（必须是静态构造方法，普通构造方法不行）里赋值。

二、修饰对象不一样。const便可以修饰类的字段，也能够修饰局部变量；readonly只能修饰类的字段

三、const是编译时常量，在编译时肯定该值；readonly是运行时常量，在运行时肯定该值。

四、const默认是静态的；而readonly若是设置成静态须要显示声明

五、修饰引用类型时不一样，const只能修饰string或值为null的其余引用类型；readonly能够是任何类型。

若是类型限制了不能在编译时肯定它的值，能够使用static readonly来代替。

请解释virtual的含义？

     virtual 关键字用于修改方法或属性的声明，在这种状况下，方法或属性被称做虚拟成员。虚拟成员的实现可由派生类中的重写成员更改。

         调用虚方法时，将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员，若是没有派生类重写该成员，则它多是原始成员。默认状况下，方法是非虚拟的。不能重写非虚方法。不能将 virtual 修饰符与如下修饰符一块儿使用：static   abstract   override除了声明和调用语法不一样外，虚拟属性的行为与抽象方法同样。

         在静态属性上使用 virtual 修饰符是错误的。

         经过包括使用 override 修饰符的属性声明，可在派生类中重写虚拟继承属性

sealed、new、virtual、abstract与override关键字的区别

sealed修饰类表明密封类，不能被继承，修饰方法表明密封方法，不能被重写。一般用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承形成层次结构混乱

new 显式隐藏基类的成员。不用new隐藏基类的成员也能够，但会给出警告。

virtual为了子类来重写的，子类须要override，若是不用会给个警告

abstract能够修饰类，方法，属性，索引器及事件。

override子类重写基类的abstract，virtual成员，。不能重写非虚拟方法或静态方法

new和override相同点和区别

相同点：均可以对基类成员进行隐藏，均可以用base调用基类的成员

不一样点：

一、用override重写基类的方法，要求与基类必须有彻底相同的访问修饰符、返回值类型和方法名称名称，参数，异常。new不用

二、用override重写基类的方法，要求基类的方法必须为虚拟的，抽象的或重写的（virtual，abstract,override），而new没必要要

三、继承后，用一个基类的对象调用基类的virtual方法时，override重写的子类方法会被访问，而new重写的子类方法不会被访问（只访问基类的virtual方法）

四、new做为运算符时，建立对象，调用构造函数。new 用于约束时 用于在泛型声明中，约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。

例

using System;

public class BaseClass

{

    public BaseClass()

    {

        Console.WriteLine(" 基类构造");

    }

    //使用virtual才能够在子类中使用override，而new没必要要

    public virtual void Method()

    {

        Console.WriteLine(" 基类.Method()");

    }

}

public class ClassA : BaseClass

{

    public ClassA()

    {

        Console.WriteLine(" 类A.构造");

    }

    public override void Method()

    {

        //base.Method();

        Console.WriteLine(" 类A.Method() in override");

    }

}

public class ClassB : BaseClass

{

    public ClassB()

    {

        Console.WriteLine(" 类B.构造");

    }

    public new void Method()

    {

        //base.Method();

        Console.WriteLine(" 类B.Method() in new");

    }

}

 

 

class Program

{

    static void Main(string[] args)

    {

        BaseClass ba1 = (BaseClass)new ClassA();//类型转换

        //用override重写方法，是基类的一个派生，

        //因此这里经过基类的虚函数，会访问到派生类的方法。

        ba1.Method();

        Console.WriteLine(" =================");

 

        BaseClass bb2 = (BaseClass)new ClassB();//类型转换

        //用new重写方法，是一个和基类无关的新方法，

        //因此这里基类调用的时候，访问基类的方法。

        bb2.Method();

        Console.WriteLine(" =================");

 

        ClassA a1 = new ClassA();

        a1.Method();

        Console.WriteLine(" =================");

 

        ClassB b2 = new ClassB();

        b2.Method();

        Console.WriteLine(" =================");

        Console.ReadKey();

 

    }

}

 

运行结果：

 基类构造

 类A.构造

 类A.Method() in override

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

 基类构造

 类B.构造

 基类.Method()

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

 基类构造

 类A.构造

 类A.Method() in override

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

 基类构造

 类B.构造

 类B.Method() in new

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

Web.config配置Windows身份认证

         您须要建立一个ASP.NET应用程序，公司考虑使用Windows身份认证。全部的用户都存在于AllWin这个域中。您想要使用下列认证规则来配置这个应用程序：1 匿名用户不容许访问这个应用程序。2全部雇员除了Tess和King都容许访问这个应用程序。请问您应该使用哪个代码段来配置这个应用程序？

<authorization>

    <allow users="*">

    <deny users="allwin\tess, allwin\king">

    <deny users="?">

</authorization>

Global.asax文件中配置自定义的错误

         问：您要建立ASP.NET应用程序用于运行AllWin公司内部的Web站点，这个应用程序包含了50个页面。您想要配置这个应用程序以便当发生一个HTTP代码错误时它能够显示一个自定义的错误页面给用户。您想要花最小的代价完成这些目标，您应该怎么作？

         答：在这个应用程序的Global.asax文件中建立一个Application_Error过程去处理ASP.NET代码错误。

在DataGrid控件的Footer显示员工合计数

         问：您要建立一个显示公司员工列表的应用程序。您使用一个DataGrid控件显示员工的列表。您打算修改这个控件以便在这个Grid的Footer显示员工合计数。请问您应该怎么作？

         答：重写OnItemCreated事件，当Grid的Footer行被建立时显示合计数。

如何在这个程序中使用Web Service

         问：您为AllWin公司建立了一个ASP.NET应用程序。这个应用程序调用一个Xml Web Service。这个Xml Web Service将返回一个包含了公司雇员列表的DataSet对象。请问您该如何在这个程序中使用这个Xml Web Service？---答：

         答：在“Web引用”对话框中输入这个XML Web service的地址。

修改程序

         问：您要建立一个ASP.NET应用程序在DataGrid控件中显示一个通过排序的列表。产品数据被存放于一个名为PubBase的Microsoft SQL Server 数据库。每一个产品的主键是ProductID，Numeric型而且每一个产品有一个字母描述字段，名为ProductName。您使用一个SqlDataAdapter对象和一个SqlCommand对象经过调用一个存储过程从数据库中获取产品数据。您将SqlCommand对象的CommandType属性设置为CommandType.StoredProcedure，并将它的CommandText属性设置为procProductList。您成功的获取了一个DataTable对象，其中是已经按ProductID降序排列的产品列表。您打算显示以相反的字母顺序排列的ProductName，请问该怎么作？

         答：将SqlCommand对象的CommandType属性修改成CommandType.Text，将CommandText属性修改成”SELECT * FROM procProductList ORDER BY ProductName DESC”。而后将这个DataTable对象绑定到DataGrid控件。

货币的值如何按各个不一样国家的习惯来输出

         问：在C#中有一个double型的变量，好比10321.5，好比122235401.21644，做为货币的值如何按各个不一样国家的习惯来输出。好比美国用$10,321.50和$122，235，401.22而在英国则为￡10  321.50和￡122  235  401.22。

using System;

using System.Globalization;

class Program

{

    static void Main(string[] args)

    {

        //CultureInfo 类呈现区域性特定的信息，如关联的语言、子语言、国家/地区、日历和区域性约定。

        System.Globalization.CultureInfo myCultureUS = new System.Globalization.CultureInfo("en-US");

        CultureInfo myCultureEN = new CultureInfo("en-GB");

        CultureInfo myCultureCN = new CultureInfo("zh-CN");

        double x = 10321.5, y = 122235401.21644;

 

        string str = String.Format(myCultureUS, "My amount={0:c}（美国）", y);

        Console.WriteLine(str);

 

        str = String.Format(myCultureEN, "My amount={0:c}（英国）", y);

        Console.WriteLine(str);

 

        str = String.Format(myCultureCN, "My amount={0:c}（中国）", y);

        Console.WriteLine(str);

    }

}

结果：

My amount=$122,235,401.22（美国）

My amount=￡122,235,401.22（英国）

My amount=￥122,235,401.22（中国）

请按任意键继续. . .

error和exception有什么区别?

         error 表示恢复不是不可能但很困难的状况下的一种严重问题。好比说内存溢出。不可能期望程序能处理这样的状况。 exception 表示一种设计或实现问题。也就是说，它表示若是程序运行正常，从不会发生的状况。

要用新浪网上的天气预报，怎么办？

用webservice，请求国家气象局的接口。用ajax把新浪网上的网页请求过来，而后解析一下。

母板页与内容页中怎么传参（除Session、Cookie、Application、QuerySting、this.Server.Transfer以外）？

获取母版页上文本框的值赋给内容页的文本框

this.TextBox1.Text = (Master.FindControl("textBox1") as TextBox).Text;

获取内容页上文本框的值赋给母版页的文本框

TextBox1.Text = (this.ContentPlaceHolder1.FindControl("textBox1") as TextBox).Text;

两根分布不均匀的香，所有烧完需1个小时，如何肯定一段15分钟的时间？

同时点燃第一根的两端和第二根的一端，第一根烧完是半个小时，这时点燃第二根的另外一端并开始计时，所有烧完就是15分钟。

Xml文档定义的形式？它们的本质区别？解析Xml文档的方式？

a: 两种形式 dtd schema；b: 本质区别:schema自己是xml的，能够被XML解析器解析(这也是从DTD上发展schema的根本目的)；c:有DOM,SAX,STAX等。

DOM:处理大型文件时其性能降低的很是厉害。这个问题是由DOM的树结构所形成的，这种结构占用的内存较多，并且DOM必须在解析文件以前把整个文档装入内存,适合对XML的随机访问。

SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不须要一次所有装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户经过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问。

STAX:Streaming API for XML（流的API的XML） (StAX）。

.在.net（C# or vb.net）中如何取消一个窗体的关闭。

private void Form1_FormClosing(object sender, FormClosingEventArgs e)

{

    e.Cancel = true;

}

在.net（C# or vb.net）中，Appplication.Exit 仍是 Form.Close有什么不一样？

一个是退出整个应用程序，一个是关闭其中一个form。

62-63=1 等式不成立，请移动一个数字（不能够移动减号和等于号），使得等式成立，如何移动？

62移动成2的6次方

得到枚举中的常数名称和常数值

经过Enum.GetNames(typeof(枚举))得到枚举名称，Enum.GetValues(typeof(枚举))得到枚举常数值

例如：对于这样的一个枚举类型

using System;

using System.Globalization;

class Program

{

    enum Color : byte

    {

        Red, Green, Blue, Orange

    }

 

    static void Main(string[] args)

    {

 

        string[] sa = Enum.GetNames(typeof(Color));     // Red, Green, Blue, Orange

        Console.WriteLine("枚举中的常数名称：");

        foreach (string s in sa)

            Console.Write(s + "\t");

        Console.WriteLine();

 

        byte[] sb = (byte[])Enum.GetValues(typeof(Color)); // 0,1,2,3

        Console.WriteLine("枚举中的常数值：");

        foreach (byte s in sb)

            Console.Write(s + "\t");

 

        Console.WriteLine();

    }

}

结果：

枚举中的常数名称：

Red     Green   Blue    Orange

枚举中的常数值：

0       1       2       3

请按任意键继续. . .

Anonymous Inner Class (匿名内部类) 是否能够extends(继承)其它类，是否能够implements(实现)interface(接口)?            

不能，能够实现接口

Static Nested Class 和 Inner Class的不一样，说得越多越好
    Static Nested Class是被声明为静态（static）的内部类，它能够不依赖于外部类实例被实例化。而一般的内部类须要在外部类实例化后才能实例化。

HashMap和Hashtable的区别。

         HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap容许空（null）键值（key）,因为非线程安全，效率上可能高于Hashtable.

分析如下代码。

    public static void test(string ConnectString)

    {

        System.Data.OleDb.OleDbConnection conn = new System.Data.OleDb.OleDbConnection();

        conn.ConnectionString = ConnectString;

        try

        {

            conn.Open();

            //……

        }

        catch (Exception Ex) {

            MessageBox.Show(Ex.ToString());

        }

        finally {

            if (!conn.State.Equals(ConnectionState.Closed))conn.Close();

        }

}

1)以上代码能够正确使用链接池吗？

         若是传入的connectionString是如出一辙的话，能够正确使用链接池。不过如出一辙的意思是，连字符的空格数，顺序彻底一致。

2)以上代码所使用的异常处理方法，是否全部在test方法内的异常均可以被捕捉并显示出来？

         只能够捕捉数据库链接中的异常吧. （finally中，catch中，若是有别的可能引起异常的操做，也应该用try,catch。因此理论上并不是全部异常都会被捕捉。）

什么是WSE？目前最新的版 本是多少？

         WSE (Web Service Extension) 包来提供最新的WEB服务安全保证，目前最新版本2.0。

请谈谈对正则表达式？

    能将一些比较复杂的验证逻辑以简单的验证表达式验证.

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

动态调试编译--<compilation/>,自定义错误信息--<customErrors/>,身份验证—<authentication/>,受权--<authorization/>,应用程序级别跟踪记录--<trace/>,会话状态设置--<sessionState/>,全球化--<globalization/>

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

         一个ASP.NET页面通常都对应一个隐藏类,通常都在ASP.NET页面的声明中指定了隐藏类例如一个页面Tst1.aspx的页面声明以下：

<%@ Page language="c#" Codebehind="Tst1.aspx.cs" AutoEventWireup="false" Inherits="T1.Tst1" %>

Codebehind="Tst1.aspx.cs" 代表经编译此页面时使用哪个代码文件

Inherits="T1.Tst1" 表用运行时使用哪个隐藏类

当发现不能读取页面上的输入的数据时颇有多是什么缘由形成的？怎么解决

颇有多是在Page_Load中数据处理时没有进行Page的IsPostBack属性判断

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

         上下文对象是指HttpContext类的Current 属性，当咱们在一个普通类中要访问内置对象(Response,Request,Session,Server,Appliction等)时就要以使用此对象

某一密码仅使用K、L、M、N、O共5个字母，密码中的单词从左向右排列，密码单词必须遵循以下规则：

（1）密码单词的最小长度是两个字母，能够相同，也能够不一样

（2）K不多是单词的第一个字母

（3）若是L出现，则出现次数不止一次

（4）M不能使最后一个也不能是倒数第二个字母

（5）K出现，则N就必定出现

（6）O若是是最后一个字母，则L必定出现

问题一：下列哪个字母能够放在LO中的O后面，造成一个3个字母的密码单词？答案:B

         A) K   B)L   C) M    D) N   

   问题二：若是能获得的字母是K、L、M，那么可以造成的两个字母长的密码单词的总数是多少？答案:A

         A)1个  B)3个  C)6个  D）9个

问题三：下列哪个是单词密码？答案: C

         A) KLLN   B) LOML   C) MLLO   D)NMKO

请解释流与文件有什么不一样？

         文件是一些具备永久存储及特定顺序的字节组成的一个有序的、具备名称的集合。所以，对于文件，人们常会想到目录路径、磁盘存储、文件和目录名等方面。相反，流提供一种向后备存储器写入字节和从后备存储器读取字节的方式，后备存储器能够为多种存储媒介之一。正如除磁盘外存在多种后备存储器同样，除文件流以外也存在多种流。例如，还存在网络流、内存流和磁带流等。

类型系统是由XMLSchema表示的吗？CLS是XMLSchema表示的吗？

问题的翻译，Are the type system represented by XmlSchema and the CLS isomorphic?我以为问题是这样的，XMLSchema和CLS的类型系统类似吗？

XmlSchema是一个特定的XML文档，必须知足的一套标准。这些标准可以描述不一样的数据类型。好比：xs:Boolean

CLS无论值类型仍是引用类型都是一套类型系统，好比System.Boolean.

像不像？你说呢？

从概念上阐述前期绑定（early-binding）和后期绑定（late-binding）的区别?

若是方法在编译时就肯定就是前期绑定，若是在运行时肯定的叫后期绑定。这个就像是强弱类型的比较类似，前期绑定是在编译的时候就肯定了要绑定的数据，然后期绑定是在运行的时候才填充数据。因此前期绑定若是失败，会在编译时报编译错误，然后期绑定失败只有在运行时的时候才发生

举个例子，好比spring在运行时才取类和类的对象，就是后期绑定

调用Assembly.Load算静态引用仍是动态引用？

我的理解其实应该是一个反射，System.Reflection.Assembly.Load.因此嘛确定动态引用了。由于静态引用在编译时就已经引用，并使用。

什么时候使用Assembly.LoadFrom？什么时候使用Assembly.LoadFile？

（声明如下是抄的，我不太了解Assembly.LoadFrom）。区别以下：

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

Assembly.LoadFrom则不同，它会载入相应的dll文件及其引用的其余dll，好比上面的例子，b.dll也会被载入。

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

Assembly.LoadFile的话则不会作这样的检查，好比上面的例子换成Assembly.LoadFile的话，则能正确载入版本2。

什么叫Assembly Qualified Name？它是一个文件名吗？它有什么不一样？

它不是一个文件名，相比文件名，Assembly Qualified Name（程序集限定名称），更能肯定一个程序集，它包含文件名，但同时包含版本，公钥，和区域。由于一样一个名称的文件可能有不一样的版本和区域，此时单独靠文件名称，可能会形成不能肯定程序集的正确性。

作强签名的assembly与不作强签名的assembly有什么不一样？

强签名的程序集能够确认assembly name是惟一的（由于使用了public key token）。

强签名的程序集能够作成com。

强签名程序集能够安装到GAC中。

DateTime是否能够为null?

不能为null，包括int什么的都不能等于null。固然2.0能够里加可空类型，可是在编译后你会发现可空类型实际上是假的。

什么叫JIT？什么是NGEN？它们分别有什么限制和好处？

.NET 采用中间语言(IL)机制。JIT(Just In Time)即时编译是指程序第一次运行的时候才进行把中间语言(IL)编译成机器代码，JIT增长了执行效率。

本机映像生成器 (Ngen.exe) 是一个提升托管应用程序性能的工具。

Ngen.exe 建立本机映像（包含经编译的特定于处理器的机器代码的文件），并将它们安装到本地计算机上的本机映像缓存中。运行库可从缓存中使用本机映像，而不是使用实时 (JIT) 编译器编译原始程序集。这是为何asp.net程序第一次会比较慢，由于他是JIT。

.NET CLR中一代的垃圾收集器是如何管理对象的生命周期的？什么叫非肯定性终结？

垃圾收集器不能管理对象的生命周期吧？？我认为他只能跟踪对象的生命周期

先看一个对象的生命周期

1.  调用IL的newobj指令，分配必定空间的内存。

2.  初始化内存空间，好比设置为string类型。

3.  使用对象。

4.  销毁对象，执行清理

5.  回收内存

垃圾收集是在第4步。有三种方法：Finalize、Dispose、Close。

但垃圾收集执行的时机不定的，初学者能够认为对象销毁的时机是在垃圾收集器认为对象须要被销毁的时候进行的，他对于程序员是透明的，初学者根本不须要知道垃圾收集器的存在。

我的理解的垃圾收集器的执行原理周期性地遍历被应用当前引用的全部对象的列表。在这个搜索过程当中，凡是没有发现的对象，都将准备予以销毁(但不并非立刻就销毁，只是先标记)。这种算法表示若是对象的最后一个引用也被解除时（意思是该对象不再使用了，便可以销毁了），这时垃圾收集器并不会当即接到通知，只有下一次对堆（heap）进行清扫时，才能发现这个状况。 说明了对象在何时终结是不肯定的，我认为这就是非肯定性终结。进一步而言，执行垃圾收集清扫次数越少，这类算法工做得越好。一般来讲，堆的耗满是收集清扫的触发条件。

Finalize()和Dispose()之间的区别?

Finalize自动释放资源，Dispose()用于手动释放资源。

一. Finalize

Finalize很像C++的析构函数，咱们在代码中的实现形式为这与C++的析构函数在形式上彻底同样，但它的调用过程却大不相同。

~ClassName() {//释放你的非托管资源}

好比类A中实现了Finalize函数，在A的一个对象a被建立时（准确的说应该是构造函数被调用以前），它的指针被插入到一个finalization链表中；在GC运行时，它将查找finalization链表中的对象指针，若是此时a已是垃圾对象的话，它会被移入一个freachable队列中，最后GC会调用一个高优先级线程，这个线程专门负责遍历freachable队列并调用队列中全部对象的Finalize方法，至此，对象a中的非托管资源才获得了释放（固然前提是你正确实现了它的Finalize方法），而a所占用的内存资源则必需等到下一次GC才能获得释放，因此一个实现了Finalize方法的对象必需等两次GC才能被彻底释放。

因为Finalize是由GC负责调用，因此能够说是一种自动的释放方式。可是这里面要注意两个问题：第一，因为没法肯定GC什么时候会运做，所以可能很长的一段时间里对象的资源都没有获得释放，这对于一些关键资源而言是很是要命的。第二，因为负责调用Finalize的线程并不保证各个对象的Finalize的调用顺序，这可能会带来微妙的依赖性问题。若是你在对象a的Finalize中引用了对象b，而a和b二者都实现了Finalize，那么若是b的Finalize先被调用的话，随后在调用a的Finalize时就会出现问题，由于它引用了一个已经被释放的资源。所以，在Finalize方法中应该尽可能避免引用其余实现了Finalize方法的对象。

可见，这种“自动”释放资源的方法并不能知足咱们的须要，由于咱们不能显示的调用它（只能由GC调用），并且会产生依赖型问题。咱们须要更准确的控制资源的释放。

二. Dispose

Dispose是提供给咱们显示调用的方法。因为对Dispose的实现很容易出现问题，因此在一些书籍上（如《Effective C#》和《Applied Microsoft.Net Framework Programming》）给出了一个特定的实现模式：

using System;

using System.Globalization;

class DisposePattern :IDisposable

{

    private System.IO.FileStream fs = new System.IO.FileStream("test.txt", System.IO.FileMode.Create);

 

    //析构函数

    ~DisposePattern()

    {

        Dispose(false);

    }

    //IDisposable Members

    #region IDisposable Members

    public void Dispose()

    {

        //告诉GC不须要再调用Finalize方法，

        //由于资源已经被显示清理

        GC.SuppressFinalize(this);

        Dispose(true);

    }

    #endregion

    protected virtual void Dispose(bool disposing)

    {

        //因为Dispose方法可能被多线程调用，

        //因此加锁以确保线程安全

        lock (this)

        {

            if (disposing)

            {

                //说明对象的Finalize方法并无被执行，

                //在这里能够安全的引用其余实现了Finalize方法的对象

            }

            if (fs != null)

            {

                fs.Dispose();

                fs = null; //标识资源已经清理，避免屡次释放

            }

        }

    }

}

 

在注释中已经有了比较清楚的描述，另外还有一点须要说明：若是DisposePattern类是派生自基类B，而B是一个实现了Dispose的类，那么DisposePattern中只须要override基类B的带参的Dispose方法便可，而不须要重写无参的Dispose和Finalize方法，此时Dispose的实现为：

class DerivedClass : DisposePattern

{

    protected override void Dispose(bool disposing)

    {

        lock (this)

        {

            try

            {

                //清理本身的非托管资源，

                //实现模式与DisposePattern相同

            }

            finally

            {

                base.Dispose(disposing);

            }

        }

    }

}

固然，若是DerivedClass自己没有什么资源须要清理，那么就不须要重写Dispose方法了，正如咱们平时作的一些对话框，虽然都是继承于System.Windows.Forms.Form，但咱们经常不须要去重写基类Form的Dispose方法，由于自己没有什么非托管的咚咚须要释放。

了解GC的脾性在不少时候是很是必要的，起码在出现资源泄漏问题的时候你不至于手足无措。我写过一个生成excel报表的控件，其中对excel对象的释放就让我忙活了一阵。若是你作过excel开发的话，可能也遇到过结束excel进程之类的问题，特别是包装成一个供别人调用的库时，什么时候释放excel对象以确保进程结束是一个关键问题。固然，GC的内部机制很是复杂，还有许多内容可挖，但了解全部细节的成本过高，只需了解基础，够用就好。

using() 语法有用吗？什么是IDisposable？它是如何实现肯定性终结的。

using()能自动调用Dispose方法

好比：using()会自动调用MyObject的Dispose方法

using ( MyObject myObject = new MyObject ( ) )

{

   Console.WriteLine ( "quit" ) ;

}

IDisposiable是显示释放对象的接口，实现IDisposiable接口的类，能够显示的释放对象。经过编写Dispose方法来实现显式释放资源；

// C#

class MyClass : IDisposable

{

    // 构造函数

    public MyClass() {

   

    }

 

    // 析构方法 (不肯定的) (编译器经过重载virtual void Finalize来实现)，与C++/CLI的!MyClass()等效

    ~MyClass() {

   

    }

 

    // Dispose方法

    public void Dispose() { }  

    public static void Test()

    {

        using (MyClass auto = new MyClass())

        {

       

        }

        // 由于使用了using句法，编译器自动调用auto.Dispose()

        // 以上代码等效于:

        MyClass user = new MyClass();

        try {

 

        }

        finally {

            user.Dispose();

        }

    }

}

 

tasklist /m "mscor*" 这句命令是干吗的？

列出全部使用了以" mscor"做为开头的dll或者exe的进程和模块信息

in-proc和out-of-proc的区别

in-proc是进程内，进程内能共享代码和数据块，out-of-proc是进程外，进程外的互操做须要用进程间通信来实现。

.NET里的哪一项技术可以实现out-of-proc通信？

.Net Remoting技术或者WCF技术

当你在ASP.NET中运行一个组件时，它在Windows XP, Windows 2000, Windows 2003上分别跑在哪一个进程里面？

Xp : aspnet_Wp.exe

Windows 2000 : inetinfo.exe

Windows 2003 : w3wp.exe

在.Net中全部可序列化的类都被标记为何？

[serializable]

DateTime.Parse(myString); 这行代码有什么问题？ 

         有问题，当myString不能知足时间格式要求的时候，会引起异常，建议使用DateTime.TryParse() 

PDB是什么东西? 在调试中它应该放在哪里？ 

         PDB是用于保存调试和项目状态信息的文件，在debug的时候将产生pdb文件，调试的时候应该放在和对应应用程序集相同目录。 

什么叫圈复杂度（cyclomatic complexity）？为何它很重要？ 

不知道，望指教 ？ 

写一个标准的lock()，在访问变量的先后建立临界区，要有"双重检查"，

lock的使用

    public void LockTest()

    {

        Object lockObj = new Object();

        lock (lockObj)

        {

            //

        }

    }

什么叫FullTrust？放入GAC的assembly是不是FullTrust的? 

         FullTrust彻底信任。放入GAC中的Assembly是否FullTrust个人理解不是。我理解FullTrust是能够经过代码设定的 

代码加上须要安全权限的特性有什么好处？ 

         能够更加灵活的设置对代码的访问权限，实现代码级保护。这点不是特清楚，有明白的给讲解下 

gacutil /l | find /i "Corillian" 这句命令的做用是什么？ 

         全局程序集缓存中若是有Corillian就更新该程序集，没有就安装 

sn -t foo.dll 这句命令是干吗的？ 

         显示程序集foo.dll的公钥标记 

DCOM须要防火墙打开哪些端口？端口135是干吗用的？ 

         135端口，由于DCOM的端口号是随机分配的，默认状况下，会分配1024以上的端口号，因此默认状况下,DCOM不能穿越防火墙。由于根本不晓得开哪一个端口。但有解决办法能够使DCOM分配的端口号固定，

         有关内容我在http://www.cnblogs.com/jillzhang/archive/2008/02/20/1075057.html 有过一些描述。135是远程过程调用(RPC)的默认端口 

对比OOP和SOA，它们的目的分别是什么？ 

         我想OOP和SOA应该没有对比性吧。OOP是一种编程模型，强调将复杂的逻辑分解出小的模块，特性是继承，封装和多态 。而SOA是一个技术框架，技术框架和编程模型应该说不是一码事吧？SOA的思想是将业务逻辑封装成服务或者中间件提供给应用程序来调用，固然其组件化思想是继承和发扬了OOP的优势。 

XmlSerializer是如何工做的？使用这个类的进程须要什么ACL权限？ 

         我只知道XmlSerializer是将对象的属性和字段进行序列化和反序列化的，序列化成为xml数据，反序列化再将xml转换成对象。应该至少须要ACL权限中的读权限. 

         ACL(access control list) 访问控制表

         ACL是存在于计算机中的一张表，它使操做系统明白每一个用户对特定系统对象，例如文件目录或单个文件的存取权限。每一个对象拥有一个在访问控制表中定义的安全属性。这张表对于每一个系统用户有拥有一个访问权限。最通常的访问权限包括读文件（包括全部目录中的文件），写一个或多个文件和执行一个文件（若是它是一个可执行文件或者是程序的时候）。Windows NT，Novell公司的Netware，Digital公司的 OpenVMS和基于UNIX系统是使用这种访问控制表的系统。而此表的实如今各个系统中却不同。

为何不提倡catch(Exception)？ 

         缘由可能有两点：1）try..catch在出现异常的时候影响性能 2）应该捕获更具体得异常，好比IOExeception,OutOfMemoryException等 

Debug.Write和Trace.Write有什么不一样？什么时候应该使用哪个？ 

         Debug.Write是调试的时候向跟踪窗口输出信息。当编译模式为debug的时候才有效，为release的时候Debug.Write在编译的时候会忽略,而Trace则是在debug和release两种模式下都可以向跟踪窗口输出信息。 

Debug Build和Release Build的区别，是否会有明显的速度变化？请说明理由。 

         Debug会产生pdb文件，release不会。Debug用于开发时的调试，不能要于部署，而release用于部署.debug编译一些特殊代码，好比#IFDEBUG Debug.Write等，而Release则会将那些特殊标记省略 

          PDB 程序数据库文件，文件保存着调试和项目状态信息，使用这些信息能够对程序的调试配置进行增量连接。

JIT是以assembly为单位发生仍是以方法为单位发生？这对于工做区有何影响? 

         方法，道理很简单，由于对于一次运行，极可能只用到一个程序集中极少数类型和对象，而大部分可能并不会被使用，此时CLR傻乎乎的给整个程序集都给Compile了，CLR不是傻疯了么 

a.Equals(b)和a == b同样吗？ 

         不同。a.Equals(b)表示a与b一致， a==b表示a与b的值相等 

在对象比较中，对象一致和对象相等分别是指什么？ 

         对象一致是指两个对象是同一个对象，引用相同。而对象相等是指两个对象的值相同，但引用不必定相同 

在.NET中如何实现深拷贝（deep copy）？ 

         实现IClonable接口 

请解释一下IClonable 

         IClonable方法是实现深度复制的接口，实现它应该能深度复制一个对象出来。深度复制的特征的调用对象的构造方法，建立新的对象，包括建立对象中嵌套的引用对象的新实例。        

         而Shadow复制则不一样，是浅表复制，不从新建立新实例。浅表复制的实现是Object.MemberWiseClone().

深度复制(Deep Copy)与浅表复制(Shadow Copy)的比较

using System;

public class Name

{

    public string FirstName;

    public string LastName;

}

public class Person : ICloneable

{

    public Name PersonName;

    public string Email;

    //// <summary>

    /// Deep Copy的例子

    /// </summary>

    /// <returns></returns>

    public Object Clone()

    {

        Person p = new Person();

        p.Email = this.Email;

        p.PersonName = new Name();

        p.PersonName.FirstName = this.PersonName.FirstName;

        p.PersonName.LastName = this.PersonName.LastName;

        return p;

    }

 

    public void ChangLastName(string lastName)

    {

        this.PersonName.LastName = lastName;

    }

 

    public static void Main()

    {

        Person p = new Person();

        p.PersonName = new Name();

        p.PersonName.LastName = "jill";

        p.PersonName.FirstName = "zhang";

        p.Email = "jillzhang@126.com";

        Person sameNamePerson = p.Clone() as Person;

        sameNamePerson.ChangLastName("clr_");

        Console.WriteLine(p.PersonName.LastName);

        Console.WriteLine(sameNamePerson.PersonName.LastName);

 

 

        Person samePerson = p.MemberwiseClone() as Person;

        samePerson.ChangLastName("Shadow");

 

        Console.WriteLine(p.PersonName.LastName);

        Console.WriteLine(sameNamePerson.PersonName.LastName);

 

        Console.Read();

    }

}

 

结果：

jill

clr_

Shadow

clr_

string是值类型仍是引用类型? 

         引用类型 

XmlSerializer使用的针对属性的模式有什么好处？解决了什么问题？ 

         只序列化有用的数据，而不是序列化整个对象。实现不必的数据冗余，和提高序列化时的性能。 

特性可以放到某个方法的参数上？若是能够，这有什么用？ 

         能够，做用能够对参数有进一步限定，好比输入参数为int类型，能够经过容许AttributeTargets=ParameterInfo的Attribute自定义实现来限定输入参数的大小，好比当输入参数小于100的时候便报错。 

对方法的参数设置Attribute的例子

[AttributeUsage(AttributeTargets.Parameter)]

public class ParameterAtt : Attribute

{

    public int Min = 100;

}

 

public class AttributeTest

{

    public void TestMethod([ParameterAtt(Min = 100)] int par1)

    {

        ParameterInfo para = MethodInfo.GetCurrentMethod().GetParameters()[0];

        ParameterAtt att = ParameterAtt.GetCustomAttribute(para, typeof(ParameterAtt)) as ParameterAtt;

        if (att.Min > par1)

        {

            throw new Exception("要求para1最小为" + att.Min);

        }

    }

} 

用什么方法比较2个字符串类似，且在系统运行时长驻内存？

         生成正则表达式进行比较，使用静态变量/方法就能够长驻内存了

Collection和Collections的区别？

         Collection是集合类的上级接口，Collections是针对集合类的一个帮助类，它提供一系列静态方法来实现对各类集合的搜索，排序，线程安全化操做。

         存在System.Collections 命名空间

死锁的必要条件？怎么克服？

系统的资源不足，进程的推动的顺序不合适，资源分配不当，一个资源每次只能被一个进程使用，一个资源请求资源时，而此时这个资源已阻塞，对已得到资源不放，进程得到资源时，未使用完前，不能强行剥夺。

什么是死锁？死锁（Deadlock）：是指两个或两个以上的进程在运行过程当中，因争夺资源而形成的一种互相等待（谁也没法再继续推动）的现象，若无外力做用，它们都将没法推动下去。

死锁的四个必要条件

l  互斥条件（Mutual exclusion）：资源不能被共享，只能由一个进程使用。

l  请求与保持条件（Hold and wait）：已经获得资源的进程能够再次申请新的资源。

l  非剥夺条件（No pre-emption）：已经分配的资源不能从相应的进程中被强制地剥夺。

l  循环等待条件（Circular wait）：系统中若干进程组成环路，该环路中每一个进程都在等待相邻进程正占用的资源。

处理死锁的策略

1.忽略该问题。例如鸵鸟算法，该算法能够应用在极少发生死锁的的状况下。为何叫鸵鸟算法呢，由于传说中鸵鸟看到危险就把头埋在地底下，可能鸵鸟以为看不到危险也就没危险了吧。跟掩耳盗铃有点像。

2.检测死锁而且恢复。

3.仔细地对资源进行动态分配，以免死锁。

4.经过破除死锁四个必要条件之一，来防止死锁产生。

什么是Windows服务，它的生命周期与标准的EXE程序有什么不一样

Windows 服务是运行在windows后台指定用户下（默认System）的应用程序，它没有标准的UI界面，想比标准的EXE程序，Windows服务是在服务开始的时候建立，而在服务结束的时候销毁，并且能够设置服务是否与操做系统一块儿启动，一块儿关闭。它支持三种方式：１）自动方式 2）手动方式　３）禁用。自动方式的时候，windows服务将在OS启动后自动启动运行，而手动方式则必须手工启动服务，禁用的状况下服务将不能被启动。另外标准的EXE默认使用的当前登陆的用户，而windows服务则默认使用System用户，这在对系统资源访问的时候特别须要注意。

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

         转发就是服务端的跳转A页面提交数据到B页面,B页面进行处理而后从服务端跳转到其它页面，跳转就是指客户端的跳转

请简述一下用Socket进行同步通信编程的详细步骤

一、在应用程序和远程设备中使用协议和网络地址初始化套接字

二、在应用程序中经过指定端口和地址创建监听

三、远程设备发出链接请求

四、应用程序接受链接产生通讯scoket

五、应用程序和远程设备开始通信（在通信中应用程序将挂起直到通信结束）

六、通信结束，关闭应用程序和远程设备的Socket回收资源

什么叫作SQL注入，如何防止？请举例说明。

         利用sql关键字对网站进行攻击。过滤关键字'等

         所谓SQL注入（SQL Injection），就是利用程序员对用户输入数据的合法性检测不严或不检测的特色，故意从客户端提交特殊的代码，从而收集程序及服务器的信息，从而获取想获得的资料。

请叙述属性与索引器的区别。

  属性                                                                     索引器   

  经过名称标识。                                       经过签名标识。   

  经过简单名称或成员访问来访问。     经过元素访问来访问。   

  能够为静态成员或实例成员。             必须为实例成员。   

  属性的get访问器没有参数。         索引器的get访问器具备与索引器相同的形参表

  属性的set访问器包含隐式value参数。除了value参数外，索引器的   set   访问器还具备与索引器相同的形参表。

String类与StringBuilder类有什么区别？为啥在.Net类库中要同时存在这2个类？

         若是要操做一个不断增加的字符串，尽可能不用String类,改用StringBuilder类。两个类的工做原理不一样:String类是一种传统的修改字符串的方式，它确实能够完成把一个字符串添加到另外一个字符串上的工做没错,可是在.NET框架下，这个操做实在是划不来。由于系统先是把两个字符串写入内存，接着删除原来的String对象，而后建立一个String对象，并读取内存中的数据赋给该对象。这一来二去的，耗了很多时间。而使用 System.Text命名空间下面的StringBuilder类就不是这样了，它提供的Append方法，可以在已有对象的原地进行字符串的修改，简单并且直接。固然，通常状况下觉察不到这两者效率的差别，但若是你要对某个字符串进行大量的添加操做，那么StringBuilder类所耗费的时间和 String类简直不是一个数量级的

选择题

一、您要建立ASP.NET应用程序用于运行AllWin公司内部的Web站点，这个应用程序包含了50个页面。您想要配置这个应用程序以便当发生一个 HTTP代码错误时它能够显示一个自定义的错误页面给用户。您想要花最小的代价完成这些目标，您应该怎么作？(多选)(  CD   )

　　A.在这个应用程序的Global.asax文件中建立一个Application_Error过程去处理ASP.NET代码错误。

　　B.在这个应用程序的Web.config文件中建立一个applicationError节去处理ASP.NET代码错误。

　　C.在这个应用程序的Global.asax文件中建立一个CustomErrors事件去处理HTTP错误。

　　D.在这个应用程序的Web.config文件中建立一个CustomErrors节去处理HTTP错误。

　　E.在这个应用程序的每一页中添加一个Page指示符去处理ASP.NET 代码错误。

F. 在这个应用程序的每一页中添加一个Page指示符去处理ASP.NET HTTP错误。

二、您的公司有一个DB Server，名为AllWin，其上装了MS SQLSERVER 2000。如今须要您写一个数据库链接字符串，用以链接AllWin上SQL SERVER中的一个名为PubBase实例的Test库。请问，应该选择下面哪个字符串？(  B  )

　　A. “Server=AllWin;Data Source=PubBase;Initial Catalog=Test;Integrated Security=SSPI”

　　B. “Server= AllWin;Data Source=PubBase;Database=Test;Integrated Security= SSPI”

　　C. “Data Source= AllWin \PubBase;Initial Category=PubBase;Integrated Security= SSPI”

　　D. “Data Source= AllWin \ PubBase;Database=Test;Integrated Security= SSPI”

3. 您要建立一个ASP.NET应用程序在DataGrid控件中显示一个通过排序的列表。产品数据被存放于一个名为PubBase的Microsoft SQL Server 数据库。每一个产品的主键是ProductID，Numeric型而且每一个产品有一个字母描述字段，名为ProductName。您使用一个 SqlDataAdapter对象和一个SqlCommand对象经过调用一个存储过程从数据库中获取产品数据。您将SqlCommand对象的 CommandType属性设置为CommandType.StoredProcedure，并将它的CommandText属性设置为 procProductList。您成功的获取了一个DataTable对象，其中是已经按ProductID降序排列的产品列表。您打算显示以相反的字母顺序排列的ProductName，请问该怎么作？ (  B  )

　　A. 将SqlCommand对象的CommandType属性修改成CommandType.Text，将CommandText属性修改成”SELECT * FROM procProductList ORDER BY ProductName DESC”。而后将这个DataTable对象绑定到DataGrid控件。

　　B. 建立一个基于这个DataTable对象的新的DataView并将这个DataView的Sort属性设置为“ProductName DESC”。而后将这个DataView对象绑定到DataGrid控件。

　　C. 将DataGrid控件的AllowSorting属性设置为True，并将DataGridColumn的SortExpression属性设置为 “ProductName DESC”.以显示ProductName。而后将这个DataTable对象绑定到DataGrid控件。

　　D. 将DataTable对象的DisplayExpression属性设置为 “ORDER BY ProductName DESC”.。而后将这个DataTable对象绑定到DataGrid控件。

四、您须要建立一个ASP.NET应用程序，公司考虑使用Windows身份认证。

　　全部的用户都存在于AllWin这个域中。您想要使用下列认证规则来配置这个应用程序：

　　　　a、 匿名用户不容许访问这个应用程序。

　　　　b、 全部雇员除了Tess和King都容许访问这个应用程序。

　　请问您应该使用如下哪个代码段来配置这个应用程序？(  A  )

A. <authorization>

　　　<deny users=”allwin\tess, allwin\king”>

　　　<allow users=”*”>

　　　<deny users=”?”>

　</authorization>

B. <authorization>

　　　<allow users=”*”>

　　　<deny users=”allwin\tess, allwin\king”>

　　　<deny users=”?”>

　</authorization>

C. <authorization>

　　　<deny users=”allwin\tess, allwin\king”>

　　　<deny users=”?”>

　　　<allow users=”*”>

　</authorization>

D. <authorization>

　　　<allow users=”allwin\tess, allwin\king”>

　　　<allow users=”*”>

　</authorization>

E.<authorization>

　　　<allow users=”*”>

　　　<deny users=”allwin\tess, allwin\king”>

　</authorization>

5.对于一个实现了IDisposable接口的类，如下哪些项能够执行与释放或重置非托管资源相关的应用程序定义的任务？(多选) (   ABC     )

A.Close                 B.DisposeC.Finalize

D.using                 E.Quit

6.Net依赖如下哪项技术实现跨语言互用性？(  C  )

A.CLR               B.CTS               C.CLS                  D.CTT

7.如下哪一个类是int的基类？(    )

A.Int32              B.Object          C.ValueType            D.Int16

8.如下哪些能够做为接口成员？   (多选) ( ABDE )

A.方法B.属性C.字段D.事件E.索引器

F.构造函数G.析构函数

9.如下关于ref和out的描述哪些项是正确的？(多选) (   ACD     )

A.使用ref参数，传递到ref参数的参数必须最早初始化。

B.使用out参数，传递到out参数的参数必须最早初始化。

C.使用ref参数，必须将参数做为ref参数显式传递到方法。

D.使用out参数，必须将参数做为out参数显式传递到方法。

10.“访问范围限定于此程序或那些由它所属的类派生的类型”是对如下哪一个成员可访问性含义的正确描述？(  B   )

A.public        B.protected            C.internal         D.protected internal

11.class Class1

{

    private static int count = 0;

    static Class1()

    {

        count++;

    }

    public Class1()

    {

        count++;

    }

}

Class1 o1 = new Class1();

Class1 o2 = new Class1();

请问，o1.Count的值是多少？(  C  )

A.1         B.2             C.3             D.4

12.

using System;

abstract class BaseClass

{

    public virtual string MethodA()

    {

        return "aaaa";

    }

    public virtual string MethodB()

    {

        return "bbbb";

    }

}

class Class1: BaseClass

{

    public string MethodA(string arg)

    {

        return "cccc";

    }

    public override string MethodB()

    {

        return "dddd";

    }

}

class Class2: Class1

{

    new public string MethodB()

    {

        return "eeee";

    }

}

class MainClass

{

    public static void Main(string[] args)

    {

        Class2 o = new Class2();

        Console.WriteLine(o.MethodA());

    }

}

结果：

aaaa

请按任意键继续. . .

请问，o.MethodA调用的是: (  A  )

A.BaseClass.MethodAB.Class2.MethodA

C.Class1.MethodAD.都不是

 

13.接口是一种引用类型，在接口中能够声明（A），但不能够声明公有的域或私有的成员变量。

a)方法、属性、索引器和事件； b)方法、属性信息、属性； c)索引器和字段；    d)事件和字段；

14.ASP.NET框架中，服务器控件是为配合Web表单工做而专门设计的。服务器控件有两种类型，它们是(A )

a)HTML控件和Web控件 b)HTML控件和XML控件 c)XML控件和Web控件    d)HTML控件和IIS控件

15.ASP.NET中，在Web窗体页上注册一个用户控件，指定该控件的名称为”Mike”，正确的注册指令为( D)

a)<%@Register TagPrefix = “Mike” TagName = “Space2” Src = “myX.ascx”%>

b)<%@Register TagPrefix = “Space2” TagName = “Mike” Src = “myX.ascx”%>

c)<%@Register TagPrefix = “SpaceX” TagName = “Space2” Src = “Mike”%>

d)以上皆非

16.在ADO.NET中，对于Command对象的ExecuteNonQuery()方法和ExecuteReader()方法，下面叙述错误的是（C）。

a)insert、update、delete等操做的Sql语句主要用ExecuteNonQuery()方法来执行；

b)ExecuteNonQuery()方法返回执行Sql语句所影响的行数。

c)Select操做的Sql语句只能由ExecuteReader()方法来执行；

d)ExecuteReader()方法返回一个DataReder对象；

17.下列ASP.NET语句（b）正确地建立了一个与SQL Server 2000数据库的链接。

a)SqlConnection con1 = new Connection(“Data Source = localhost; Integrated Security = SSPI; Initial Catalog = myDB”);

b)SqlConnection con1 = new SqlConnection(“Data Source = localhost; Integrated Security = SSPI; Initial Catalog = myDB”);

c)SqlConnection con1 = new SqlConnection(Data Source = localhost; Integrated Security = SSPI; Initial Catalog = myDB);

d)SqlConnection con1 = new OleDbConnection(“Data Source = localhost; Integrated Security = SSPI; Initial Catalog = myDB”);

18.Winform中，关于ToolBar控件的属性和事件的描述不正确的是(D)。

a)Buttons属性表示ToolBar控件的全部工具栏按钮

b)ButtonSize属性表示ToolBar控件上的工具栏按钮的大小，如高度和宽度

c)DropDownArrows属性代表工具栏按钮（该按钮有一列值须要如下拉方式显示）旁边是否显示下箭头键

d)ButtonClick事件在用户单击工具栏任何地方时都会触发

19.在ADO.NET中执行一个存储过程时，若是要设置输出参数则必须同时设置参数的方向和（B ），必要时还要设置参数尺寸。

a)大小；             b)上限；              c)初始值；            d)类型；

20.若是将窗体的FormBoderStyle设置为None，则( B)。

a)窗体没有边框并不能调整大小；        b)窗体没有边框但能调整大小；

c)窗体有边框但不能调整大小；          d)窗体是透明的；

21.若是要将窗体设置为透明的，则( B)

a)要将FormBoderStyle属性设置为None；      b)要将Opacity属性设置为小于100%得值；

c)要将locked 属性设置为True；              d)要将 Enabled属性设置为True；

22.下列关于C#中索引器理解正确的是(B/C )

a)索引器的参数必须是两个或两个以上   b)索引器的参数类型必须是整数型

c)索引器没有名字                     d)以上皆非

23.下面描述错误的是( C/D)。

a)窗体也是控件； b)窗体也是类； c)控件是从窗体继承来的； d)窗体的父类是控件类；

24.要对注册表进行操做则必须包含( D)。

a)System.ComponentModel命名空间； b)System.Collections命名空间；

c)System.Threading命名空间；      d)Microsoft.Win32命名空间；

25.要建立多文档应用程序，须要将窗体的(D )属性设为true。

a)DrawGrid；         b)ShowInTaskbar；          c)Enabled；            d)IsMdiContainer；

26.若是设treeView1=new TreeView()，则treeView1.Nodes.Add("根节点")返回的是一个 ()类型的值。

a)TreeNode；

b)int；

c)string；

d)TreeView；

27.下面关于XML的描述错误的是（D）。

a)XML提供一种描述结构化数据的方法；

b)XML 是一种简单、与平台无关并被普遍采用的标准；

c)XML文档可承载各类信息；

d)XML只是为了生成结构化文档；

28.装箱、拆箱操做发生在: (  C  )

A.类与对象之间   B.对象与对象之间

C.引用类型与值类型之间   D.引用类型与引用类型之间

29.用户类若想支持Foreach语句须要实现的接口是: (  A  )

A.IEnumerableB.IEnumerator

C.ICollectionD.ICollectData

30..Net Framework经过什么与COM组件进行交互操做？(   C )

A.Side By SideB.Web Service

C.InteropD.PInvoke

31..Net依靠如下哪一项技术解决COM存在的Dll Hell问题的？( A   )

A.Side By SideB.Interop

C.PInvokeD.COM+

32.装箱与拆箱操做是不是互逆的操做？(  B  )

A.是B.否

33.如下哪一个是能够变长的数组？(  D  )

A.Array                      B.string[]

C.string[N]                  D.ArrayList

34.用户自定义异常类须要从如下哪一个类继承：(  A  )

A.Exception                             B.CustomException

C.ApplicationException                  D.BaseException

35 如下叙述正确的是： B C

A. 接口中能够有虚方法。B. 一个类能够实现多个接口。 C. 接口不能被实例化。 D. 接口中能够包含已实现的方法。

36从数据库读取记录，你可能用到的方法有：B C D

      A. ExecuteNonQuery            B. ExecuteScalar      C. Fill                        D. ExecuteReader

37.对于一个实现了IDisposable接口的类，如下哪些项能够执行与释放或重置非托管资源相关的应用程序定义的任务？(多选)   (        ABC         ) 

  A.Close B.Dispose C.Finalize 

  D.using E.Quit 

38.如下关于ref和out的描述哪些项是正确的？(多选)   (    ACD   ) 

  A.使用ref参数，传递到ref参数的参数必须最早初始化。 

  B.使用out参数，传递到out参数的参数必须最早初始化。 

  C.使用ref参数，必须将参数做为ref参数显式传递到方法。 

  D.使用out参数，必须将参数做为out参数显式传递到方法。

39.在对SQL Server 数据库操做时应选用（A）。

a)SQL Server .NET Framework 数据提供程序；

b)OLE DB .NET Framework 数据提供程序；

c)ODBC .NET Framework 数据提供程序；

d)Oracle .NET Framework数据提供程序；

40.下列选项中，（C）是引用类型。

a)enum类型   b)struct类型 c)string类型   d)int类型

41.关于ASP.NET中的代码隐藏文件的描述正确的是（C）

a)Web窗体页的程序的逻辑由代码组成，这些代码的建立用于与窗体交互。编程逻辑惟一与用户界面不一样的文件中。该文件称做为“代码隐藏”文件，若是用C＃建立，该文件将具备“.ascx.cs”扩展名。

b)项目中全部Web窗体页的代码隐藏文件都被编译成.EXE文件。

c)项目中全部的Web窗体页的代码隐藏文件都被编译成项目动态连接库（.dll）文件。

d)以上都不正确。

42.如下描述错误的是（A）

a)在C++中支持抽象类而在C#中不支持抽象类。

b)C++中可在头文件中声明类的成员而在CPP文件中定义类的成员，在C#中没有头文件而且在同一处声明和定义类的成员。

c)在C#中可以使用 new 修饰符显式隐藏从基类继承的成员。

d)在C#中要在派生类中从新定义基类的虚函数必须在前面加Override。

43.C#的数据类型有（A）

a)值类型和调用类型； b)值类型和引用类型；c)引用类型和关系类型；d)关系类型和调用类型；

44.下列描述错误的是（D）

a)类不能够多重继承而接口能够；

b)抽象类自身能够定义成员而接口不能够；

c)抽象类和接口都不能被实例化；

d)一个类能够有多个基类和多个基接口；

45.在DOM中，装载一个XML文档的方法（D）

a)save方法   b)load方法 c)loadXML方法 d)send方法

46.下列关于构造函数的描述正确的是（C）

a)构造函数能够声明返回类型。

b)构造函数不能够用private修饰

c)构造函数必须与类名相同

d)构造函数不能带参数

47.如下是一些C#中的枚举型的定义，其中错误的用法有（）

a)public enum var1{ Mike = 100, Nike = 102, Jike }

b)public enum var1{ Mike = 100, Nike, Jike }

c)public enum var1{ Mike=-1 , Nike, Jike }

d)public enum var1{ Mike , Nike , Jike }

48.int[][] myArray3=new int[3][]{new int[3]{5,6,2},new int[5]{6,9,7,8,3},new int[2]{3,2}}; myArray3[2][2]的值是（D）。

a)9                   b)2             c)6              d)越界

 

代码书写和阅读

变量A、B如何不经过第三变量来交换（C#实现）？

using System;

class MainClass

{

    static void Main(string[] args)

    {

        int A = 5, B = 7;

        Console.WriteLine("交换前：A=" + A + "  B=" + B);

        A = A + B;

        B = A - B;

        A = A - B;

        Console.WriteLine("交换后：A=" + A + "  B=" + B);

        Console.ReadLine();

    }

}

结果：

交换前：A=5  B=7

交换后：A=7  B=5

请编程遍历页面上全部TextBox控件并给它赋值为string.Empty？

using System.Windows.Forms;

//部分代码略

    foreach (Control c in this.Controls)

    {

        if (c is TextBox)

        {

            TextBox tb = (TextBox)c;

            tb.Text = "aaa";

        }

    }

公司要求开发一个继承System.Windows.Forms.ListView类的组件，要求达到如下的特殊功能：点击ListView各列列头时，能按照点击列的每行值进行重排视图中的全部行 (排序的方式如DataGrid类似)。根据您的知识，请简要谈一下您的思路

根据点击的列头,包该列的ID取出,按照该ID排序后,在给绑定到ListView中。

给定如下XML文件，完成算法流程图。

<FileSystem>

    <DriverC>

    <Dir DirName="MSDOS622">

        <File FileName =" Command.com" ></File>

    </Dir>

    <File FileName ="MSDOS.SYS" ></File>

    <File FileName =" IO.SYS" ></File>

    </DriverC>

</FileSystem>

请画出遍历全部文件名（FileName）的流程图(请使用递归算法)。下面只是个算法思路，不是代码

void FindFile( Directory d )

{

   FileOrFolders = d.GetFileOrFolders();

   foreach( FileOrFolder fof in FileOrFolders ) 

   {

     if( fof is File ) 

              You Found a file;

     else if ( fof is Directory ) 

              FindFile( fof );

    }

}

根据线程安全的相关知识，分析如下代码，当调用test方法时i>10时是否会引发死锁?并简要说明理由。

    public void test(int i)

    {

        lock (this)

        {

            if (i > 10)

            {

                i--;

                test(i);

            }

        }

    }

         不会发生死锁，（但有一点int是按值传递的，因此每次改变的都只是一个副本，所以不会出现死锁。但若是把int换作一个object，那么死锁会发生）

根据委托(delegate)的知识，请完成如下用户控件中代码片断的填写：

namespace test

{

    public delegate void OnDBOperate();

    public class UserControlBase : System.Windows.Forms.UserControl

    {

        public event OnDBOperate OnNew;

        private void toolBar_ButtonClick(object sender, System.Windows.Forms.

                                                        ToolBarButtonClickEventArgs e)

        {

            if (e.Button.Equals(BtnNew))

            {

                //请在如下补齐代码用来调用OnDBOperate委托签名的OnNew事件。

            }

        }

    }

}

答：if( OnNew != null ) 

    OnNew( this, e );

分析如下代码，计算运行结果

string strTmp = "abcdefg某某某";

int i= System.Text.Encoding.Default.GetBytes(strTmp).Length;

int j= strTmp.Length;

以上代码执行完后i=13,j=10

分析如下代码，计算运行结果

using System;

class A

{

    public A()

    {

        PrintFields();

    }

    public virtual void PrintFields() { }

}

class B : A

{

    int x = 1;

    int y;

    public B()

    {

        y = -1;

    }

    public override void PrintFields()

    {

        Console.WriteLine("x={0},y={1}", x, y);

    }

}

当使用new B()建立B的实例时，产生什么输出？

         X=1,Y=0，new B()时，首先运行父类的构造方法，构造方法里运行PrintFields()方法，此方法被B类从新，按B类的方法来运行。

求如下表达式的值，写出您想到的一种或几种实现方法： 1-2+3-4+……+m

using System;

class MainClass

{

    static void Main(string[] args)

    {

        Console.WriteLine("请输入数字：");

        int Num = int.Parse(Console.ReadLine().ToString());

        int Sum = 0;

        for (int i = 0; i < Num + 1; i++)

        {

            if ((i % 2) == 1)

            {

                Sum += i;

            }

            else

            {

                Sum -= i;

            }

        }

        System.Console.WriteLine(Sum.ToString());

        System.Console.ReadLine();

    }

}

结果：

请输入数字：

5

3

产生一个int数组，长度为100，并向其中随机插入1-100，而且不能重复。

using System;

using System.Collections;

 

class MainClass

{

    static void Main(string[] args)

    {

        int[] intArr = new int[100];

        ArrayList myList = new ArrayList();

        Random rd = new Random();

        int x = 0;

        while (myList.Count < 100)

        {

            x++;

            int num = rd.Next(1, 101);

            if (!myList.Contains(num))

            {

                myList.Add(num);

            }

        }

        for (int i = 0; i < 100; i++)

        {

            intArr[i] = (int)myList[i];

            Console.Write(intArr[i] + " ");

        }

        Console.WriteLine();

    }

}

13 11 2 52 74 7 56 42 69 20 58 84 15 19 87 78 53 36 5 16 34 54 82 22 55 76 61 79

 23 8 98 71 44 45 41 26 100 83 86 65 10 1 60 30 81 46 50 43 17 48 62 91 64 35 72

 21 6 75 14 9 92 12 96 49 80 33 37 39 93 18 88 63 38 70 28 27 40 95 3 24 97 25 8

5 29 66 68 73 31 59 90 4 57 99 94 89 51 67 77 47 32

请按任意键继续. . .

程序设计: 猫大叫一声，全部的老鼠都开始逃跑，主人被惊醒。

       要求：1.要有联动性，老鼠和主人的行为是被动的。 2.考虑可扩展性，猫的叫声可能引发其余联动效应。

using System;

public sealed class Cat

{

    //猫叫时引起的事件

    public event EventHandler Calling;

 

    public void Call()

    {

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

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

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

    }

}

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

public sealed class Mouse

{

    public void Escape(object sender, EventArgs e)

    {

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

    }

}

 

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

public sealed class Master

{

    public void Wakened(object sender, EventArgs e)

    {

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

    }

}

//用于测试的执行方法

//程序入口点

public class Program

{

    public static void 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分)

using System;

using System.Collections;

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();

    }

}

Cat cryed!

mouse1 attempt to escape!

mouse2 attempt to escape!

Host waken!

请按任意键继续. . .

写出程序的输出结果

using System;

class Program

{

    private string str = "Class1.str";

    private int i = 0;

    static void StringConvert(string str)

    {

        str = "A string being converted.";

    }

    static void StringConvert(Program c)

    {

        c.str = "B 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";

        Program c = new Program();

        Add(i1);

        AddWithRef(ref i2);

        Add(c.i);

        StringConvert(str); //string没法被改变           

        StringConvert(c);   //传递对象string能够被改变

 

        Console.WriteLine(i1);

        Console.WriteLine(i2);

        Console.WriteLine(c.i);

        Console.WriteLine(str);

        Console.WriteLine(c.str);

    }

}

运行结果：

10

21

0

str

B string being converted.

请按任意键继续. . .

写出程序的输出结果

using System;

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();

    }

}

 

运行结果：

A

B

A.Fun()

请按任意键继续. . .

有继承关系，在构造子类的时候会先构造父类；Fun函数在子类是被new了一下，只是显示隐藏，并无重写，因此输出仍是A.Fun()。若是子类是被override，则最后输出B.Fun

写出程序的输出结果

using System;

public class A

{

    public virtual void Fun1(int i)

    {

        Console.WriteLine(i);

    }

    public void Fun2(A a)

    {

        a.Fun1(1);  //以传递进来的对象选择哪一个Fun1

        Fun1(5);    //以调用此方法的对象选择哪一个Fun1

    }

}

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);

    }

}

输出结果：

2

5

1

6

请按任意键继续. . .

冒泡排序

using System;

public class MainClass

{

    public static void ArraySort()

    {

        int[] Arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };

        int t = 0;

        //从小到大排序

        for (int i = 0; i < Arr.Length - 1; i++)            //总共须要N-1趟

        {

            for (int j = 0; j < Arr.Length - 1 - i; j++)    //每趟总共须要（N-1-趟数）次比较

            {

                if (Arr[j] > Arr[j + 1])

                {

                    t = Arr[j];

                    Arr[j] = Arr[j + 1];

                    Arr[j + 1] = t;

 

                }

            }

        }

        foreach (int i in Arr)

        {

            Console.Write(i + ",");

        }

    }

    public static void Main()

    {

        ArraySort();

    }

}

输出：1,2,3,4,5,6,7,8,9,请按任意键继续. . .

写出程序的输出结果

using System;

class A

{

    public static int X;

    static A()

    {

        X = B.Y + 1;

    }

}

class B

{

    public static int Y = A.X + 1;

    static B() { }

    static void Main()

    {

        Console.WriteLine("X={0},Y={1}", A.X, B.Y);

    }

}

输出结果：

X=1,Y=2

请按任意键继续. . .

在.net（C# or vb.net）中如何用户自定义消息，并在窗体中处理这些消息。

在form中重载DefWndProc函数来处理消息:

protected override void DefWndProc(ref System.WinForms.Message m)

{

    switch (m.msg)

    {

        case WM_Lbutton:

            ///string与MFC中的CString的Format函数的使用方法有所不一样

            string message = string.Format("收到消息!参数为:{0},{1}", m.wParam, m.lParam);

            MessageBox.Show(message);///显示一个消息框

            break;

        case USER:

        //处理的代码

        default:

            base.DefWndProc(ref m);///调用基类函数处理非自定义消息。

            break;

    }

}

请说明以下代码的结果

using System;

class Father

{

    public virtual void show()

    {

        Console.WriteLine("Father");

    }

    static void Main(string[] args)

    {

        Father obj = new Child();

        obj.show();

    }

}

class Child : Father

{

    public override void show()

    {

        Console.WriteLine("Child");

    }

}

输出：

Child

请按任意键继续. . .

若是把virtual和override去掉，输出结果为Father