【转】2011年.NET面试题总结（很经典的） - _蝶恋花 - 博客园
继承：子类拥有父类的所有数据和操作。
封装：用抽象的数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型内。
多态：一个程序中同名的不同方法共存的情况。有两种形式的多态&重载与重写。
抽象类可以继承实体类，但是有个条件，条件是，实体类必须要有明确的构造函数。
&&&& .net是一种平台和框架, .net 不是单纯的语言也不是单纯的工具,它是从底层平台开始构建起来的一个整体框架
Common Language Specification
Data and XML
Base Class Library
Visual Studio .NET
&&& 由于ASP。NET是Web页面和服务端分离的，因此要产生了服务端事件.
&&& 在web控件发生事件时，客户端采用提交的形式将数据交回服务端，服务端先调用Page_Load事件,然后根据传回的状态信息自动调用服务端事件自动传回是当我们在点击客户端控件时，采用提交表单的形式将数据直接传回到务端。只有通过自动传回才能实现服务端事件的机制，如果没有自动回传机制就只能调用客户端事件，而不能调用服务端事件
&&& Aps.net 中有非空验证，比较验证，取值范围验证，正则表达式验证及客户自定义验证五大控件，另还有一个集中验证信息处理控件
用户控件是能够在其中放置标记和 Web 服务器控件的容器。然后，可以将用户控件作为一个单元对待，为其定义属性和方法。
用户控件以扩展名可以拖到不同的页面中调用以节省代码比如登陆可能在多个页面上有就可以做成用户控件但是有一个问题就是用户控件拖到不同级别的目录下后里面的等的相对路径会变得不准确需要自已写方法调整
问这样的问题一般是迷惑你因为新手还是分不清楚用户控件和服务器控件也称自定义控件用户控件一般用在内容多为静态或者少许会改变的情况下，用的比较大，类似中的但是功能要强大的多
是不给他分配内存空间而给它分配长度为空字符串的内存空
静态变量属于类，而不属于对象；并对所有对象所享；静态成员在加类的时候就被加载。
&&& 静态变量使用 static 修饰符进行声明，静态成员在加类的时候就被加载（在类被实例化时创建，哪个对），通过类进行访问
&&& 不带有static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问
&&& 一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值
&&& 静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等
DataReader和DataSet最大的区别在于，DataReader使用时始终占用SqlConnection，在线操作数据库，任何对SqlConnection的操作都会引发DataReader的异常，因为DataReader每次只在内存中加载一条数据，所以占用的内存是很小的，因为DataReader的特殊性和高性能。所以DataReader是只进的，你读了第一条后就不能再去读取第一条了。
DataSet则是将数据一次性加载在内存中。抛弃数据库连接，读取完毕即放弃数据库连接，因为DataSet将数据全部加载在内存中。所以比较消耗内存，但是确比DataReader要灵活，可以动态的添加行，列，数据。对数据库进行回传更新操作。
只包含方法或属性的声明，
5、表达的含义不同，接口主要定义一种规范，统一调用方法，也就是规范类，约束类，类是方法功能的实现和集合
2接口用于规范，抽象类用于共性。
简单的说成class可以被实例化,属于引用类型struct属于值类型,
1）、类型，空间分配。结构是值类型，是分配在内存的栈上的.类时引用类型，,是分配在内存的堆上的。结构实例化可以不用new，即使用new操作也不会在堆里分配内存。作参数是按值传递，类时引用传递，变量用完
2）、基类。
4)、结构没有类的特性，不支持继承。但可以实现接口。
5）、结构无法声明无参的构造函数，但可以声明有参的构造函数
6）、结构的实例成员不能直接赋初值，必须通过构造函数来赋值，但静态成员可以直接赋初值
（1） 接口定义一个类型需要实现的方法，属性，索引和事件，包括可能的参数类型和返回值类型，而把具体的实现交由相应的类或结构来做，从而为组件提供多态能力。
（2） 继承常用于在一个现有父类的基础上的功能扩展，往往是我们将几个类中相同的成员提取出来放在父类中实现，然后在各自的子类中加以继承。
（3） 接口可以实现多接口继承，而继承只能实现单继承。
（4） 实现继承可继承父类型的实现，由于接口中没有定义方法的实现，因此必须实现继承后该接口的所有方法。
（5） 为父类型添加方法可能不影响使用继承自该类型实现的用户，而为接口添加方法导致用户必须为新方法添加实现。
（6） 当派生类和基类是is-a的关系是使用"继承"，典型案例"苹果 is-a 水果"，存在can-do的关系时使用"接口"
&&& 简单的说，一个是同一个函数的几种形式,一个是重写父类函数，
1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
&&& 2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
&&& 3、覆盖要求参数列表相同；重载要求参数列表不同。
&&& 4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。
&%# %&表示绑定的数据源
&% %&是服务器端代码块
5、值类型存贮在栈中，而引用类型存贮在动态的堆中，栈是先进先出的有系统管理的空间，而堆是由应用程序控制的可随时申请和释放该空间，在中一般情况下有垃圾收集器处理，他们的不同导致在编程上的不同。
的意思是：的引用置为空但此时的堆空间并没有被释放，因此在此之后，输出时，仍然可以输出
static void Main(string[] args)
StringBuilder a=new StringBuilder();//的一个首地址传给a
StringBuilder b=a;&&&&&&&&&&&&&&&&& //的一个首地址传给b
b.Append("mxh");
Console.WriteLine(a);
Console.WriteLine(b);
输出结果：
委托实例化时，可以把方法名作为一个参数传递给委托对象，委托可以理解为指向函数的引用。生成的委托对象可以代理所传递的方法，可以接收方法的参数。也就是定义了委托，可以在不用调用原方法的情况下，调用那个方法
public delegate string MyDel(string nm,string pwd); //
static void Main(string[] args)
&&MyDel md=new MyDel(&&& //定义委托对象，其引用变量指向参数中的方法
&&string result=md("); //调用委托对象，传递所指方法的参数
委托类似于或中的函数指针。但不同的是委托是面向对象、类型安全的。
委托允许将方法作为参数进行传递。
委托可用于定义回调方法。
委托可以链接在一起；创建多个对象，使用&+=&累加到同一个委托对象上的引用上，例如，可以对一个事件调用多个方法。
string MyDel(string nm,string pwd); //
Main(string[] args)
MyDel md=new MyDel(&&&&&&& //委托对象，其引用变量指向参数中的方法
md+=new MyDel(
md+=new MyDel(
string result=md(");&& //调用委托对象，传递所指方法的参数
方法不需要与委托签名精确匹配。有关更多信息，请参见协变和逆变。
C# 2。0 版引入了匿名方法的概念，此类方法允许将代码块作为参数传递，以代替单独定义的方法。如：
private string pN
public delegate void myEventHandler(object sender, NameEventArgs e);
public event myEventHandler G
internal string Text
&get { return this.pN }
//-----------------------------------------------------------2
&&&&&&& this.pName=value;
this.OnGet(new NameEventArgs("Text
void OnGet(NameEventArgs e)//----------------------------------------3
this.Get(this, e);& //
public override string ToString()
return "Name
public class NameEventArgs : EventArgs& //
public NameEventArgs(string s)
public override string ToString()
{ return pA }
static void Main(string[] args)
Name myname = new Name();
myname.Get += new Name.myEventHandler(myname_get); //--------------4
myname.Text = "
static void myname_get(object sender, Name.NameEventArgs e) //---------5
Console.WriteLine("
&Console.WriteLine("
Console.WriteLine(")sender).Text);
事件信息：Text属性被更改了
事件发布者:Name类的对象
你输入的名字是：张三
请按任意键继续. . .
使用匿名方法，直接将方法体的代码和委托对象关联而不需要单独定义此方法
static void Main(string[] args)
&&& Name myname=new Name();
myname.Get += delegate(object sender, Name.NameEventArgs e)
也可以用Lambda表达式把delegate隐藏
static void Main(string[] args)
&&& Name myname=new Name();
myname.Get += (object sender, Name.NameEventArgs e) =&
委托是一种安全的函数指针，事件是一种消息机制
,因此委托调节器用的方法不是在编译时决定的,而是在运行时确定的.
&&& 给类的索引器赋值.
Asp.net的身份验证有有三种，分别是"Windows | Forms | Passport"，
验证 ASP.NET 会结合信息服务 (IIS),为每个用户开启帐号验证其身份安全性较高
验证为每个登陆用户写入一个身份验证票据，在使用最广的验证方式，灵活方便
passport验证由 Microsoft 提供的集中身份验证服务，该服务为成员站点提供单一登录和核心配置
就是代码隐藏，在ASP.NET中通过ASPX页面指向CS文件的方法实现显示逻辑和处理逻辑的分离，这样有助于web应用程序的创建。比如分工，美工和编程的可以个干各的，不用再像以前asp那样都代码和html代码混在一起，难以维护。
新建一个下的项目看到和三个后缀的文件，这个就是代码分离实现了代码和服务器代码分离方便代码编写和整理
活动目录是的最重要的功能可以将用户信息全部集成起来登陆以后可以访问多个不同的网络服务
命名空间，任何类型的项目都可以通过System.XML命名空间进行XML处理。使用System.Xml命名空间中的XmlDocument类来操作xml的数据
System.Net.Sockets。 Socket 类为网络通信提供了一套丰富的方法和属性。Socket 类允许您使用 ProtocolType 枚举中所列出的任何一种协议执行异步和同步数据传输。
垃圾回收器每次进行垃圾回收时，对堆上的对象进行检查，把没有被任何变量引用的对象销毁。但并不是检查堆上的每个对象，而是将对象进行分类，将所有对象分类三代（generation）。生命周期越短（新创建的对象）代数越小，反之越大。
在堆空间不够用时，垃圾回收器回收垃圾，检查第0代对象，如果发现没有被引用的对象，则标记这些为&垃圾&，并销毁。而幸存的部分的第0代对象将升级为第1代对象，某些标记为&垃圾&的对象也会幸存而升级。这时如果堆空间仍然不够用（如创建比较大的新对象），垃圾收集器将会检查第1代对象，将没有引用的对象进行销毁。幸存部分升级为第2代对象，当内存堆空间仍然不够用时，检查第2代对象，不过第2代对象检查后仍然是第2代对象，不会继续升级。
如果发现内存不够则垃圾回收器将全部对象作为无效对象被回收对象然后先将全局变量处于活动中的局部变量以及当前指针指向的对象放入一个表中然后会搜索新列表中的对象所引用的对象加入列表中其他没有被加入列表的对象都会被回收
&&& 三个generation，当每个generation内存满了的时候检查引用，无引用就回收内存
&&& 可以用来做网页可以当作数据库可以用来保存对象的系列化用于配置用于保存静态数据类型接触最多的是和
&&& property和attribute汉语都称之为属性。
&&& property一个是属性，用于存取类的字段，类向外提供的数据区域,
attribute一个是特性，用来标识类，方法等的附加性质,描述对象在编译时或运行时属性的.
触发器，性能好，事务性
&&& 简单的说，新增等，不需要随时保持连接，性能提高.
1:ADO.Net不依赖于ole db提供程序,而是使用.net托管提供的程序,
2:不使用com
3:不在支持动态游标和服务器端游
4:,可以断开connection而保留当前数据集可用
5:强类型转换
解释型，编译型，性能提高，有利于保护源码
可以主动获取远端代码，类似
存储过程是编译好的存储在数据库的操作，函数不用说了。
Session:用于保持状态的基于 Web 服务器的方法。Session 允许通过将对象存储在Web 服务器的内存中在整个用户会话过程中保持任何对象。主要用于保持代码隐藏类中对象的状态。为每个用户创建的,用于存储单个用户,因为他是相对每个用户的.所以可能来取得在线人数等。
ViewState:主要用于保持 Web 页上控件的状态。当 Web 页上的控件被绑定到代码隐藏类中的对象。
Application用于存储所有用户都可视的信息.所以它存储的是要让所有用户共享的一些信息.如总访问数等Cache，页面缓存。
Cookie:通常我们都把它放在客户端,也可以存储在服务器端。主要用它存储用户的个性设制,和登陆信息。
1、queryString& url参数 简单，显示于地址栏，长度有限
优点：简单易用；资源占用比较少。
缺点：传递数据大小有限制，只能传递基本类型的数据，安全性差
2、session(viewstate)
优点：简单，灵活性强，能传递复杂的对象
缺点：但易丢失，资源消耗大
优点：简单，
缺点：但可能不支持，可能被伪造，大小有限制不能超过4KB 不恩能够存储复杂对象
4、this.Server.Transfer,
优点：URL地址不变，安全性高，灵活性强，能传递复杂的对象
缺点：资源消耗大
5、hidden control/viewstate& 简单，可能被伪造
6、static member。&
8、application
优点：全局
缺点：资源消耗大
9、DataBase& 数据库 稳定，安全，但性能相对弱
10、xml or other&& Files&
11、XMLHTTP or Hidden iFrame/frame&
12、Context.user.identity&
&&& 我正在做一个通用提示页面，所有页面出现问题都要，传递几个变量字符串到同一个页面变量字符串包括提示语言，即将跳转的页面，跳转时间。在种方案中哪个更好些
(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这个占用了用户，不适合做这个。
input type="hidden" 简单，可能被伪造
url参数 简单，显示于地址栏，长度有限
数据库 稳定，安全，但性能相对弱
this.Server.Transfer，在新页面获得值的代码如下：
if (Page.PreviousPage != null)
&&& TextBox st =
&&&&&&& (TextBox)Page.PreviousPage.FindControl("TextBox1");
&&& if (st != null)
&&&&&&& Label1.Text = SourceTextBox.T
超链接跳转
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为公用
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.
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.
End Operator
public static void Main()
int n = 123;
int* p = &n;
Console.WriteLine("{0:X}", n);
Console.WriteLine("{0:X}", *p);
Console.WriteLine("{0}", p-&ToString());
Gloal Assembly Cache
&&& 全局程序集缓存（Global Assembly Cache）可全局使用的程序集的缓存。大多数共享程序集都安装在这个缓存中，其中也安装了一些私有程序集。存放共享程序的文件夹，可被任何项目使用
在全局程序集缓存中部署的应用程序必须具有强名称。.Net提供的命令行工具gacutil.exe用于支持这一功能。gacutil.exe可以将具有强名称的程序集添至全局程序集缓存。
所有实例公用一个的变量
需求分析，架构设计，代码编写，QA，部署
需求分析，概要设计，详细设计，软件编码，软件测试
可行性分析需求分析实施和编码，测试，维护
取：类在封装时将属性及函数设置成public
同一个名称控件直接，或者反射
const static int classNum=0;
classNum++;
构造先父后子，析够反之
string inputStr=" xx xx ";
inputStr=Regex.Replace(inputStr.Trim()，" *"，" ");
1、创建对象，调用构造函数
2、覆盖方法，隐藏父类的成员public new XXXX(){}
using引入名称空间或者使用非托管资源
new新建实例或者隐藏父类方法
if (Object.ReferenceEquals(i,j))
Console.WriteLine("Equal");
Console.WriteLine("Not Equal");
inputStr=inputStr.ToCharArray().Reverse().ToString();
static属性里面new ，构造函数private
Web应用，类似Thread Pool，提高并发性能
一个可以动态增长，一个固定(VB中可以Redim)，性能数组教好
friendly声明，可以访问protect级别方法
可以被重写
必须被重写
C++，C中忘了释放内存，内存不会再次分配
private : 私有成员， 在类的内部才可以访问。
protected : 保护成员，该类内部和继承类中可以访问。
public : 公共成员，完全公开，没有访问限制。
internal: 在同一命名空间内可以访问。
1、单位：进程是系统进行资源分配和调度的单位；线程是CPU调度和分派的单位。
2、一个进程可以有多个线程，这些线程共享这个进程的资源。
&&& 它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数。分别用来反映类的状态。比如类成员变量可以用来统计类实例的数量，类成员函数负责这种统计的动作。
&&& new是C++的关键字。malloc在分配内存时必须按给出的字节分配，new可以按照对象的大小自动分配，并且能调用构造函数。可以说new是对象的对象，而malloc不是。本质上new分配内存时，还会在实际内存块的前后加上附加信息，所以new所使用的内存大小比malloc多。
&&& 堆：一般由程序员分配释放。用new、malloc等分配内存函数分配得到的就是在堆上。
&&& 栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。
&&& 栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。
1 ASP.Net 2。0 把一些代码进行了封装打包，所以相比1。0相同功能减少了很多代码。
2 同时支持代码分离和页面嵌入服务器端代码两种模式，以前1。0版本，.Net提示帮助只有在分离的代码文件，无法在页面嵌入服务器端代码获得帮助提示，
3 代码和设计界面切换的时候，2。0支持光标定位。这个我比较喜欢
4 在绑定数据，做表的分页。UPDATE，DELETE，等操作都可以可视化操作，方便了初学者
5， 在ASP.Net中增加了40多个新的控件，减少了工作量
&&& .Net错误处理机制采用try-&catch-&finally结构，发生错误时，层层上抛，直到找到匹配的Catch为止。
反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性
可以使用反射动态地创建类型的实例,
序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
利用反射，配置 将类于数据库表映射
sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其他类的基类，则会发生编译时错误。
密封类不能同时为抽象类。
sealed 修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化。具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数成员的调用可以转换为非虚拟调用来处理。
Connection
DataAdapter
&&& DataTable 用来存储一个表的数据
DataReader
Command用来执行SQL语句
String类是类故不可以继承。
?是?定义了一套标准的数据类型，并给出了一种语言来扩展这套数据类型。?来构造一个
主要是可利用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元素中包含调用的方法或远程过程的名称，以及代表方法参数的元素。
格式以可以穿越防火墙，做到真正的数据共享。因为DataSet处理DataTable的序列化以便进行封送处理，所以无法传递单个DataTable
的三个基本数据对象 & DataReader、DataTable 和 DataSet 中，只有 DataSet 可以与 Web 服务之间传递。这是因为，为了与 Web 服务进行通信，对象必须是可序列化的。（序列化是一个过程，它用于将对象的公共属性转换为 XML，并且因为 XML 只是纯文本，所以可以将其从一个应用程序传输到另一个应用程序，并且可以穿越防火墙，从而克服了 COM 的主要障碍之一。）DataReader 无法序列化，因为它们需要到服务器的开放连接。并且，因为 DataSet 处理 DataTable 的序列化以便进行封送处理，所以您也无法传递单个 DataTable。让我们研究一些示例。
服务，该服务可返回所请求的有价证券在给定日期的收盘价格。用户传入用户 ID 和密码，以及他/她希望看到的有价证券和收盘价格的 DataTable。Web 服务随后验证他/她的成员身份并返回一个 DataTable，其中包含股票符号和它们的收盘价格，或者包含错误信息。
服务的应用程序）的开发人员需要知道股票符号和错误信息的期望结构，因此 DataSet 需要遵守您提供的发布规范。出于我们的目的，我们将假设以下条件：股票符号将存储在一个 DataTable 中，它包含三个列：一个名为 Symbol、类型为 varchar(5) 的列，一个名为 ClosingDate、类型为 datetime 的列，以及一个名为 Price、类型为 float 的列。如果在此过程中的任何时候生成错误，都将在一个只包含一列的 DataTable 中返回错误信息 & 该列的名称为 ErrorMessage，类型为 varchar(100)，并且包含错误信息。通过简单地引用所返回 DataTable 的列 count，开发人员可以知道该过程是否成功。
页或其他WEB服务调用可以使用HTTP-GET&& HTTP-POST访问WEB服务也可以从ASP页或其他WEB服务向其他WEB服务发出SOAP请求HTTP-GET&& HTTP-POST& SOAP& 使用WEB服务代理
装箱：将值类型转换为引用类型。拆箱：将引用类型转换为值类型。
句是将i装箱，后一句是将obj拆箱！再写个代码，看看进行了几次装拆箱！
次装箱和一次拆箱！^_^，看出来了吧？！第一次是将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属性
读取或设置配置文件属性
注：如果请求是回发请求，则控件的值尚未从视图状态恢复，即：不应该在此事件中设置控件属性。
完成操作：在所有控件都已经初始化并且应用所有外观设置后引发。使用该事件来读取和初始化控件属性。
3、InitComplete
完成操作：由Page对象引发，使用该事件来处理要求完成所有初始化工作的任务。
4、PreLoad
完成操作：为页和所有控件加载视图状态，然后处理Request 实例包括的任何回发数据。注：如果需要在Load之前对页或控件进行处理，需要该事件。
完成操作：以递归方式加载所有控件。
6、控件事件
完成操作：处理控件引发的事件。
注：在回发请求中，如果页包含验证程序控件，请在执行任何处理之前检查Page和各个验证控件的IsValid属性。
7、LoadComplete
8、PreRender
在控件输出前最后的修改机会。
注：在该事件发生前的操作：
Page对所有控件递归进行EnsureChildControl操作
设置了DataSourceID属性的数据绑定控件会调用DataBind方法。
9、SaveStateComplete
在该事件发生前，已经对控件的ViewState进行了保存。将忽略对页和控件所作的所有修改。
10、Render
方法，便于开发
11、UnLoad
初始化& 加载视图状态& 处理回发数据& 加载& 发送回发更改通知& 处理回发事件& 预呈现& 保存状态& 呈现& 处置& 卸载
在应用程序的生命周期期间，应用程序会引发可处理的事件并调用可重写的特定方法。若要处理应用程序事件或方法，可以在应用程序根目录中创建一个名为Global.asax的文件。如果创建了Global.asax文件，ASP.NET 会将其编译为从HttpApplication类派生的类，然后使用该派生类表示应用程序。
HttpApplication进程的一个实例每次只处理一个请求。由于在访问应用程序类中的非静态成员时不需要将其锁定，这样可以简化应用程序的事件处理过程。这样还可以将特定于请求的数据存储在应用程序类的非静态成员中。例如，可以在Global.asax文件中定义一个属性，然后为该属性赋一个特定于请求的值。
Application_Start和Application_End方法是不表示HttpApplication事件的特殊方法。在应用程序域的生命周期期间，ASP.NET 仅调用这些方法一次，而不是对每个HttpApplication实例都调用一次。
来重载初试化事件
事件中所有控件将获得他们的第一个属性ViewState属性，这个属性最终将被返回给服务器以判断这个页面是已经被用户访问完毕还是仍然在被
事件对相应的控件进行值设定。
处理Postback数据
接口操作的控件。
之间的区别，所有的对象第一次被布置在DOM页面（在Asp.net中称控件树）里了并且可以通过代码或是相关的位置被引用。这样，对象就可以很容易的从客户端获得诸如宽度、高度、值、可见性等在Html中的属性值。经常会用到的Page.IsPostBack()指示该页是否正为响应客户端回发而加载，或者它是否正被首次加载和访问.
可以对控件的属性、控件树的结构等做出最后的修改，同时还不用考虑Asp.net对其作出任何改变，因为此时已经脱离了数据库调用以及viewstate更新了，也可以通过OnPreRender来重载。
就被保存了。运用Html创建给浏览器输出的页面的时候Render事件就发生了。在Render事件过程中，页面调用其中的对象将它们呈递给Html。然后，页面就可以以Html的形式被用户的浏览器访问了。当Render事件被重载时，开发者可以编写自定义的Html代码使得原先生成的Html都无效而按照新的Html来组织页面。
Render对象作为参数并用它将Html在浏览器上以网页的形式显示。这时仍然可以做一些修改动作，不过它们只是客户端的一些变化而已了。亦可以重载Render事件。
就会在内存里生成一个继承页面对象,也就是页面的类,它继承自System.Web.UI.Page.当页面对象从内存中卸载时发生，将触发该事件.
完成后，所有的对象都应被销毁。在Dispose事件中，你应该销毁所有在建立这个页面时创建的对象。这时，所有的处理已经完毕，所以销毁任何剩下的对象都是不会产生错误的，包括页面对象。你可以重载Dispose事件。
final(.Net
short s1 = 1; s1 = s1 + 1;
String a="xyz";
System.gc()
Runtime.getRuntime().gc()
c&& ,pascal&& )
private string[] str = new string[5];
//声明属性，接收一个整型类型参数
public string this[int i]
return str[i];
str[i] = value;
public int Length
return str.L
static void Main(string[] args)
MyArray ma = new MyArray();
Console.WriteLine("请输入数组元素值："
for (int i = 0; i & ma.L i++)
ma[i] = Console.ReadLine();
Console.WriteLine("
for (int i = 0; i & ma.L i++)
Console.Write(ma[i] + " ");
class ClassHello
//extern一起使用时必须再加上一个static修饰符
[DllImport("User32.dll")]
public static extern int MessageBox(int Handle, string Message, string Caption, int Type);
static void Main()
string myS
Console.Write("
myString = Console.ReadLine();
MessageBox(0, myString, "
创建对象，调用构造函数。
public BaseClass()
Console.WriteLine("
//才可以在子类中使用override，而new不必要
public virtual void Method()
Console.WriteLine("
ClassA : BaseClass
public ClassA()
Console.WriteLine(" 构造"
public override void Method()
//base.Method();
Console.WriteLine("
ClassB : BaseClass
public ClassB()
Console.WriteLine(" 构造"
public new void Method()
//base.Method();
Console.WriteLine("
static void Main(string[] args)
BaseClass ba1 = (BaseClass)new ClassA();//
//重写方法，是基类的一个派生，
ba1.Method();
Console.WriteLine(" =================");
BaseClass bb2 = (BaseClass)new ClassB();//
//重写方法，是一个和基类无关的新方法，
bb2.Method();
Console.WriteLine(" =================");
ClassA a1 = new ClassA();
a1.Method();
Console.WriteLine(" =================");
ClassB b2 = new ClassB();
b2.Method();
Console.WriteLine(" =================");
Console.ReadKey();
=================
=================
=================
=================
321.50235& 401.22
static void Main(string[] args)
//CultureInfo 地区、日历和区域性约定。
System.Globalization.CultureInfo myCultureUS = new System.Globalization.CultureInfo("en-US");
CultureInfo myCultureEN = new CultureInfo("en-GB");
CultureInfo myCultureCN = new CultureInfo("zh-CN");
double x = 10321.5, y = 644;
string str = String.Format(myCultureUS, "My amount={0:c}
Console.WriteLine(str);
str = String.Format(myCultureEN, "My amount={0:c}
Console.WriteLine(str);
str = String.Format(myCultureCN, "My amount={0:c}
Console.WriteLine(str);
e.Cancel =
一个是退出整个应用程序，一个是关闭其中一个form。
62移动成2的6次方
通过获得枚举名称，Enum.GetValues(typeof(枚举))获得枚举常数值
对于这样的一个枚举类型
enum Color : byte
Red, Green, Blue, Orange
static void Main(string[] args)
string[] sa = Enum.GetNames(typeof(Color));&&&& // Red, Green, Blue, Orange
Console.WriteLine("
foreach (string s in sa)
Console.Write(s + "\t");
Console.WriteLine();
byte[] sb = (byte[])Enum.GetValues(typeof(Color)); // 0,1,2,3
Console.WriteLine("
foreach (byte s in sb)
Console.Write(s + "\t");
Console.WriteLine();
Green&& Blue&&& Orange
1&&&&&& 2&&&&&& 3
&&&&&&&&&&&&
不能，可以实现接口
&&& Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。
public static void test(string ConnectString)
System.Data.OleDb.OleDbConnection conn = new System.Data.OleDb.OleDbConnection();
conn.ConnectionString = ConnectS
conn.Open();
catch (Exception Ex) {
MessageBox.Show(Ex.ToString());
if (!conn.State.Equals(ConnectionState.Closed))conn.Close();
WSE (Web Service Extension)
（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
(Just In Time)
:IDisposable
private System.IO.FileStream fs = new System.IO.FileStream("test.txt", System.IO.FileMode.Create);
~DisposePattern()
Dispose(false);
//IDisposable Members
public void Dispose()
//不需要再调用Finalize方法，
GC.SuppressFinalize(this);
&Dispose(true);
#endregion
protected virtual void Dispose(bool disposing)
//方法可能被多线程调用，
lock (this)
if (disposing)
//方法并没有被执行，
//方法的对象
if (fs != null)
fs.Dispose();
fs = null; //
: DisposePattern
protected override void Dispose(bool disposing)
lock (this)
base.Dispose(disposing);
Console.WriteLine ( "quit" ) ;
: IDisposable
public MyClass() {
// 不确定的) (编译器通过重载virtual void Finalize来实现)，与C++/CLI的!MyClass()等效
~MyClass() {
// Dispose
public void Dispose() { }&&
public static void Test()
using (MyClass auto = new MyClass())
// 句法，编译器自动调用auto.Dispose()
MyClass user = new MyClass();
user.Dispose();
[serializable]
public void LockTest()
Object lockObj = new Object();
lock (lockObj)
ACL(access control list)
Debug.Write
public string FirstN
public string LastN
Person : ICloneable
public Name PersonN
public string E
//// &summary&
/// Deep Copy
/// &/summary&
/// &returns&&/returns&
public Object Clone()
Person p = new Person();
p.Email = this.E
p.PersonName = new Name();
p.PersonName.FirstName = this.PersonName.FirstN
p.PersonName.LastName = this.PersonName.LastN
public void ChangLastName(string lastName)
this.PersonName.LastName = lastN
public static void Main()
Person p = new Person();
p.PersonName = new Name();
p.PersonName.LastName = "jill";
p.PersonName.FirstName = "zhang";
p.Email = "";
Person sameNamePerson = p.Clone() as Person;
sameNamePerson.ChangLastName("clr_");
Console.WriteLine(p.PersonName.LastName);
Console.WriteLine(sameNamePerson.PersonName.LastName);
Person samePerson = p.MemberwiseClone() as Person;
samePerson.ChangLastName("Shadow");
Console.WriteLine(p.PersonName.LastName);
Console.WriteLine(sameNamePerson.PersonName.LastName);
Console.Read();
ParameterAtt : Attribute
public int Min = 100;
AttributeTest
public void TestMethod([ParameterAtt(Min = 100)] int par1)
ParameterInfo para = MethodInfo.GetCurrentMethod().GetParameters()[0];
ParameterAtt att = ParameterAtt.GetCustomAttribute(para, typeof(ParameterAtt)) as ParameterAtt;
if (att.Min & par1)
throw new Exception("最小为"
Collection
B.DisposeC.Finalize
B.CTS&&&&&&&&&&&&&& C.CLS&&&&&&&&&&&&&&&&& D.CTT
B.Object&&&&&&&&& C.ValueType&&&&&&&&&&& D.Int16
B.protected&&&&&&&&&&& C.internal&&&&&&&& D.protected internal
private static int count = 0;
static Class1()
public Class1()
B.2&&&&&&&&&&&& C.3&&&&&&&&&&&& D.4
public virtual string MethodA()
return "aaaa";
public virtual string MethodB()
return "bbbb";
: BaseClass
public string MethodA(string arg)
return "cccc";
public override string MethodB()
return "dddd";
new public string MethodB()
return "eeee";
public static void Main(string[] args)
Class2 o = new Class2();
Console.WriteLine(o.MethodA());
d)Microsoft.Win32
b)ShowInTaskbarc)Enabledd)IsMdiContainer
B.string[]
D.ArrayList
B.CustomException
D.BaseException
A. ExecuteNonQuery&&&&&&&&&&& B. ExecuteScalar&&&&& C. Fill&&&&&&&&&&&&&&&&&&&&&&& D. ExecuteReader
(&&&&&&& ABC&&&&&&&& )&
A.Close B.Dispose C.Finalize&
D.using E.Quit&
(&&& ACD&& )&
b)structd)int
&&&&&&&&&&b)2&&&&&&&&&&&& c)6&&&&&&&&&&&&& d)
static void Main(string[] args)
int A = 5, B = 7;
Console.WriteLine("B=" + B);
A = A + B;
B = A - B;
A = A - B;
Console.WriteLine("B=" + B);
Console.ReadLine();
foreach (Control c in this.Controls)
if (c is TextBox)
TextBox tb = (TextBox)c;
tb.Text = "aaa";
&" &&/File&
&" &&/File&
&" &&/File&
FileOrFolders = d.GetFileOrFolders();
foreach( FileOrFolder fof in FileOrFolders )&
if( fof is File )&
&&&&&&&& You F
else if ( fof is Directory )&
&&&&&&&& FindFile( fof );
public void test(int i)
lock (this)
if (i & 10)
public delegate void OnDBOperate();
public class UserControlBase : System.Windows.Forms.UserControl
public event OnDBOperate OnN
private void toolBar_ButtonClick(object sender, System.Windows.Forms.
ToolBarButtonClickEventArgs e)
if (e.Button.Equals(BtnNew))
//委托签名的OnNew事件。
OnNew( this, e );
public A()
PrintFields();
public virtual void PrintFields() { }
int x = 1;
public B()
public override void PrintFields()
Console.WriteLine("x={0},y={1}", x, y);
static void Main(string[] args)
Console.WriteLine("
int Num = int.Parse(Console.ReadLine().ToString());
int Sum = 0;
for (int i = 0; i & Num + 1; i++)
if ((i % 2) == 1)
&&&&&&&&&&&&&& Sum -=
System.Console.WriteLine(Sum.ToString());
System.Console.ReadLine();
static void Main(string[] args)
int[] intArr = new int[100];
ArrayList myList = new ArrayList();
Random rd = new Random();
int x = 0;
while (myList.Count & 100)
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();
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
&&&&&& 要求：1.要有联动性，老鼠和主人的行为是被动的。 2.考虑可扩展性，猫的叫声可能引起其他联动效应。
public event EventHandler C
public void Call()
Console.WriteLine("
if (Calling != null) //
Calling(this, EventArgs.Empty); //
提供一个方法表示逃跑
class Mouse
public void Escape(object sender, EventArgs e)
Console.WriteLine("
发生猫叫的时候惊醒
class Master
public void Wakened(object sender, EventArgs e)
Console.WriteLine("
public static void Main(string[] args)
Cat cat = new Cat();
Mouse mouse = new Mouse();
Master master = new Master();
cat.Calling += new EventHandler(mouse.Escape);
cat.Calling += new EventHandler(master.Wakened);
cat.Call();
void Response();
void AimAt(Observer obs);
Mouse : Observer
private string
public Mouse(string name, Subject subj)
this.name =
subj.AimAt(this);
public void Response()
Console.WriteLine(name + " attempt to escape!");
Master : Observer
public Master(Subject subj)
subj.AimAt(this);
public void Response()
Console.WriteLine("Host waken!");
Cat : Subject
private ArrayList
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();
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();
private string str = "Class1.str";
private int i = 0;
static void StringConvert(string str)
str = "A string being converted.";
static void StringConvert(Program c)
c.str = "B string being converted.";
static void Add(int i)
static void AddWithRef(ref int i)
static void Main()
int i1 = 10;
int i2 = 20;
string str = "str";
Program c = new Program();
AddWithRef(ref i2);
StringConvert(str); //string
StringConvert(c);&& //可以被改变
Console.WriteLine(i1);
Console.WriteLine(i2);
Console.WriteLine(c.i);
Console.WriteLine(str);
Console.WriteLine(c.str);
public A()
Console.WriteLine('A');
public virtual void Fun()
Console.WriteLine("A.Fun()");
public B()
Console.WriteLine('B');
public new void Fun()
Console.WriteLine("B.Fun()");
public static void Main()
A a = new B();
public virtual void Fun1(int i)
Console.WriteLine(i);
public void Fun2(A a)
a.Fun1(1);& //
Fun1(5);&&& //
public override void Fun1(int i)
base.Fun1(i + 1);
public static void Main()
B b = new B();
A a = new A();
a.Fun2(b);
b.Fun2(a);
public static void ArraySort()
int[] Arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
int t = 0;
for (int i = 0; i & Arr.Length - 1; i++)&&&&&&&&&&& //趟
for (int j = 0; j & Arr.Length - 1 - j++)&&& //趟数）次比较
if (Arr[j] & Arr[j + 1])
t = Arr[j];
Arr[j] = Arr[j + 1];
Arr[j + 1] =
foreach (int i in Arr)
Console.Write(i + ",");
public static void Main()
ArraySort();
public static int X;
static A()
X = B.Y + 1;
public static int Y = A.X + 1;
static B() { }
static void Main()
Console.WriteLine("X={0},Y={1}", A.X, B.Y);
在form中重载DefWndProc函数来处理消息:
void DefWndProc(ref System.WinForms.Message m)
switch (m.msg)
case WM_Lbutton:
///string中的CString的Format函数的使用方法有所不同
string message = string.Format("参数为:{0},{1}"
MessageBox.Show(message);///
case USER:
base.DefWndProc(ref m);///
请说明如下代码的结果
public virtual void show()
Console.WriteLine("Father");
static void Main(string[] args)
Father obj = new Child();
obj.show();
public override void show()
Console.WriteLine("Child");}