.net面试题

  登录

首页 专栏 专家 热文



心亦❤ .


[转]2011年.NET面试题总结（很经典的）

2012-7-21阅读1821 评论0




基础知识

什么是面向对象

        面向对象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、不能直接实例化接口。

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

3、接口可以多继承，类只能单继承。

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

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

相同点：

1、接口、类和结构都可以从多个接口继承。

2、接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。

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

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

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

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

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

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

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

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

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

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

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

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

        5、新增方法的影响：在抽象类中，新增一个方法的话，继承类中可以不用作任何处理；而对于接口来说，则需要修改继承类，提供新定义的方法。

        6、接口可以作用于值类型（枚举可以实现接口）和引用类型；抽象类只能作用于引用类型。

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

        8、接口可以用于支持回调（CallBack）；抽象类不能实现回调，因为继承不支持。

如下给出两者的简单对比表格。




接口

抽象类


多继承

支持

不支持


类型限制

没有

有，只能是引用类型


方法实现

继承类型中必须给出方法实现

继承类中可以不给出


扩展性

比较麻烦

相对比较灵活


多层继承

比较麻烦，需要借助虚函数

比较灵活


如何选择：

1、看是否需要多继承，如果需要就只能使用接口

2、看你在累里定义的方法是否需要有实现的代码，如果要，就使用抽象类

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

结构和类的区别

简单的说成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)的区别

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

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

        覆写：在类的继承中使用，通过覆写子类方法可以改变父类虚方法的实现。

区别：

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

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

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

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

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

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

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

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

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

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

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

3、null：与引用类型不同，值类型不可能包含 null 值。然而，可空类型功能允许将 null赋给值类型。

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

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

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

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

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

例：

"a=null"的意思是：a的引用置为空但此时StringBuilder的堆空间并没有被释放，因此在此之后，输出b时，仍然可以输出mxh


using System;

using System.Text;

classEventDel

{

     staticvoid Main(string[] args)

    {

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

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

       b.Append("mxh");

       Console.WriteLine(a);

       a=null;

       Console.WriteLine(b);

    }

}

输出结果：

mxh

mxh

请按任意键继续. . .



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

简单的说：委托是一种方法容器，里面可以装载若干个具有相同签名的方法引用地址，那么调用委托，就相当于同时调用了该容器内的所有方法。

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



例：

例：


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

    staticvoid Main(string[] args)

    {

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

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

    }

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

委托允许将方法作为参数进行传递。

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

委托可以链接在一起；创建多个对象，使用“+=”累加到同一个委托对象上的引用上，例如，可以对一个事件调用多个方法。


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

staticvoid 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;

className

{

     privatestring pName;

     //定义委托类型

    publicdelegate void myEventHandler(object sender,NameEventArgs e);

     //定义Get事件

    publicevent myEventHandler Get;

     internalstring Text

    {

       get {return this.pName; }

       set{

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

           this.pName=value;

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

       }

    }

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

    {

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

    }

    publicoverride string ToString()

    {

       return"Name类的对象";

    }

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

    {

       string pArgs;

       public NameEventArgs(string s)

       {

           pArgs = s;

       }

       publicoverridestring ToString()

       {return pArgs; }

    }

}

classEventDel

{

     staticvoid Main(string[] args)

    {

       Name myname =new Name();

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

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

    }

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

    staticvoid 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类的对象

你输入的名字是：张三

请按任意键继续. . .

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


classEventDel

{

      staticvoid Main(string[] args)

    {

        Name myname=newName();

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

        {

        };

    }

}

也可以用Lambda表达式把delegate隐藏


classEventDel

{

      staticvoid Main(string[] args)

    {

        Name myname=newName();

        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中常用的几种页面间传递参数的方法，并说出他们的优缺点。

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

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

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

2、session(viewstate)

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

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

3、cookie

优点：简单，

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

4、this.Server.Transfer,

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

缺点：资源消耗大

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

6、static member。

7、cache

8、application

优点：全局

缺点：资源消耗大

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

10、xml or other  Files

11、XMLHTTP or Hidden iFrame/frame

12、Context.user.identity

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

  (1)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;

publicclassProgram

{

     publicstatic 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 postget一般为链接方式，post一般为按钮方式。主要区别如下：

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

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

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

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

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

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

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

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

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

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

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

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

存：继承

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

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

const static int classNum=0;

classNum++;

A类是B类的基类，并且都有自己的构造，析构函数，请举例证明B类从实例化到消亡过程中构造，析构函数的执行过程。

构造先父后子，析够反之

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

string inputStr=" xx xx ";

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

new有几种用法

1、new运算符，创建对象，调用构造函数

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

3、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编译成可执行代码.

进程和线程的区别

1、单位：进程是系统进行资源分配和调度的单位；线程是CPU调度和分派的单位。

2、一个进程可以有多个线程，这些线程共享这个进程的资源。

        进程是比线程大的程序运行单元，都是由操作系统所体会的系统运行单元，一个程序中至少要有一个进程，有一个进程中，至少要有一个线程，线程的划分尺度要比进程要小。

3、进程拥有独立的内存单元，线程是共享内存，从而极大的提高了程序的运行效率同一个进程中的多个线程可以并发执行。

4、边界：二者都定义了某种边界，进程是应用程序与应用程序之间的边界，不同的进程之间不能共享代码和数据空间，而线程是代码执行堆栈和执行上下文的边界。

成员变量和成员函数前加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里

例1、foreach( object o in array )

arrayList.Add(o);

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

例3、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，二进制传送提高效率。

1、Remoting可以灵活的定义其所基于的协议，如果定义为HTTP，则与Web Service就没有什么区别了，一般都喜欢定义为TCP，这样比Web Service稍为高效一些。

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

3、Remoting一般需要通过一个WinForm或是Windows服务进行启动，而Web Service则需要IIS进行启动。

4、在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的一种特例。

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

2、一般来说，Remoting是和平台相关的不跨平台的，需要客户和服务器都是.NET，但可配置特性比较好，可以自定义协议。WebService可以做到跨平台通信，但必须采用SOAP协议。

3、 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拆箱！！

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

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

页生命周期阶段

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

2、开始：设置页属性，如：HttpContext以及其他属性；在此阶段，页面需要确定是回发请求还是新请求，并设置IsPostBack属性；设置页面的UICulture属性。

3、页面初始化：加载所有主题；控件生成，并设置UniqueID；

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

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

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

6、回发事件处理：如果请求是回发请求，则调用所有事件处理程序。

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

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

页生命周期事件：

1、PreInit

完成操作：检查IsPostBack属性来确定是不是第一次处理该页；

   创建或重新创建动态控件

   动态设置主控页

   动态设置Theme属性

   读取或设置配置文件属性

注：如果请求是回发请求，则控件的值尚未从视图状态恢复，即：不应该在此事件中设置控件属性。

2、Init

完成操作：在所有控件都已经初始化并且应用所有外观设置后引发。使用该事件来读取和初始化控件属性。

3、InitComplete

完成操作：由Page对象引发，使用该事件来处理要求完成所有初始化工作的任务。

4、PreLoad

完成操作：为页和所有控件加载视图状态，然后处理Request实例包括的任何回发数据。
注：如果需要在Load之前对页或控件进行处理，需要该事件。

5、Load

完成操作：以递归方式加载所有控件。

6、控件事件

完成操作：处理控件引发的事件。

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

7、LoadComplete

8、PreRender

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

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

Page对所有控件递归进行EnsureChildControl操作

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

9、SaveStateComplete

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

10、Render

方法，便于开发

11、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;

classMyArray

{

     privatestring[] str =newstring[5];

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

    publicstring this[int i]

    {

       get

       {

           return str[i];

       }

       set

       {

           str[i] =value;

       }

    }

     //获得数组长度

    publicint Length

    {

       get

       {

           return str.Length;

       }

    }

}

publicclassLxIndex

{

     staticvoid Main(string[] args)

    {

       MyArray ma =newMyArray();

       //给数组赋值

       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

{

     classClassHello

    {

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

       [DllImport("User32.dll")]

       publicstaticextern int MessageBox(int Handle,string Message,string Caption,int Type);

       staticvoid 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区别

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

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

2、修饰对象不同。const即可以修饰类的字段，也可以修饰局部变量；readonly只能修饰类的字段

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

4、const默认是静态的；而readonly如果设置成静态需要显示声明

5、修饰引用类型时不同，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调用基类的成员

不同点：

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

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

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

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

例


using System;

publicclassBaseClass

{

     public BaseClass()

    {

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

    }

     //使用virtual才可以在子类中使用override，而new不必要

    publicvirtual void Method()

    {

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

    }

}

publicclassClassA :BaseClass

{

     public ClassA()

    {

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

    }

    publicoverride void Method()

    {

       //base.Method();

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

    }

}

publicclassClassB :BaseClass

{

     public ClassB()

    {

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

    }

    publicnew void Method()

    {

       //base.Method();

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

    }

}





classProgram

{

     staticvoid Main(string[] args)

    {

       BaseClass ba1 = (BaseClass)newClassA();//类型转换

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

       //所以这里通过基类的虚函数，会访问到派生类的方法。

       ba1.Method();

      &nfont-size:9.5ptbsp;Console.WriteLine(" =================");



       BaseClass bb2 = (BaseClass)newClassB();//类型转换

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

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

       bb2.Method();

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



       ClassA a1 =newClassA();

       a1.Method();

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



       ClassB b2 =newClassB();

       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>

   <allowusers="*">

   <denyusers="allwin\tess, allwin\king">

   <denyusers="?">

</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;

classProgram

{

   staticvoid 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;

classProgram

{

   enumColor :byte

   {

       Red, Green, Blue, Orange

   }



   staticvoid Main(string[] args)

   {



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

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

       foreach (string sin sa)

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

       Console.WriteLine();



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

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

       foreach (byte sin 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.

分析以下代码。


    publicstatic 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）。区别如下：

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

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

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

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;

classDisposePattern :IDisposable

{

     private System.IO.FileStream fs =new System.IO.FileStream("test.txt", System.IO.FileMode.Create);



     //析构函数

    ~DisposePattern()

    {

       Dispose(false);

    }

     //IDisposable Members

   #region IDisposable Members

     publicvoid Dispose()

    {

       //告诉GC不需要再调用Finalize方法，

       //因为资源已经被显示清理

       GC.SuppressFinalize(this);

       Dispose(true);

    }

   #endregion

     protectedvirtualvoid 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的实现为：


classDerivedClass : DisposePattern

{

     protectedoverridevoid 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#


classMyClass :IDisposable

{

     //构造函数

    public MyClass() {

   

    }



     //析构方法 (不确定的) (编译器通过重载virtual void Finalize来实现)，与C++/CLI的!MyClass()等效

    ~MyClass() {

   

    }



     // Dispose方法

    publicvoid Dispose() { } 

     publicstatic void Test()

    {

       using (MyClass auto =newMyClass())

       {

      

       }

       //因为使用了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的使用


    publicvoid 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;

publicclassName

{

     publicstring FirstName;

     publicstring LastName;

}

publicclassPerson :ICloneable

{

     publicName PersonName;

     publicstring Email;

     //// <summary>

     /// Deep Copy的例子

     ///</summary>

     ///<returns></returns>

     publicObject Clone()

    {

       Person p =newPerson();

       p.Email =this.Email;

       p.PersonName =new Name();

       p.PersonName.FirstName =this.PersonName.FirstName;

       p.PersonName.LastName =this.PersonName.LastName;

       return p;

    }



     publicvoid ChangLastName(string lastName)

    {

       this.PersonName.LastName = lastName;

    }



     publicstatic void Main()

    {

       Person p =newPerson();

       p.PersonName =new Name();

       p.PersonName.LastName ="jill";

       p.PersonName.FirstName ="zhang";

       p.Email ="[e-mail]";

       Person sameNamePerson = p.Clone()as Person;

       sameNamePerson.ChangLastName("clr_");

       Console.WriteLine(p.PersonName.LastName);

       Console.WriteLine(sameNamePerson.PersonName.LastName);





       Person samePerson = p.MemberwiseClone()asPerson;

       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)]

publicclassParameterAtt :Attribute

{

   publicint Min = 100;

}



publicclassAttributeTest

{

   publicvoid TestMethod([ParameterAtt(Min = 100)]int par1)

   {

       ParameterInfo para = MethodInfo.GetCurrentMethod().GetParameters()[0];

       ParameterAtt att =ParameterAtt.GetCustomAttribute(para, typeof(ParameterAtt))asParameterAtt;

       if (att.Min > par1)

       {

           thrownew 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进行同步通讯编程的详细步骤

1、在应用程序和远程设备中使用协议和网络地址初始化套接字

2、在应用程序中通过指定端口和地址建立监听

3、远程设备发出连接请求

4、应用程序接受连接产生通信scoket

5、应用程序和远程设备开始通讯（在通讯中应用程序将挂起直到通讯结束）

6、通讯结束，关闭应用程序和远程设备的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类简直不是一个数量级的

选择题

1、您要创建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错误。

2、您的公司有一个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控件。

4、您需要创建一个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;

abstractclassBaseClass

{

     publicvirtual string MethodA()

    {

       return"aaaa";

    }

     publicvirtual string MethodB()

    {

       return"bbbb";

    }

}

classClass1:BaseClass

{

     publicstring MethodA(string arg)

    {

       return"cccc";

    }

     publicoverride string MethodB()

    {

       return"dddd";

    }

}

classClass2:Class1

{

     newpublic string MethodB()

    {

       return"eeee";

    }

}

classMainClass

{

     publicstatic void Main(string[] args)

    {

       Class2 o =newClass2();

       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;

classMainClass

{

   staticvoid 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 cinthis.Controls)

    {

       if (cis TextBox)

       {

           TextBox tb = (TextBox)c;

           tb.Text ="aaa";

       }

    }

公司要求开发一个继承System.Windows.Forms.ListView类的组件，要求达到以下的特殊功能：点击ListView各列列头时，能按照点击列的每行值进行重排视图中的所有行 (排序的方式如DataGrid相似)。根据您的知识，请简要谈一下您的思路

根据点击的列头,包该列的ID取出,按照该ID排序后,在给绑定到ListView中。

给定以下XML文件，完成算法流程图。


<FileSystem>

   <DriverC>

   <DirDirName="MSDOS622">

       <FileFileName =" Command.com" ></File>

   </Dir>

   <FileFileName ="MSDOS.SYS" ></File>

   <FileFileName =" 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时是否会引起死锁?并简要说明理由。


    publicvoid test(int i)

    {

       lock (this)

       {

           if (i > 10)

           {

               i--;

               test(i);

           }

       }

    }

        不会发生死锁，（但有一点int是按值传递的，所以每次改变的都只是一个副本，因此不会出现死锁。但如果把int换做一个object，那么死锁会发生）

根据委托(delegate)的知识，请完成以下用户控件中代码片段的填写：


namespace test

{

     publicdelegate void OnDBOperate();

     publicclass UserControlBase : System.Windows.Forms.UserControl

    {

       publiceventOnDBOperate OnNew;

       privatevoid 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;

classA

{

     public A()

    {

       PrintFields();

    }

     publicvirtual void PrintFields() { }

}

classB :A

{

     int x = 1;

     int y;

     public B()

    {

       y = -1;

    }

     publicoverride 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;

classMainClass

{

   staticvoid 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;



classMainClass

{

   staticvoid Main(string[] args)

   {

       int[] intArr =newint[100];

       ArrayList myList =new ArrayList();

       Random rd =newRandom();

       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;

publicsealedclass Cat

{

     //猫叫时引发的事件

    publicevent EventHandler Calling;



     publicvoid Call()

    {

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

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

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

    }

}

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

publicsealedclass Mouse

{

     publicvoid Escape(object sender,EventArgs e)

    {

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

    }

}



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

publicsealedclass Master

{

     publicvoid Wakened(object sender,EventArgs e)

    {

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

    }

}

//用于测试的执行方法

//程序入口点

publicclassProgram

{

     publicstatic void Main(string[] args)

    {

       //建立猫

       Cat cat =newCat();

       //建立老鼠

       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;

publicinterfaceObserver

{

     //观察者的响应，如是老鼠见到猫的反映

    void Response();

}

publicinterfaceSubject

{

     //针对哪些观察者，这里指猫的要扑捉的对象---老鼠

    void AimAt(Observer obs);

}

publicclassMouse : Observer

{

     privatestring name;

     public Mouse(string name,Subject subj)

    {

       this.name = name;

       subj.AimAt(this);

    }



     publicvoid Response()

    {

       Console.WriteLine(name +" attempt to escape!");

    }

}

publicclassMaster :Observer

{

     public Master(Subject subj)

    {

       subj.AimAt(this);

    }



     publicvoid Response()

    {

       Console.WriteLine("Host waken!");

    }

}



publicclassCat : Subject

{

     privateArrayList observers;

     public Cat()

    {

       this.observers =new ArrayList();

    }

     publicvoid AimAt(Observer obs)

    {

       this.observers.Add(obs);

    }

     publicvoid Cry()

    {

       Console.WriteLine("Cat cryed!");

       foreach (Observer obsinthis.observers)

       {

           obs.Response();

       }

    }

}

classMainClass

{

     staticvoid Main(string[] args)

    {

       Cat cat =newCat();

       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;

classProgram

{

     privatestring str ="Class1.str";

     privateint i = 0;

     staticvoid StringConvert(string str)

    {

       str ="A string being converted.";

    }

     staticvoid StringConvert(Program c)

    {

       c.str ="B string being converted.";

    }

     staticvoid Add(int i)

    {

       i++;

    }

     staticvoid AddWithRef(refint i)

    {

       i++;

    }

     staticvoid Main()

    {

       int i1 = 10;

       int i2 = 20;

       string str ="str";

       Program c =newProgram();

       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;

publicabstractclass A

{

     public A()

    {

       Console.WriteLine('A');

    }

     publicvirtual void Fun()

    {

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

    }

}

publicclassB : A

{

     public B()

    {

       Console.WriteLine('B');

    }

     publicnew void Fun()

    {

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

    }

     publicstatic void Main()

    {

       A a =newB();

       a.Fun();

    }

}



运行结果：

A

B

A.Fun()

请按任意键继续. . .

有继承关系，在构造子类的时候会先构造父类；Fun函数在子类是被new了一下，只是显示隐藏，并没有重写，所以输出还是A.Fun()。如果子类是被override，则最后输出B.Fun

写出程序的输出结果


using System;

publicclassA

{

     publicvirtual void Fun1(int i)

    {

       Console.WriteLine(i);

    }

     publicvoid Fun2(A a)

    {

       a.Fun1(1); //以传递进来的对象选择哪个Fun1

       Fun1(5);   //以调用此方法的对象选择哪个Fun1

    }

}

publicclassB : A

{

     publicoverride void Fun1(int i)

    {

       base.Fun1(i + 1);

    }

     publicstatic void Main()

    {

       B b =newB();

       A a =newA();

       a.Fun2(b);

       b.Fun2(a);

    }

}

输出结果：

2

5

1

6

请按任意键继续. . .

冒泡排序


using System;

publicclassMainClass

{

   publicstaticvoid 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 iin Arr)

       {

           Console.Write(i +",");

       }

   }

   publicstaticvoid Main()

   {

       ArraySort();

   }

}

输出：1,2,3,4,5,6,7,8,9,请按任意键继续. . .

写出程序的输出结果


using System;

classA

{

     publicstatic int X;

     static A()

    {

       X =B.Y + 1;

    }

}

classB

{

     publicstatic int Y = A.X + 1;

     static B() { }

     staticvoid Main()

    {

       Console.WriteLine("X={0},Y={1}",A.X,B.Y);

    }

}

输出结果：

X=1,Y=2

请按任意键继续. . .

在.net（C# or vb.net）中如何用户自定义消息，并在窗体中处理这些消息。

在form中重载DefWndProc函数来处理消息:


protectedoverridevoid 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;

classFather

{

     publicvirtual void show()

    {

       Console.WriteLine("Father");

    }

     staticvoid Main(string[] args)

    {

       Father obj =newChild();

       obj.show();

    }

}

classChild :Father

{

     publicoverride void show()

    {

       Console.WriteLine("Child");

    }

}

输出：

Child

请按任意键继续. . .

如果把virtual和override去掉，输出结果为Father







本文转自：http://www.cnblogs.com/dielianhua/articles/ASPNET_1.html

上一篇下一篇.

请先登录后，再发表评论！

查看评论 更多评论（0）  
回顶部


移动版|桌面版

©1999-2012, CSDN.NET, All Rights Reserved