1. 什么是类? 什么是结构体? 二者有什么区别? 相同点是什么? 你经常使用类还是结构体?为什么?
类：同一类对象共同属性和行为的抽象
结构体：同一类共同属性和行为的抽象
二者区别：类：引用类型 结构体：值类型
类和结构体的区别：
1、关键字不同；
2、结构体是值类型，在栈中存放；类是引用类型，在堆中存放。
3、结构体不能继承；类可以继承。更没有多态性。有封装性。结构体不具备面性对象的性质。
4、结构体中不能给字段赋值，即不能初始化。在构造函数、方法中可以赋值。类可以给字段赋值。
5、结构体中无论是否写构造函数，总是会给结构体添加一个默认无参的构造函数。
public 类名()//系统自动添加无参的构造函数
{
}
6、结构体的构造函数(自定义的)中给字段赋值时，要把所有的字段都赋值。
7、运行速度比类快。因为它在栈中存放。
8、结构体不用new，就可以创建。student st；student st=new student();
二者相同点：对共同属性和行为的抽象
经常使用类，一般在开发系统软件时，使用结构体。
2..怎样理解静态变量和静态方法？ 静态构造函数的作用是什么?
静态变量：属于类，不属于对象。所有的对象共用一个。
静态方法：不用创建类的实例，直接使用类的方法，方法变量在栈上。没有访问修饰符；没有形参；一个类中有且只有一个静态方法；用static来修饰。
静态构造函数的作用： 初始化类的静态数据成员，在代码加载时执行；
程序中无法调用静态构造函数，此前的任何修饰符都是无效的。
3.值类型与引用类型有什么区别？
值类型：数据存储在栈上，直接存储数据本身；
引用类型：数据存储在堆上，在栈上引用其内存地址，存储对值的引用。
二者区别：
l 所有内置对象，除了object和string 以外，都是值类型，所有用户定义类型，除了结构体都是引用类型。
l C#内置值类型(13种)
| 类型 | 大小（字节） | .net类型 | 说明 | |
| byte | 1 | Byte | 无符号（0-255） | 八 种 整 型 |
| sbyte | 1 | Sbyte | 有符号（-128～127） | |
| short | 2 | Int16 | 有符号（short） （-32768～32767） | |
| ushort | 2 | Unt16 | 无符号（short） (0～65535) | |
| Int | 4 | Int32 | -2147483648~ 2147483647 | |
| Uint | 4 | Uint32 | ||
| Long | 8 | Int64 | ||
| Ulong | 8 | Uint64 | ||
| Char | 2 | Char | Unicode 字符 | |
| float | 4 | Single | 三 种 浮 点 型 | |
| Double | 8 | Double | ||
| Decimal | 8 | Decimal | ||
| bool | 1 | Boolean | True or false |
l 除了基本类型，C#还有两种值类型：enum (枚举)和 struct（结构）；
l 引用类型：类、接口、数组、枚举。
l 编译器会默认带小数点的数位double类型，要赋值给一个float型变量，需要在数字后面加上f;
l 常见转义字符 ：
\’单引号 \”双引号 \\ 反斜杠 \0 空 \a 警铃 \b 回退 \f换页 \n 换行 \r 回车 \t 水平制表 \v 垂直制表
4.override 与重载有什么区别？
Override:重写：在继承关系中，父类是虚方法，子类中需要重写该虚方法。
Overload:重载： 同一个类中，函数名相同，参数列表不同，实现不同功能
5.你在什么情况下会用到虚方法？它与接口有什么不同？
子类要重写父类中的方法时，父类中方法应声明为虚方法；
接口：只有方法声明，没有方法体，可以有属性、索引器、方法和事件，有概念上的共同特征，要用接口实现。
虚方法：不但有方法声明，还要有方法体
6.什么是抽象方法? 什么是抽象类?
抽象方法：只有方法签名（方法头），没有方法体
抽象类： 类前加关键字abstract，则为抽象类，抽象类不能创建对象，只能作为其他类的基类。
一个类中，如果有抽象方法，则该类一定位抽象类；但是抽象类中不一定有抽象方法。
7. 怎样理解类、抽象类、和接口之间的异同？
抽象程度不同：
类：同一类对象属性和行为的抽象，以及重点考察方法的具体实现过程；
抽象类：二者中间：行为一样，实现不同；
接口：最高程度抽象，忽略对象，只考察行为概念，不考虑行为的具体实现。
8．.c#是一种纯粹面向对象的语言。面向对象语言具有什么特点？
抽象，封装 （结果是类），继承，多态
9．类和类之间有哪些关系？
继承，多态，聚合，组合，关联
10．@的作用是什么？
是转义字符失效，用在常量字符串前
表示常量字符串没有需要转义的字符
11．什么是序列化？ 为什么要序列化？（什么时候必须作序列化？）如何实现序列化？
序列化：把对象数据成员转化为字节流，只序列化数据成员，不序列化方法
为了把对象保存到存储介质或者在网络上传输。
默认的序列化方法：类的定义前加属性：Serializable，编译器会将序列化方法添加到类中
自定义序列化方法：接口：ISerilizable（GetOjbectData方法），还需要加上属性
序列化器：BinaryFormatter ，SoapFormatter
12．阐述C#中的访问修饰符。类和类的成员的访问修饰符分别有哪些？权限是什么？
类的Public：任何地方都可用，Internal：当前程序集中可用
类成员的
Public：任何地方都能使用。
Protected：本身和子类
Private：只能在当前类中才能访问。
13．什么是操作符重载？为什么要操作符重载？如何实现操作符重载？
操作符重载：在不改变操作符固有的含义情况下，重新定义操作符。
目的：扩大操作符的作用范围，必须公有、静态，放在一个类中
Public Static 返回类型 operator ——（参数列表），该操作符，作用在该类上
Class A
{
Public Static 返回类型 operator ——（A a， B。。）//必须出现一个
}
14．C#中有指针吗？
十三种基本数据类型有指针，其他数据类型没有指针，在非安全模式下用
15．c#中的委托是什么？事件是不是一种委托？委托的作用是什么？
委托：是一种特殊的类：不用Class而用Delegate定义，是一个方法的集合，即委托中存放的都是签名相同的方法。
事件是委托定义的一个变量，事件只能作为类的数据成员出现，不能在方法体中出现。
目的：封装一个方法的名称
作用：取代C++中的函数指针，把方法封装在委托对象中；定义委托对象，达到传递方法的目的。
16．什么是应用程序域？
将进程进一步划分为多个应用程序域，每个应用程序域运行一个应用程序。应用程序域之间相互隔离，互不影响。
17．怎样理解托管代码？
运行在.NET平台上的代码，运行在CLR（Commom Language Runtime）公共语言运行库上的代码，都是托管代码
18．怎样理解强类型系统？
强类型系统：声明变量时，就指定其存放的数据类型，如C#；JavaScript是弱类型系统。
19．解释装箱和拆箱；如何解决装箱、拆箱引发的性能问题？
装箱：值类型到Ojbect类型，或者该值类型所实现的任何接口类型之间的转换。
对值类型装箱，会在堆上分配一个实例对象，并将该值复制到新的对象中。
对于装箱和拆箱对性能影响的解决方法是程序中大量使用泛型进行代替。
在栈上 在堆上
Int i=123；
图示：
Object o=i；
拆箱与该操作相反。
装箱：在堆中开辟空间；把数据从栈中复制到堆中；把在堆中的引用存放到栈中。
拆箱：根据下标在内存中找到在堆中对应的位置；把数据从堆中复制到栈中。
20．const 和readonly 的区别是什么？ ref、out、和 params的作用和区别是什么？
const：定义常量，只能在定义时，初始化；
readonly：只读变量，可以在定义时初始化，也可以在构造函数里初始化
ref和out的作用都是把变量传递给方法，该方法对变量所做的任何改变都会影响到原始对象的值。但ref把参数传递给方法前必须初始化，out必须在方法结束前给变量赋值。
Params：修饰传递可变参数的数组，。
21．这些符号的含意是什么： &、 &&、 | 、||、 !、 ^、~。
&:按位与；
&&:逻辑与，操作数为逻辑表达式，；
短路现象：a1=T,a2=F,(a1=null计算A1&&a2汇报错) a1&&a2 ,a2&&a1, a1||a2,a2||a1, 1.结果一样2。效率不一样。
|:
||:逻辑或
!:逻辑非
~:按位取反
^:异或
22．CTS、CLS、CLR是什么？图示 VB.Net、 C#.net、 CTS、CLS、CLR 之间的关系？
CTS: Common Type System 公共类型系统
CLS：Common Language Specification公共语言规范
CLR: Common Language Runtime 公共语言运行库
从图中可以看出，某个编程语言的类型等特性只不过是CTS的一个子集。如果你直接使用IL编程，那么你可以用CTS的所有特性，如果你使用C#，那么你只能使用CTS里面针对C#那部分类型或准则。CTS描述了语言在.NET环境中的定义规则及其行为方式，一门语言要进入.NET环境运行，它就必须符合CTS规定。
23. c#中property 与attribute的区别，他们各有什么用处，这种机制的好处在哪里？
Property：类中的一种成员，如：方法，索引器，一般格式：public string Name{ get{return this._name;}set{this._name=value}
Attribute:（本身是一个类）一种解释说明，用来解释如何编译源代码，一般用[……]包含起来
用处：property:私有成员的读写；（与索引是同一类东西）避免私有成员的直接暴露。
Attribute：加入注解和说明
24．TCP、UDP的异同？
TCP(传输控制协议,Transmission Control Protocol)：面向连接的，可靠的，速度慢；
UDP(用户数据报协议,User Datagram Protocol)：非面向连接的，不可靠的，速度快。
25．怎样把 array 复制到 arraylist 中？
int[] arr = new int[] { 1,2,3,4,5};
ArrayList list = new ArrayList();
list.AddRange(arr); //或把这句话去掉，在上一句改为ArrayList list = new ArrayList(arr);
foreach (int o in list)
{
Console.WriteLine(o);
}
26．将数组a1中从第6个成员起10个数据成员拷贝到数组a2中
int[] arr = new int[] { 1,2,3,4,5,6};
int[] array=new int[3];
Array.Copy(arr, 3, array, 0, 3);
foreach (int o in array)
{
Console.WriteLine(o);
}
27．string和stringbuilder的区别，为什么要写这两个类？
String:定长的常量字符串。String s=“abc”;
Stringbuilder:可变字符串
S1=”hello”;
S2=”World”;
S1+=s2;
StringBuilder builder=new StringBUlder(s1);
Builder.Append(s2);
内部字符数组：默认为十六个字符
28．什么是程序集？强命名？GAC？
程序集：面向.NET Framework已经编译好的可独立发布最小逻辑单元。
强命名：strongName标识程序集，加强了的名字，名字+公钥（ID）+版本+文化；
GAC：全局程序集缓存 Global Assembly Cache,本质上是一个文件夹assembly
29．接口有几种实现模式？请解释接口的显式实现有什么意义？
实现模式：显示，隐式；实现方法时，前面加上接口的名字，即为显示实现模式，反之，为隐式实现模式。
意义： 一个类继承多个接口的时候，签名相同的方法需要实现时，必须使用显示实现模式，以区别于不同的接口。
30．请列出c＃中几种循环的方法，并指出他们的不同
For：带有索引的集合，用于循环次数确定的情况。
Foreach:遍历数组和集合。使用条件：只读的，不能对数组中的数进行修改。
While:while循环的测试条件在每一次循环开始时执行；
Do……while: Do……while的测试条件在每一次循环体结束时进行判断。
31．.通过超连接怎样传递中文参数？
HyperLink link=new HyperLink();
1.Link.NavgatorUrl=string.Format(“~/Default.aspx?Name={0}”, HttpContext.Current.Server.UrlEncode("中文名称"));
2.HttpUtility.UrlEncoding();
31.如何通过cookie保存中文参数？
在服务器上创建并向客户端输出cookie，可以利用response对象实现；
response对象支持一个名为cookie的集合，可以将cookie对象添加到该集合中，从而向客户端输出cookie；
通过request对象的cookies集合访问cookie。
32．请编程遍历页面上的所有textbox 控件并给它赋值为string.empty?
foreach (Control control in Form.Controls)
{
if (control is TextBox)
{
TextBox textbox = control as TextBox;
textbox.Text = string.Empty;
}
}
33．什么是form表单？
Form表单：客户端向服务段发送信息，Get：参数放在Url中，Post：参数放在body中。
<form method=”Get/Post” action=”Default.aspx”></form>:用get/post请求方法将该form表单中的数据提交到Default.aspx页面
34．什么是cookie? 什么是session?
Cookie:在服务器端生成，保存在客户端的键值（name=value）对，向服务器发送请求的时候，如需要，则回发到服务端，服务器端可以禁用Cookie。”
区别 ：
Session是存在服务器端的;而Cookie是存在客户端的；
Session可以不用Cookie来支持和不会受浏览器端的设置影响，可记录每个访问者的信息，独立在服务器端，比Cookie安全！
Session是存在内存中的，浏览器关闭它也就“死”了；Cookie是以文件方式存在的，可以修改其“存活”时间。
35．我们讲http协议是无状态的，其含义是什么？
含义：同一客户向服务器发送的前后的不同请求，是没有关系的。
36．讲一讲你对web service的理解？在dot net framework 中, Web Service 怎么很好的结合xml？
Web Service就是一种特殊的Web应用程序，没有界面，可被其他的应用程序通过http来调用。
Web 服务要封装在一个类中，web 方法要贴上[WebMethod]。
机制：在Server端为Web sevice生成WSDL（Web服务描述语言），
Client端要使用该web服务，首先要从服务端取得WSDL，生成本地Web service代理类，
Client端通过该代理类与Web服务器进行通讯。
遵循协议：http(hypertext transfer protocol:超文本标记语言);
SOAP：Simple Object Access Protocal（简单对象访问协议）。
它规定了一种封装格式，将传输的数据包装为XML文件，通讯双方按照该协议进行解析。
与XML结合：Client要取得Web服务器上的Web服务，首先，向代理类发出请求，该代理类将该请求
按照SOAP协议包装为XML文件，传输到Server端；
然后：在Server端，按照SOAP协议，对请求进行解析，并将处理后的数据，在按照SOAP协议包装为XML文件，传输到Client端。
37. 在HTML中，如何合并三行为一行？如何合并三列为一列？
rowspan=”3”;Colspan=”3”;
38．ASP.Net的身份验证方式有哪些？什么原理？
身份验证：
Windows：Windows身份验证与IIS身份验证结合，确保ASP.NET应用程序安全。
Forms：使用登陆窗体验证用户的用户名和密码，
未经过身份验证的用户被重定向到登陆页面，
用户在页面上提供凭据和提交窗体，Asp.net成员管理和登陆控件。
Passport：微软提供的集中身份验证服务。该服务为成员站点提供单一登陆和核心配置文件服务。
39．什么是WebPart? 什么是 Master Page? 你会使用吗？
WebPart：ASP.NET Web 部件功能集。
MasterPage：母版页
40．什么是 MIME类型？你知道哪些MIME类型？ 你用过吗？
MIME：Multipurpose Internet Mail Extension 多用途Internet邮件扩展，
MIME类型用于指定客户端Web浏览器和邮件应用程序处理二进制数据的方式 ，传输电子邮件，发送附件。
HTTP支持MIME；
MIME类型：text、image、application、message、audio、video
42．用.net做b\s结构的系统，你是用几层结构来开发，每一层的关系以及为什么要这样分层？
三层结构：
数据层(DAL)：数据库和存储过程，以及ADO.NET所写的数据库访问接口
（C#代码中最好不要出现SQL语句。触发器最好少用。触发器的BUG很难调试。游标也要少用）
业务逻辑层(BLL)：业务流程的表现层次，主要展示数据的处理和流向，核心，实现各种业务功能。
表示层(UI)：用页面展示业务层功能，并从中接受参数，传递给业务层aspx页面组成
好处：各层相互独立，互不影响。某一层如果有变动，其他层的代码或设置不需要更改。有利于团队的开发。
43．解释ADO.Net中的连接池。
连接池：为每个唯一的e连接字符串创建的e。当创建一个池后，将创建多个连接对象并将其添加到该池中，直至达到最大池大小。连接池可以显著提高应用程序的性能和可缩放性。
ADONET自动使用连接池，系统维护一定数目的e连接。
44．解释WSDL、UDDI及其作用；
Wsdl：Web Service Dscription Language;Web服务描述语言
在服务器提供Web Service时，客户端获得服务器端的WsDl；生成web服务代理类，与服务器端进行通讯
UDDI：Web服务的黄页。Universal Description，Discovery and Integration。通用描述、发现与集成服务。UDDI是一个独立于平台的框架，用于通过使用Internet来描述服务，发现企业并对企业服务进行集成。
45．DataGrid（或Gridview）中有一超链接列（TID），如何取出值（实现页面跳转）， 写出代码
for (int i = 0; i < this.GridView1.Rows.Count; i++)
{
Control ctl = this.GridView1.Rows[i].FindControl("HyperLink");
if (ctl is HyperLink)
{
HyperLink link = ctl as HyperLink;
link.NavigateUrl = link.NavigateUrl
}
}
46．写出DataGrid（或Gridview）中实现分页的方法。 如果要显示的数据量很大，你有什么办法加速服务器的响应速度？
<asp:GridView ID=”GridView” runat=”server” AutoPaging=”true”/>
数据量很大时，可以在数据库中分页，
create procedure ReadRecord
(
@StartIndex int,
@EndIndex int
)
as
declare @Count int
set @count=@EndIndex-@StartIndex+1
declare @UpCount int
set @UpCount=@StartIndex-1
declare @sql varchar(1000) //拼凑SQL字符串 ，条件要凑成SQL
set @sql='select top '+str(@Count)+' * from Orders where OrderID not in ( select top '+str(@UpCount)+' OrderID from Orders where OrderID > -1 )'
exec sp_executesql @sql//将查询语句作为字符串传递给存储过程，调用系统得存储过程，来执行拼接好的sql语句
///
数据库分页：
create procedure PageingInDataBase
(
@pageNo int,
@pageSize int
)
As //创建临时表，临时表的结构只设为两个字段，（一个子增长字段，一个所要查询表的ID主键），
//这样做表结构简单，插入的效率比较高
declare @tempTable table //声明临时表，将ID号插入该表
(
OrderID int ,
OrderNo int identity(0,1) //子增长字段
)
insert into @tempTable(OrderID) //将主表的ID插入临时表
(select OrderID from Orders)
declare @startIndex int //设置每页的起始索引
set @startIndex=@pageNo*@pageSize
declare @endIndex int //设置每页的结束索引
set @endIndex=(@pageNo+1)*@pageSize-1
select o.OrderID,o.CustomerID //内连接，选择出每页数据
from @tempTable t inner join Orders o on t.OrderID=o.OrderID
where t.OrderNo>=@startIndex and t.OrderNo<=@endIndex
--drop table @tempTable //临时表用完之后，自动消失
exec PageingInDataBase 0,10 //测试
47．定义一个用户定义控件（第三方控件），并添加一个属性和事件（事件属性）
48．说明数据库表建立索引的好处和缺点
索引：查询速度快，对增删改不利；
聚集索引（物理索引：）：磁盘上的记录
逻辑索引：本质是一张表
49．在页面中点击按钮，实现弹出窗口，提示“是否继续？”，写出代码
<script language=”JavaScript”>
Function Pop()
{confirm(“是否继续？”)；}
</script>
<input type=”submit” οnclick=”pop()”/>;
或：
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="Sum.WebForm1" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<script type="text/javascript">
window.onload = function () {
document.getElementById("btnAdd").onclick = function () {
confirm("确定要继续吗?");
}
};
</script>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="btnAdd" Text="是" runat="server" />
</div>
</form>
</body>
</html>
50．实现四舍五入小数点后两位
A=8.235;
Double.parse(String.Format(“{0:n2}”,a));
Double.parse(String.Format(“{0:0.00}”,a));
51．产生一个流水号，以ID开头后跟6为数字如ID000002不足六位以0补充
a=5;
string.Format(“ID”+”{0:d6}”,a);
52．解释aspx、aspx.cs文件、区别及工作原理；
Aspx：
Aspx
53．写一个Web Service的类并实现返回“Good Morning!”的字符串的方法，要求必须提供用户名和密码才能存取这个Web Service。
利用SOAP，将用户的验证信息写在 Header里面
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]// 若要允许使用 ASP.NET AJAX 从脚本中调用此Web服务，请取消对下行的注释。
// [System.Web.Script.Services.ScriptService]
public class Service : System.Web.Services.WebService
{
public Service () {
//如果使用设计的组件，请取消注释以下行。
//InitializeComponent();
}
[WebMethod]
public string GetString(string username, string password)
{
return "Good Morning";
}
}
54．向服务器发送请求常用的方式有什么？有什么区别?
Get：参数列表放在URl中，请求的所有参数以请求字符串的方式放在URL中；
Post：参数列表放在body体中 ，请求的所有参数放在Body体中。
(1)get通过url传值，post通过后台传值；
(2)get传递的数据量有限，post能够传递大量的数据；
(3)post会有浏览器提示重新提交表单的问题，get则没有；对于post的表单重新敲定地址再刷新就不会提示重新提交了，因为重新敲定地址就没有“偷偷”提交数据了。
55.DataReader 与 DataSet 有什么区别？
DataReader：时刻保持与数据库连接，只读，向前阅读器，一次读出一条记录
DataSet：非面向连接，将数据库中的表与数据复制到内存中，增删该查操作全部在内存中执行，然后同步更新到数据库中
56．ADO.Net的五大对象是什么？
Connection；Command；DataAdapter；DataSet；DadaReader；
57．简述什么是用户控件？ 什么是第三方控件？
用户控件：页面的一部分，.ascx文件，实现代码的重复使用；
第三方控件：非微软提供的控件。
58．在Web 应用程序里边，最常用的页面间传递参数的方式有哪些？
Cookie;session; QueryString;隐藏字段;ViewSate。
59．如果在一个b\s结构的系统中需要传递变量的值，但又不能使用session,cookie,application,你有几种方法进行处理？
QueryString查询字符串;;ViewState隐藏字段;Application（全局的Cache）
60．按先后顺序写出你所知道的web页面的几个事件
PreInit;Init;InitComplete;
PreLoad;Load;LoadComplete;
PreRender;PreRenderComplete;
SaveStateComplete;unload。
61．( C# )Asp.net如何调用win API函数？
DllImport；
[DllImport（“User32.Dll”）]
Public static extern int MessageBox(int h,string m,string c,int type)
62．dataview,dataset,datatable,sqldataadapter,connection之间的关系,用图例写出来.
Dataview:轻量级表, Dataview是datatable 快照
63．数据库里的事务处理.
事务：为完成一项功能，由一系列的SQL语句组成。把多个操作看成一个整体。
ACID：
原子性Atomicity：sql语句要么都执行，要么都不执行；
一致性Consistency：事务执行前后，数据都是完整的；
隔离性Isolation：事务执行时，数据对其他事务不可见；事务之间相互隔离，互不影响。
持久性Durability：事务执行后，数据能够持久的保存下来。
64．编程把阿拉伯数字代表的钱数转换成中文大写的钱数
65．请解释什么是上下文对象，在什么情况下要使用上下文对象。 找这个例题
它是asp.net页面处理周期中，用来保存相关数据的一个对象。访问session、cookie、cache等数据，都需要用到HttpContext。
66．请解释ASP.NET中button linkbutton imagebutton 及hyperlink这四个控件之间的功能
Button：在WEB窗体上创建下压按钮，分为两类：
Submit按钮：将页面发送回服务器，为Click事件提供事件处理程序，
Command按钮：通过设置CommandName属性，command按钮将命令名与按钮相关联。这样能够在页面上创建多个Command按钮，并通过Command事件的事件处理程序来确定被单击的e按钮。CommandArgument提供附加信息
LinkButton：可以在Web页面上创建超链接式的按钮。也可创建提交按钮和命令按钮
ImageButton：响应鼠标单击的图像。单击该控件，会同时引发OnClick和OnCommand两个事件。
HyperLink：创建一个链接，转移到其他页面，或其他位置，通过NavigateUrl来指定来指定链接的位置
67．WEB控件及HTML服务端控件能否调用客户端方法？如果能，请解释如何调用？
可以调用：例如：
<script language=”javasript”>function ClientFuntion(){alert(“您好！”);}</script>
WEB控件调用：<asp:Button runat=”server” ID=”Button1”OnClick=”ClientFuntion();”></asp:Button>
Html控件调用：<input type=”Submit” name=”submit” value=”提交” οnclick=”ClientFunction();”></>
68．WEB控件可以激活服务端事件，请谈谈服务端事件是怎么发生并解释其原理？自动传回是什么？为什么要使用自动传回？
Web控件事件发生时，客户端以提交的形式将表单中的数据提交到服务端，服务器端调用PreInit,Init,InitComplete,PreLoad,Load,LoadComplete,等事件，然后根据提交回的控件状态，来激发服务器端其他事件，PreRender,PreRenderComplete,SaveStateComplete,UnLoad。
自动回传：客户端控件被点击时，表单中的数据自动提交到服务端。
因为有视图状态(即ViewState)，所以初始化控件的属性后，并不像每次页面加载都初始化这个属性。视图状态在页面回传过程中保存了控件属性的状态，所以只在页面第一次加载时初始化控件属性一次。在这样的情况下，就需要用IsPostBack属性来检测页面是否已经回传给服务器端。事实上，如果每次页面加载都重新初始化控件的属性，很多控件将不能正确的工作。
69．请解释ASP.NET中的web页面与其隐藏类之间的关系？
一个ASP.NET页面对应一个隐藏类，该隐藏类在页面声明时进行指定。例如：Default.aspx页面的声明：
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
Language=“C#”：指定后台代码文件使用的语言：C#/编码语言；
AutoEventWireUp=“true”：自动执行系统的10个事件；
CodeFile=“Default.aspx.cs”:编译时使用的后台代码文件 或 后台代码在哪放着；
Inherits=“_Default”:该页面的对应的隐藏类 或继承那个基类，继承后台代码所定义的类。
70．请解释web.config文件中的重要节点
<appSettings>//应用程序的自定义设置
<authentication mode=”forms”> //验证策略：用于配置身份认证
<forms name=”cookieName(系统自动生成)”/>//
</authentication>
<location></Location>合法用户才能访问的文件或文件夹，有该节点指定
<authorization> //授权策略：用于配置授权
< deny users=”?/*”>
</authorization>:未登陆用户，*：所有用户
<sessionState mode=“Inproc”：IIS |stateService|SQLServer stateConnectionString>
</SessionState>//用于配置Session存放的状态
<system.web></System.web>:系统配置
71．什么是viewstate，能否禁用？是否所用控件都可以禁用?
视图状态：保存当前页面上各个控件的状态（数据）；
如果控件有EnableViewState属性，将其设置为false即可禁用
72．请解释一个WEB页面中代码执行次序。
PreInit;Init;InitComplete;PreLoad;Load;LoadComplete;事件处理器PreRender;PreRenderComplete;SaveStateComplete;unload;
73．请解释转发与跳转的区别？
转发：Response.Redirect()：客户端页面A提交数据到服务器端，服务器端处理后将数据返回到客户端，客户端根据该数据跳转到其他页面B
两个来回：web服务器 《=======================〉客户端《==============》yahoo
跳转：Server.Tranfer：客户端页面A提交数据到服务端，在服务端实现页面间的跳转；不能出当前网站，在服务器端实现页面的转换。 一个来回
Server.Execute();子页面处理完之后，返回到原始页面处理程序。 两个来回
脚本：Response.Write("<script>window.location.href='sec.aspx'</script>");
74．什么是WEB控件？使用WEB控件有那些优势？
(1)web控件是能拖放到web上的控件。 分为内部控件、列表控件和复杂控件。
(2)web控件的优势：
web控件是对象，与对象一样，web控件拥有方法、属性和相应的事件；
一旦将控件放在web页中，就可以设置其属性并调用其方法；
可以为web控件编写服务器端代码以响应在客户端上发生的事件；
大大减少代码编写量。
75．请简述一下用Socket进行同步通讯编程的详细步骤？
1、在server和Client中使用协议和网络地址初始化套接字
2、在server中通过指定端口和地址建立监听
3、client发出连接请求
4、server接受连接产生通信scoket
5、server和client开始通讯（在通讯中应用程序将挂起直到通讯结束）
6、通讯结束，关闭server and client的Socket回收资源
76．SQL SEVER中，向一个表中插入了新数据，如何快捷的得到自增量字段的当前值
@@identity;返回，多个表中插入记录中，返回最后一次插入的自增长字段。返回上一条SQL语句受影响的行数。
Ident_Current;局限于某一张表，返回刚刚插入表中的自增长的字段
Scope_Identity(比@@identity更好)：返回当前绘话的最后一张表的自增长字段
77．写出一条Sql语句： 取出表A中第31到第40记录（SQLServer, 以自动增长的ID作为主键, 注意：ID可能不是连续的。）
Select top 10 * from A where id not in//id索引查找
(Select top 30 id from A where id>-1)//物理存储顺序;可能出错
(Select top 30 id from A order by ID)//加上order by排序
扩展：取出n到n+m条记录
Create procedure ReadRec
(@start int,@end int)
As
Declare @n int
Set @n=@end-@start+1
Declare @m int
Set @m=@start-1
Declare @sql nvarchar(4000)
Set @sql=’select top’+str(@n)//拼凑SQL字符串 ，条件要凑成SQL
+’* from orders where orderid not in(select top’
+ str(@m)
+’orderid from orders where ordered > -1’
Exec sp_executesql @sql //将查询语句作为字符串传递给存储过程
exec ReadRecord 10,20
/
Select top @n //top后不能跟变量，需要常量
from orders
where ordered not in(select top @m orderID from orders order by orderID)
order by ordered
78．当发现不能读取页面上的输入的数据时很有可能是什么原因造成的？怎么解决 ?
很可能是在Page_Load中数据处理时，没有对page.IsPostBack属性进行判断
If(!IspostBack),客户第一次请求，为false，随后的请求，为true（数据存储视图状态中）；
79．产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
int[] arr=new int[100];
Random ran = new Random();
for (int i = 0; i < 100; i++)
{
int num = ran.Next(1, 101);
for (int j = 0; j <= i; j++)
{
if(arr[j]==0)
{
arr[j]=num;
break;
}
if (arr[j] == num)
{
i--;
break;
}
}
}
foreach(int c in arr)
{
Console.WriteLine(c);
}
79．怎样预防SOL注入
利用SQL关键字对网站进行攻击，过滤关键字。
Sql注入：如果服务端对输入的数据的合法性检测不严格或者不检查，客户端提交特殊代码，可以收集到程序或者服务器的信息，从而获取所需资料
例如：
http://localhost/lawjia/show.aspx?ID=444 or 1>0，这时，服务器运行Select * from 表名 where ID=444 or 1>0
如果表中ID=444这条记录，就会被查询到。
80．怎样在页面不刷新的情况下局部更新页面信息
Ajax：核心XMLHttpRequest
IE-------------------JS------------------IIS：Server
|-------------------XMLHTTPRequest--------------|XML
81．表的设计范式，描述第三范式，你常用第几范式？
第一范式：每一列都是不可再分的数据单元，称为最小的数据单元。即原子性；
第二范式：每个表只描述一件事情。除了主键以外的其它列，都依赖与该主键。
第三范式：除了主键以外的其它列都不传递依赖于主键列。
BNCF范式：在第三范式的基础上，消除主属性之间的部分函数依赖
关系数据库设计之时是要遵守一定的规则的。
第一范式（1NF）：在关系模式R中的每一个具体关系r中，如果每个属性值 都是不可再分的最小数据单位，则称R是第一范式的关系。例：如职工号，姓名，电话号码组成一个表（一个人可能有一个办公室电话 和一个家里电话号码） 规范成为1NF有三种方法：
一是重复存储职工号和姓名。这样，关键字只能是电话号码。
二是职工号为关键字，电话号码分为单位电话和住宅电话两个属性
三是职工号为关键字，但强制每条记录只能有一个电话号码。
以上三个方法，第一种方法最不可取，按实际情况选取后两种情况。
第二范式（2NF）：如果关系模式R（U，F）中的所有非主属性都完全依赖于任意一个候选关键字，则称关系R 是属于第二范式的。
例：选课关系 SCI（SNO，CNO，GRADE，CREDIT）其中SNO为学号， CNO为课程号，GRADEGE 为成绩，CREDIT 为学分。 由以上条件，关键字为组合关键字（SNO，CNO）
在应用中使用以上关系模式有以下问题：
a.数据冗余，假设同一门课由40个学生选修，学分就 重复40次。
b.更新异常，若调整了某课程的学分，相应的元组CREDIT值都要更新，有可能会出现同一门课学分不同。
c.插入异常，如计划开新课，由于没人选修，没有学号关键字，只能等有人选修才能把课程和学分存入。
d.删除异常，若学生已经结业，从当前数据库删除选修记录。某些门课程新生尚未选修，则此门课程及学分记录无法保存。
原因：非关键字属性CREDIT仅函数依赖于CNO，也就是CREDIT部分依赖组合关键字（SNO，CNO）而不是完全依赖。
解决方法：分成两个关系模式 SC1（SNO，CNO，GRADE），C2（CNO，CREDIT）。新关系包括两个关系模式，它们之间通过SC1中的外关键字CNO相联系，需要时再进行自然联接，恢复了原来的关系
第三范式（3NF）：如果关系模式R（U，F）中的所有非主属性对任何候选关键字都不存在传递信赖，则称关系R是属于第三范式的。
例：如S1（SNO，SNAME，DNO，DNAME，LOCATION） 各属性分别代表学号，
姓名，所在系，系名称，系地址。
关键字SNO决定各个属性。由于是单个关键字，没有部分依赖的问题，肯定是2NF。但这关系肯定有大量的冗余，有关学生所在的几个属性DNO，DNAME，LOCATION将重复存储，插入，删除和修改时也将产生类似以上例的情况。
原因：关系中存在传递依赖造成的。即SNO -> DNO。 而DNO -> SNO却不存在，DNO -> LOCATION, 因此关键辽 SNO 对 LOCATION 函数决定是通过传递依赖 SNO -> LOCATION 实现的。也就是说，SNO不直接决定非主属性LOCATION。
解决目地：每个关系模式中不能留有传递依赖。
解决方法：分为两个关系 S（SNO，SNAME，DNO），D（DNO，DNAME，LOCATION）
注意：关系S中不能没有外关键字DNO。否则两个关系之间失去联系。
BCNF：如果关系模式R（U，F）的所有属性（包括主属性和非主属性）都不传递依赖于R的任何候选关键字，那么称关系R是属于BCNF的。或是关系模式R，如果每个决定因素都包含关键字（而不是被关键字所包含），则RCNF的关系模式。
例：配件管理关系模式 WPE（WNO，PNO，ENO，QNT）分别表仓库号，配件号，职工号，数量。有以下条件
a.一个仓库有多个职工。
b.一个职工仅在一个仓库工作。
c.每个仓库里一种型号的配件由专人负责，但一个人可以管理几种配件。
d.同一种型号的配件可以分放在几个仓库中。
分析：由以上得 PNO 不能确定QNT，由组合属性（WNO，PNO）来决定，存在函数依赖（WNO，PNO） -> ENO。由于每个仓库里的一种配件由专人负责，而一个人可以管理几种配件，所以有组合属性（WNO，PNO）才能确定负责人，有（WNO，PNO）-> ENO。因为 一个职工仅在一个仓库工作，有ENO -> WNO。由于每个仓库里的一种配件由专人负责，而一个职工仅在一个仓库工作，有 （ENO，PNO）-> QNT。
找一下候选关键字，因为（WNO，PNO） -> QNT，（WNO，PNO）-> ENO ，因此 （WNO，PNO）可以决定整个元组，是一个候选关键字。根据ENO->WNO，（ENO，PNO）->QNT，故（ENO，PNO）也能决定整个元组，为另一个候选关键字。属性ENO，WNO，PNO 均为主属性，只有一个非主属性QNT。它对任何一个候选关键字都是完全函数依赖的，并且是直接依赖，所以该关系模式是3NF。
分析一下主属性。因为ENO->WNO，主属性ENO是WNO的决定因素，但是它本身不是关键字，只是组合关键字的一部分。这就造成主属性WNO对另外一个候选关键字（ENO，PNO）的部 分依赖，因为（ENO，PNO）-> ENO但反过来不成立，而P->WNO，故（ENO，PNO）-> WNO 也是传递依赖。
虽然没有非主属性对候选关键辽的传递依赖，但存在主属性对候选关键字的传递依赖，同样也会带来麻烦。如一个新职工分配到仓库工作，但暂时处于实习阶段，没有独立负责对某些配件的管理任务。由于缺少关键字的一部分PNO而无法插入到该关系中去。又如某个人改成不管配件了去负责安全，则在删除配件的同时该职工也会被删除。
解决办法：分成管理EP（ENO，PNO，QNT），关键字是（ENO，PNO）工作EW（ENO，WNO）其关键字是ENO
缺点：分解后函数依赖的保持性较差。如此例中，由于分解,函数依赖（WNO，PNO）-> ENO 丢失了, 因而对原来的语义有所破坏。没有体现出每个仓库里一种部件由专人负责。有可能出现 一部件由两个人或两个以上的人来同时管理。因此，分解之后的关系模式降低了部分完整性约束。
一个关系分解成多个关系，要使得分解有意义，起码的要求是分解后不丢失原来的信息。这些信息不仅包括数据本身，而且包括由函数依赖所表示的数据之间的相互制约。进行分解的目标是达到更高一级的规范化程度，但是分解的同时必须考虑两个问题：无损联接性和保持函数依赖。有时往往不可能做到既有无损联接性，又完全保持函数依赖。需要根据需要进行权衡。
1NF直到BCNF的四种范式之间有如下关系：
BCNF包含了3NF包含2NF包含1NF
小结：
原则：遵从概念单一化 "一事一地"原则，即一个关系模式描述一个实体或实体间的一种联系。规范的实质就是概念的单一化。
方法：将关系模式投影分解成两个或两个以上的关系模式。
要求：分解后的关系模式集合应当与原关系模式"等价"，即经过自然联接可以恢复原关系而不丢失信息，并保持属性间合理的联系。
注意：一个关系模式结这分解可以得到不同关系模式集合，也就是说分解方法不是唯一的。最小冗余的要求必须以分解后的数据库能够表达原来数据库所有信息为前提来实现。其根本目标是节省存储空间，避免数据不一致性，提高对关系的操作效率，同时满足应用需求。实际上，并不一定要求全部模式都达到BCNF不可。
82．说出配置SessionState的几种方式，及分别用于什么情况。
83．说出Global.asax文件的用途，最好说出其中每个方法的名称及作用。
Global.asax文件的用途：全局应用程序类
Application_Start():应用程序启动时，执行的代码
Application_End():应用程序关闭时，执行的代码
Application_Error():应用程序出现未处理错误时，执行的代码
Session_Start():新会话启动时，执行的代码
Session_End():会话结束时，执行的代码
84．说出我们常用的几种数据处理控件，及它们之间的异同。
数据验证控件：
Reapter：最简单的数据迭代控件，
DataList:将数据源的数据分栏显示
GridView: 将数据源数据列表显示
85．ViewState的作用，用多了会出现什么问题？
访问速度慢。
86．DataGrid（Gridview）如果数据量大的话，如何绑定。
在数据库端用存储过程实现分页
create procedure PageingInDataBase
(
@pageNo int,
@pageSize int
)
As //创建临时表，临时表的结构只设为两个字段，（一个子增长字段，一个所要查询表的ID主键），
//这样做表结构简单，插入的效率比较高
declare @tempTable table //声明临时表，将ID号插入该表
(
OrderID int ,
OrderNo int identity(0,1) //子增长字段
)
insert into @tempTable(OrderID) //将主表的ID插入临时表
(select OrderID from Orders)
declare @startIndex int //设置每页的起始索引
set @startIndex=@pageNo*@pageSize
declare @endIndex int //设置每页的结束索引
set @endIndex=(@pageNo+1)*@pageSize-1
select o.OrderID,o.CustomerID //内连接，选择出每页数据
from @tempTable t inner join Orders o on t.OrderID=o.OrderID
where t.OrderNo>=@startIndex and t.OrderNo<=@endIndex
--drop table @tempTable //临时表用完之后，自动消失
exec PageingInDataBase 0,10 //测试
87. 服务器端控件与客户端控件的区别
服务器控件：服务器端控件运行在服务器端，非服务器端控件运行在客户端，服务器端控件有属性 runat=“server”来制定
客户端控件：运行在客户端，
需要与服务器端进行交互时，用服务器控件，没有必要与服务器端交互时，用客户端控件
88．Ajax技术
基于XML的异步JavaScript，简称AJAX；Asynchronous JavaScript + XML的简写
Ajax不是一种技术。实际上，它由几种蓬勃发展的技术以新的强大方式组合而成。Ajax包含：
· 基于CSS标准的表示；
· 使用Document Object Model进行动态显示和交互；
· 使用XMLHttpRequest与服务器进行异步通信；
· 使用JavaScript绑定一切。
· Ajax应用程序的优势在于：
1. 通过异步模式，提升了用户体验
2. 优化了浏览器和服务器之间的传输，减少不必要的数据往返，减少了宽带占用
3. Ajax引擎在客户端运行，承担了一部分本来由服务器承担的工作，从而减少了大用户量下的服务器负载。
89．.软件开发过程一般有几个阶段？每个阶段的作用？
需求分析，概要设计，详细设计，代码编写，软件测试阶段，安装部署
90．请列举一些你用到的设计模式以及在什么情况下使用该模式？（单件模式、工厂模式、观察者模式、适配器模式） 编成实现它们。
单件模式：
class Singleton
{ private static Singleton _instance;
public static Singleton Instance()
{if (_instance == null)
{
_instance = new Singleton();
}
return _instance;
}
protected Singleton(){}
// Just to prove only a single instance exists
private int x = 0;
public void SetX(int newVal) {x = newVal;}
public int GetX(){return x;}
}
public class Client
{ public static int Main(string[] args)
{ int val;
// can't call new, because constructor is protected
Singleton FirstSingleton = Singleton.Instance();
Singleton SecondSingleton = Singleton.Instance();
// Now we have two variables, but both should refer to the same object
// Let's prove this, by setting a value using one variable, and
// (hopefully!) retrieving the same value using the second variable
FirstSingleton.SetX(4);
Console.WriteLine("Using first variable for singleton, set x to 4");
val = SecondSingleton.GetX();
Console.WriteLine("Using second variable for singleton, value retrieved = {0}", val);
return 0;
}
}
}
工厂模式：
基本思想：工厂基类，具体工厂；产品基类，具体产品；
Abstract class Basefactory{pulic void Produce();}
Class DeskTopFactory:BaseFactory{public void Produce(){}}
Class NoteBookFactory:BaseFactotry{puvlic void ProduceComputer(){}}
Abstract class BaseProduct{}
Class computer:BaseProduct{}
Class NoteBook:BaseProduct{}
观察者模式：
//定义一个接口，声明一个注册功能，该功能要在被观察者类中实现，
//观察者在被观者类中实现，以便通知消息
Interface ISubject{void Register(IOberser io);}
//定义接口，声明一个能够接受通知消息的功能，该功能要在观察者类中实现，
//观察者能够接受被观察者通知的消息，消息可以是任意一种消息，所以为Ojbect类型
Interface IObserver{void ReceiveNotify(object obj);}
//被观察者类，实现接口ISubject，实现注册功能
class Subject:ISubject
{
//观察者注册时，将每个观察者保存在ArrayList中（出版社记录将每个分销商记录在案，以便通知）
ArrayList list=new ArrayList();
//观察者注册，添加到list中
void Register(IObserver io)
{ list.Add(io); }
//被观察者向每个观察者通知消息
void Notify(object obj)
{
foreach(IObserver io in list)
{
io.ReceiveNotify(obj);
}
}
}
//被观察者类(可以有多种观察者)，继承接口IObserver,实现接收通知的e功能
class Observer-A:IObserver
{
void ReceiveNotify(objecty obj)
{..................}
}
class Observer-B:IObserver
{
void ReceiveNotify(object obj)
{..................}
}
class Observer-c:IObserver
{
void ReceiveNotify(object obj)
{..................}
}
//测试类
class Test
{
Main()
{
//被观察者实例对象
Subject sub=new Subject();
//观察者实例对象（多种多个）
Observer-A a1=new Observer-A();
Observer-A a2=new Observer-A();
Observer-B b1=new Observer-A();
Observer-B b2=new Observer-A();
Observer-c c1=new Observer-A();
Observer-c c2=new Observer-A();
//观察者在被观察者中注册
sub.Register(a1);
sub.Register(a2);
sub.Register(b1);
sub.Register(b2);
sub.Register(c1);
sub.Register(c2);
//被观察者向观察者通知消息
sub.Notify(obj);
}
}
适配器模式：
class FrameworkXTarget
{
virtual public void SomeRequest(int x)
{
// normal implementation of SomeRequest goes here
}
}
class FrameworkYAdaptee
{
public void QuiteADifferentRequest(string str)
{
Console.WriteLine("QuiteADifferentRequest = {0}", str);
}
}
class OurAdapter : FrameworkXTarget
{
private FrameworkYAdaptee adaptee = new FrameworkYAdaptee();
override public void SomeRequest(int a)
{
string b;
b = a.ToString();
adaptee.QuiteADifferentRequest(b);
}
}
/// <summary>
/// Summary description for Client.
/// </summary>
public class Client
{
void GenericClientCode(FrameworkXTarget x)
{
// We assume this function contains client-side code that only
// knows about FrameworkXTarget.
x.SomeRequest(4);
// other calls to FrameworkX go here
// ...
}
public static int Main(string[] args)
{
Client c = new Client();
FrameworkXTarget x = new OurAdapter();
c.GenericClientCode(x);
return 0;
}
}
}
Class Tax{ public f(double){} }
Interface payTax{double GetTex();}
Class MyTax:Tax,payTax
{pub setTex(double t){return base.f(t)}}
MVC：
M：Model：数据源
V：View ：数据的表示；
C：Contorller：控制数据源，过滤关键字，在View上显示
91．请编程实现一个冒泡排序算法、快速排序法，递归。
冒泡排序：
int[] arr = new int[] {9,8,7,6,5,4,3,2,1,0 };
int temp;
for (int i = 0; i< arr.Length; i++)
{
for (int j = 0; j < arr.Length-i-1; j++)
{
if (arr[j] > arr[j+1])
{
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
快速排序：
private static void QSort(int[] arr,int start ,int end)
{
//第一趟快排///
int i = start;
int j = end;
int privot=arr[i];//记录枢轴数值
while(i<j)
{
while (i < j && privot <= arr[j])//
{
j--;
}
arr[i] = arr[j];
while (i < j && privot >= arr[i])
{
i++;
}
arr[j] = arr[i];
}
arr[i] = privot;
/
if (i > start)
{
QSort(arr,start,i-1);//递归查找
}
if(i<end)
{
QSort(arr,i+1,end);//递归查找
}
}
二分查找：log2
Public bool Search(int[] a,int M)
{
return Search(a,0,a.Length-1,M);
}
Private Search(int[] a,int start,int end, int M)
{
If(start>end ) return false;
If(start==end)
{
If(a[start]==M) return true;
Else reutn false;
}
Int mid=(start+end)/2;
If(a[mid]==M) return true;
Else if(a[mid]<M)
{
Return Search(a,start,mid-1,M)
}
Else
{
Return Search(a,mid+1,M)
}
}
无序数组中找最大值：设置临时变量，逐次比较：
//
无序数组中找出次大执：
92．what are xml,xpath, xmldom? what is the relation among them？
XML：
Sysetm.Xml命名空间中有许多有用的工具，下面将简要的讨论该命名空间以及这些类之间的相互关系。
System.Xml主要有三个大类：XmlNode、XmlReader、XmlWriter。其它的大多数类均由这三个类之一派生而来的。
XmlNode是大多数类的基类。其为XML单一节点的表现形式。可以是几个节点类型中的一个，如entity、text、attribute，或其它有效节点类型。XmlDocument是架构中的DOM实现，其由XmlNode派生而来。
mlReader和XmlWriter均为System.Xml命名空间的抽象类，分别为读取和写XML数据的基类。使用其可以实现快速向前的XML文档文法分析和XML文档编辑，注意每种方法中的XML都是不可修改的。XMLWriter只有一个派生类：XmlTextWriter。
XPath:
XMLDom:
93. ASP.NET的Application, session, cookie, viewstate, cache等变量的区别是什么？
Application:
Session:
Cookie:
ViewState:
Cache:
94. what protocol does web service based on?
SOAP:Simple Object Access protocol:简单对象访问协议
http:
95. 简述C#中的异常处理机制。
Try……………Catch………finally
96．反转字符串.
String str=”abcde”;
StringBuilder builder=new StringBuilder();
For(int i=str.Length-1;i<0;i--)
{
Builder.append(str[i]);
}
Str.
String.Reverse();
97．什么是链表？实现一个单向链表； 并反转一个单向链表。
98．邮政编码的正则表达式是什么？你用哪些类作字符串查找？ [0-9]{6} regexp
中华人民共和国邮政编码：\d{6}；
法国邮政编码：\d{5}；
德国邮政编码：(D-)?\d{5}；
日本邮政编码：\d{3}(-(\d{4}|\d{2}))?；
美国邮政编码：\d{5}(-\d{4})?；
99．给字符串加密
字符串=====〉字节数组；对字节数组加密
加密：
对称加密：DES
非对称加密：RSA
100．
产品表 销售计划表
ProductID 产品名 单价 ProductID 客户名 订货数量 销售单价
1 name1 110 2 m 2 250
2 name2 220 1 n 3 110
3 name3 330 3 n 1 300
4 name4 440
a.是否能删除产品表中的name2？请说明理由与过程。
能。步骤：
打开“销售计划表”的设计--à右击选择”关系”-àinsert和update规范-à删除规则(选择里面的"级联")
b.将销售计划表中m客户的产品名为name2的销售单价更换为产品表中相应的单价
Update 销售计划表 set 销售单价=（select 单价 from 产品表 where ProductID=2）
全部更新为产品表中的单价：
Update 销售计划表 set 销售计划表.销售单价=产品表.单价 from 销售计划表，产品表 where 产品表.ProductID=销售计划表.prodcutID
c.求销售计划表中各客户各自的销售总金额的sql语句
select 客户名，sum（订货数量*销售单价）
from 销售计划表
Group by 客户名
d.求客户中销售总量最大的销售总金额的客户的sql语句
select top 1 客户名，sum（订货数量*销售单价）Total
from 销售计划表
Group by 客户名
Order by Total desc
101． 人机界面设计要遵循三个主要的的人机交互原则：一致性原则、有效的信息反馈、简洁明了的界面布局。
一致性：
有效的信息反馈：
简洁明了：重点突出：
102．开闭原则也是面向对象技术的关键原则之一，Open-Closed Principle原则讲的是：一个软件实体应当对扩展开放，对修改关闭。
通过扩展已有软件系统，可以提供新的行为，以满足对软件的新的需求，使变化中的软件有一定的适应性和灵活性。
已有软件模块，特别是最重要的抽象层模块不能再修改，这使变化中的软件系统有一定的稳定性和延续性。
那如何做到对现有接口的扩展而不是修改呢，关键是抽象；如果在发布的接口要做出修改，那么说明不符合开闭原则，说起来是乎有点芧盾：“这个东西不符合现有的功能，那不能修改，现在的写法又不好扩展，怎么办”，这说明你的设计不合理，得进行重构，使其是可扩展的；好像还是有茅盾，“我怎么知道这个地方对以后是要可扩展的呢，如果每个都考虑到扩展性的话那么一个小小的软件开发起来也是一件相当庞大的事情”，这个就是开闭原则茅盾之处，这就得靠实际的工作经验了，关键是一个度（边界）的问题；不预测将来，做好现有的迫切的，所以不存在100%的开闭;
103． 写出输出结果：
（1）
class Class1 {
private string str = "Class1.str";
private int i = 0;
static void StringConvert(string str) {
str = "string being converted.";
}
static void StringConvert(Class1 c) {
c.str = "string being converted.";
}
static void Add(int i) {
i++;
}
static void AddWithRef(ref int i) {
i++;
}
static void Main() {
int i1 = 10;
int i2 = 20;
string str = "str";
Class1 c = new Class1();
Add(i1);
AddWithRef(ref i2);
Add(c.i);
StringConvert(str);
StringConvert(c);
Console.WriteLine(i1);//10
Console.WriteLine(i2);//21
Console.WriteLine(c.i);//0
Console.WriteLine(str);//str
Console.WriteLine(c.str);//string being converted!
}
}
（2）。
public abstract class A
{
public A()
{
Console.WriteLine('A');
}
public virtual void Fun()
{
Console.WriteLine("A.Fun()");
}
}
public class B: A
{
public B()
{
Console.WriteLine('B');
}
public new void Fun()
{
Console.WriteLine("B.Fun()");
}
public static void Main()
{
A a = new B();
a.Fun();//A.Fun();
}
}
（3）。
public class A
{
public virtual void Fun1(int i)
{
Console.WriteLine(i);
}
public void Fun2(A a)
{
a.Fun1(1);
Fun1(5);//确定该函数是哪个对象的
}
}
public class B : A
{
public override void Fun1(int i)
{
base.Fun1 (i + 1);
}
public static void Main()
{
B b = new B();
A a = new A();
a.Fun2(b);//2,5
b.Fun2(a);//1,6
}
}
104． 一列数的规则如下: 1、1、2、3、5、8、13、21、34......
求第30位数是多少， 用递归算法实现。(C#语言)
public void fibnation(int i)
{
If(i==0){ return 1;}
If(i==1){ return 1;}
Return fination(i-1)+fibnation(i-2)
}
105. 程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。(C#语言)
要求： 1.要有联动性，老鼠和主人的行为是被动的。
要点：1. 联动效果，运行代码只要执行Cat.Cryed()方法。2. 对老鼠和主人进行抽象
评分标准: <1>.构造出Cat、Mouse、Master三个类，并能使程序运行(2分)
<2>从Mouse和Master中提取抽象（5分）
<3>联动效应，只要执行Cat.Cryed()就可以使老鼠逃跑，主人惊醒。(3分)
public interface Observer
{
void Response(); //观察者的响应，如是老鼠见到猫的反映,
}
public interface Subject
{
void AimAt(Observer obs); //针对哪些观察者，这里指猫的要扑捉的对象---老鼠
}
public class Mouse : Observer
{
private string name;
public Mouse(string name, Subject subj)
{
this.name = name;
subj.AimAt(this);
}
public void Response()
{
Console.WriteLine(name + " attempt to escape!");
}
}
public class Master : Observer
{
public Master(Subject subj)
{
subj.AimAt(this);
}
public void Response()
{
Console.WriteLine("Host waken!");
}
}
public class Cat : Subject
{
private ArrayList observers;
public Cat()
{
this.observers = new ArrayList();
}
public void AimAt(Observer obs)
{
this.observers.Add(obs);
}
public void Cry()
{
Console.WriteLine("Cat cryed!");
foreach (Observer obs in this.observers)
{
obs.Response();
}
}
}
class MainClass
{
static void Main(string[] args)
{
Cat cat = new Cat();
Mouse mouse1 = new Mouse("mouse1", cat);
Mouse mouse2 = new Mouse("mouse2", cat);
Master master = new Master(cat);
cat.Cry();
}
}
设计方法二: 使用event -- delegate设计..
public delegate void SubEventHandler();
public abstract class Subject
{
public event SubEventHandler SubEvent;
protected void FireAway()
{
if (this.SubEvent != null)
this.SubEvent();
}
}
public class Cat : Subject
{
public void Cry()
{
Console.WriteLine("cat cryed.");
this.FireAway();
}
}
public abstract class Observer
{
public Observer(Subject sub)
{
sub.SubEvent += new SubEventHandler(Response);
}
public abstract void Response();
}
public class Mouse : Observer
{
private string name;
public Mouse(string name, Subject sub) : base(sub)
{
this.name = name;
}
public override void Response()
{
Console.WriteLine(name + " attempt to escape!");
}
}
public class Master : Observer
{
public Master(Subject sub) : base(sub){}
public override void Response()
{
Console.WriteLine("host waken");
}
}
class Class1
{
static void Main(string[] args)
{
Cat cat = new Cat();
Mouse mouse1 = new Mouse("mouse1", cat);
Mouse mouse2 = new Mouse("mouse2", cat);
Master master = new Master(cat);
cat.Cry();
}
}
排序：快速排序，折半查找
两个正整数的最大公约数和最小公倍数。
最大公约数：
Class MyMath
{
Public int GetmaxDiv(int a,int b)
{
If(a>=b)
Return getMaxDiv(a,b);
Else
Return getMaxDiv(b,a);
}
Private Int getMaxDiv（int a,int b）
{
If(b==0) return a;
If(a==b) return a;
Return getMaxDiv(b,a%b);
}
}
最小公倍数：
正整数转化为二进制后，计算有多少个1
Int Get_1_Count(int n)
{
If(n<=0) return 0;
Int sum=0;
While（n>0）
{
Sum+=n%2;
n=n/2;
}
Return sum;
}
冒泡，快速
讲一讲你理解的web service,在dot net framework中，怎么很好的结合xml?（讲概念就行了）
3. 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关键字用在将在事件发生的时候被当成代理调用的方法声明中.
常问问题：
Cache:
数据缓存：Cache.Add();
页面缓存：局部页面缓存：outputCache
XML:
106．
class A
{
public static int X=3;
static A()
{
X = B.Y + 1;
}
}
class B
{
public static int Y = A.X + 1;
static B()
{
Y = 1;
}
public static void Main()
{
Console.WriteLine("{0},...{1}",A.X,B.Y);
Console.Read();
}
}
107．求两个数的最大公约数和最小公倍数。
108．You're given an array containing both positive and negative integers and required to find the sub-array with the largest sum . Write a routine in C# for the above.
109． Give a very good method to count the number of ones in a "n" (e.g. 32) bit number.
110. Reverse a linked list.
111. Write a program to remove duplicates from a sorted array.
112.有一个栈,push(1),push(2),pop(),pop(),栈顶元素是（d）
a.1 b.2 c.0 d.不确定
113.下列语句的作用是什么？
string *str;
str="hello world";
(将hello world地址赋给str，即给str初始化)
114.给定一个int[100] a,找出次大数.
115.有一个名单表，其中包含name等字段，写sql语句,找出有重复的name,和其重复的次数
Select name, count(*) from T group by name having count(*) > 1
116. 有两个表，学生表和成绩表，写sql，找出所有成绩都大于80的学生
Select * from student where sid in (select sid from marks where grade>80)
Select * from student inner join mark on student.sid=mark.sid where grade>80
117. 有一个单向有序连表，写出一个向其中插入一个新结点的方法
118. 自定义一个队列，并实现入队和出队的方法
public class Queue//先进先出
{
public System.Collections.ArrayList list = new System.Collections.ArrayList();
public void Add(Node node)
{
list.Add(node);
}
public void Remove()
{
list.RemoveAt(0);
}
}
public class Stack
{
public System.Collections.ArrayList list = new System.Collections.ArrayList();
public void Push(Node node)
{
list.Add(node);
}
public void Pop()
{
list.Remove(list.Count-1);
}
}
119. 写出一个方法，实现字符串的逆转，如输入abc,输出cba
120. 有两个单向连表，写出方法判断两个连表是否有交叉部分，如果有，返回结点位置
133． public class A
{
public A()
{
show();
}
public virtual void show()
{
Console.WriteLine("A");
}
}
public class B : A
{
int x = 1;
int y;
public B()
{
y = -1;
}
public override void show()
{
Console.WriteLine("x={0}, y={1}",x,y);
}
public static void Main()
{
B b = new B();
}
}
输出结果是什么？？
134． Student（id int identity ， name varchar(100), age int） PK: id
找出 id=10 的那条记录前面的记录的 name.
Select top 9 name from Student
namespace 单向连表
{
class Node
{
public int n;
public Node next;
public Node(int a)
{
n = a;
}
}
class SortedLinkedList
{
public Node Root;
public void GenLL(Node node)
{
if (Root == null)
{
Root = node;
return;
}
if (node.n < Root.n)
{
node.next = Root;
Root = node;
return;
}
Node tmp = Root;
Node t = Root;
while (tmp != null)
{
if (tmp.n < node.n)
{
t = tmp;
tmp = tmp.next;
}
else
.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000…………………..0.
………………………….. {
t.next = node;
node.next = tmp;
break;
}
}
if (tmp == null)
t.next = node;
}
}
class Search
{
public int SearchCross(Node a, Node b)
{
int pos = 1;
Node tmp;
if(a==null||b==null)
return 0;
while (a != null)
{
tmp = b;
while (tmp != null)
{
if (a.n == tmp.n)
return pos;
tmp = tmp.next;
}
a = a.next;
pos++;
}
return 0;
}
}
class Queue
{
System.Collections.ArrayList al = new System.Collections.ArrayList();
//int[] a = new int[100];
public void Push(int o)
{
al.Add(o);
}
public int Pop()
{
if (al.Count > 0)
{
int c = int.Parse(al[0].ToString());
al.RemoveAt(0);
return c;
}
return -1;
}
}
public class Client
{
public static void Main()
{
Node a1 = new Node(1);
Node a2 = new Node(2);
Node a3 = new Node(3);
Node a4 = new Node(4);
Node a5 = new Node(5);
Node a6 = new Node(6);
Node a7 = new Node(7);
Node a;
Node b;
// a = a1;
//a1.next = a3;
//a3.next = a5;
//a5.next = a6;
//a6.next = a7;
//a7.next = a2;
//a2.next = a4;
//b = a6;
//Search s = new Search();
//int c=s.SearchCross(a, b);
// Console.WriteLine(c);
SortedLinkedList ll = new SortedLinkedList();
ll.GenLL(a6);
ll.GenLL(a2);
ll.GenLL(a7);
ll.GenLL(a1);
ll.GenLL(a3);
ll.GenLL(a4);
ll.GenLL(a5);
Node n=ll.Root;
while (n!= null)
{
Console.WriteLine(n.n);
n = n.next;
}
}
}
}
135.垃圾回收机制
136. SQL中游标的定义?
SQL中的游标类似于指针,它用于指向的某一行即为选定或执行到的当前行.使用游标有四种基本的步骤:声明游标、打开游标、提取数据、关闭游标。
137. 如何在定义游标的时候使用动态sql语句？
答案:
使用代码来描述
declare @qa nvarchar(200)
declare @i int
declare @sql nvarchar(255)
set @i = 1
while @i <= 5
begin
set @sql = 'declare cur cursor for
select q' + convert(nvarchar(2), @i) + ' from ImportSurveyInfo'
set @i = @i + 1
exec(@sql)
open cur
fetch cur into @qa
select @qa
close cur
deallocate cur
end
138. Ado.net常用对象有哪些？
数据提供程序和dataset。
扫一扫
1733
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
