C#/.Net - 艺风在线 - Power By CSZI.com

C#语言的几个层次

一线风 — 2009-5-15 13:02:12

不谈具体领域（比如搜索，视频，网络等），单就编程语言这个垂直方向，我大体上对它有一个如下的层次划分。

1. 基本运用C#语法，在各种工具和示例代码的支持下，完成一些基本程序任务

2. 熟练掌握面向对象与组件构造，知其然亦知其所以然，完成一般小规模信息管理类软件项目开发任务

3. 深入理解CLR内核机制，对各种类型与.NET平台机制的优缺点、适用场合、效率有清晰把握，能够完成技术复杂度比较高的项目。

4. 能够游刃有余把握松耦合原则,精准运用各种语言构造，架构大型软件项目。

5. 能够站在计算机抽象、系统和历史发展的高度来理解和把握编程语言

子类与父类的小关系：盒子套盒子

一线风 — 2009-3-10 16:39:08

创建一个控制台程序，运行一个看看：

C#代码

class Program
{
static void Main(string[] args)
{
InBox son = new InBox();
son.m1();
son.m2();
Console.WriteLine("转换成父类");
Box box = (Box)son;
box.m1(); //从这儿就能看出，只有父类的方法，而没有子类的方法了？所以像不像是父类就是子类里的一个盒子？
}
}
class Box
{
public void m1()
{
Console.WriteLine("我是父类的方法");
Console.ReadLine();
}
}
class InBox : Box
{
public void m2()
{
Console.WriteLine("我是子类的方法");
Console.ReadLine();
}
}

C#位运算讲解与示例[转]

一线风 — 2008-12-3 15:02:23

在C#中可以对整型运算对象按位进行逻辑运算。按位进行逻辑运算的意义是：依次取被运算对象的每个位，进行逻辑运算，每个位的逻辑运算结果是结果值的每个位。C#支持的位逻辑运算符如表2.9所示。

运算符号	意义	运算对象类型	运算结果类型	对象数	实例
~	位逻辑非运算	整型，字符型	整型	1	~a
&	位逻辑与运算			2	a & b
\|	位逻辑或运算			2	a \| b
^	位逻辑异或运算			2	a ^ b
<<	位左移运算			2	a<<4
>>	位右移运算			2	a>>2

from : http://blog.csdn.net/icyleaf1026/archive/2007/08/25/1758243.aspx

1、位逻辑非运算

位逻辑非运算是单目的，只有一个运算对象。位逻辑非运算按位对运算对象的值进行非运算，即：如果某一位等于0，就将其转变为1；如果某一位等于1，就将其转变为0。

比如，对二进制的10010001进行位逻辑非运算，结果等于01101110，用十进制表示就是：

~145等于110；对二进制的01010101进行位逻辑非运算，结果等于10101010。用十进制表示就是~85等于176。

2、位逻辑与运算

位逻辑与运算将两个运算对象按位进行与运算。与运算的规则：1与1等于1，1与0等于0。

比如：10010001（二进制）&11110000等于10010000（二进制）。

3、位逻辑或运算

位逻辑或运算将两个运算对象按位进行或运算。或运算的规则是：1或1等1，1或0等于1，

0或0等于0。比如10010001（二进制）| 11110000（二进制）等于11110001（二进制）。

4、位逻辑异或运算

位逻辑异或运算将两个运算对象按位进行异或运算。异或运算的规则是：1异或1等于0，

1异或0等于1，0异或0等于0。即：相同得0，相异得1。

比如：10010001（二进制）^11110000（二进制）等于01100001（二进制）。

5、位左移运算

位左移运算将整个数按位左移若干位，左移后空出的部分0。比如：8位的byte型变量

byte a=0x65(即二进制的01100101),将其左移3位：a<<3的结果是0x27(即二进制的00101000)。

6、位右移运算

位右移运算将整个数按位右移若干位，右移后空出的部分填0。比如：8位的byte型变量

Byte a=0x65(既（二进制的01100101）)将其右移3位：a>>3的结果是0x0c(二进制00001100)。

在进行位与、或、异或运算时，如果两个运算对象的类型一致，则运算结果的类型就是运算对象的类型。比如对两个int变量a和b做与运算，运算结果的类型还是int型。如果两个运算

对象的类型不一致，则C#要对不一致的类型进行类型转换，变成一致的类型，然后进行运算。

类型转换的规则同算术运算中整型量的转换则一致。

由位运算符连接整型量而成的表达式就是位运算表达式。

VS项目里.sln和.suo文件的作用

一线风 — 2008-3-27 18:11:25

今天发现suo是变化的,一直不知是啥作用,就查了一下.

Visual   Studio   .NET   采用两种文件类型（.sln   和   .suo）来存储特定于解决方案的设置。这些文件总称为解决方案文件，为解决方案资源管理器提供显示管理文件的图形接口所需的信息，从而使您每次继续开发任务时，都能够全身心地投入到项目和最终目标中，不会因开发环境而分散精力。


扩展名   名称   说明

*.sln   Visual   Studio.Solution   通过为环境提供对项目、项目项和解决方案项在磁盘上位置的引用，可将它们组织到解决方案中。     比如是生成Debug模式,还是Release模式,是通用CPU还是专用的等

*.suo  (solution user opertion 我自已理解的) 解决方案用户选项   记录所有将与解决方案建立关联的选项，以便在每次打开时，它都包含您所做的自定义设置。比如你的VS布局,你的项目最后编译的而又没有关掉的文件(下次打开时用)

C# String小技巧

一线风 — 2008-3-17 13:15:58

NET string 类是相当广泛的,然而仍有一些String函数是缺失的或者不是很明显,在使用Net String时,这里提供几个小技巧.

用重复的字符填充一个 String

为了用重复的字符填充一个字符串, 使用string 类的构造函数.例如:用20个(*)填充一个字符串.

string s = new string( '*', 20 );

......

NET string 类是相当广泛的,然而仍有一些String函数是缺失的或者不是很明显,在使用Net String时,这里提供几个小技巧.

用重复的字符填充一个 String

为了用重复的字符填充一个字符串, 使用string 类的构造函数.例如:用20个(*)填充一个字符串.

string s = new string( '*', 20 );

检查空字符串

一个空字符串可能表现为空引用或者空字符串(String.Empty或null),如果你试图对一个空字符串调用方法,可能会发生异常.因此,要检查空字符串,你应该使用Net2.0中的静态函数 String.IsNullOrEmpty;
String.IsNullOrEmpty( s )

String.Empty vs. ""? 并不重要

在网上关于用string.Empty还是""表示空字符已经有很多争论了,然而测试表明,这里差别很小,即使创建10亿个空字符串时.

反转字符串

这里有很多算法在反转字符串方面. 下面是一个很好的方法,不论是作用在Unicode还是字符上:

static public string Reverse( string s )
{
    char[] charArray = s.ToCharArray();
    Array.Reverse( charArray );
    return new string( charArray );
}

字符串比较

由于字符串引用可能是空的,所以在比较字符串时,你应该避免使用"=="或者成员比较函数.代替的是使用静态的String.Compare方法.这个方法有个优势就是它能处理空字符串引用,忽略字符串大小写.也可以在特定文化背景下使用.

if (String.Compare( s1, s2, true ) == 0)

转换字符串为数字类型

每一种数字类型如: int, Int32, double, 等等,都有一个静态TryParse 方法来转换一个字符串而不抛出异常.这个方法返回一个bool无论这个字符串是否包含在这个特殊的数字类型中.例如:

string s = "42″;
int i;
int.TryParse( s, out i );

IndexOf 忽略大小写

字符串的 IndexOf 方法是对大小写敏感的.幸运的是. 这个Globalization 命名空间下包含 CompareInfo 类,它包含一个对大小写敏感的 IndexOf 方法. 例如:

    using System.Globalization;

    string s1 = "C# is a GREAT programming language.";
    string s2 = "great";

    CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo;
    int i = Compare.IndexOf( s1, s2, CompareOptions.IgnoreCase );

本周ASP.NET英文技术文章推荐[03/02 - 03/15]：ASP.NET AJAX、LinqDataSource、ListView、MVC、JavaScript、智能感知、Ext、CAPTCHA

一线风 — 2008-3-17 10:36:51

摘要

本期共有7篇文章（实际上有12篇文章，这两天不知为何网络状况一直不好，很多国外网站都上不去，只好暂时作罢）：

深入ASP.NET AJAX：对象继承体系
使用ASP.NET 3.5和自定义层级数据源控件构造Vista样式的文件夹浏览器
使用ASP.NET 3.5的LinqDataSource和ListView实现Tag云的过滤
对ASP.NET MVC第二个预览版本的想法
ASP.NET MVC中测试框架的集成
JavaScript智能感知支持Ext框架
在ASP.NET MVC中实现CAPTCHA

转自：http://www.cnblogs.com/dflying/archive/2008/03/16/1108763.html

[1] ASP.NET AJAX In-Depth: Object Inheritance （深入ASP.NET AJAX：对象继承体系）

这是《ASP.NET 3.5 Unleashed》一书的作者，Stephen Walther的一篇文章，其中在源代码级别讨论了ASP.NET AJAX中继承的实现方式。对ASP.NET AJAX原理感兴趣的朋友，或是想学习一下JavaScript的朋友都可以参考一下。

Steve还有两篇相关的文章，如果你看了上一篇的话，也可以顺便看看这两篇：

[2] Building a Vista Style Folder Browser with ASP.NET 3.5 and a Custom Hierarchical DataSource Control （使用ASP.NET 3.5和自定义层级数据源控件构造Vista样式的文件夹浏览器）

使用了不少东西组合起来，包括GridView、UpdatePanel、TreeView、FileSystemDataSource、ListView等等，界面也很漂亮（真的很像Vista）：

不过说实话，除了界面模仿得比较成功之外，其它还真没有那些地方特别有“技术含量”。不过一俊遮百丑，已经很不错了。

Live Demo (IE6, IE7, FF and Opera) | Download (.Net 3.5)

[3] Tag Cloud Filters with ASP.NET 3.5's LinqDataSource and ListView Controls （使用ASP.NET 3.5的LinqDataSource和ListView实现Tag云的过滤）

同样是界面比较漂亮（居然使用了几个iPhone的图标-_-），不过也算是有了一些新东西——LinqDataSource和ListView。适合入门者阅读：

[4] Thoughts on ASP.NET MVC Preview 2 and Beyond （对ASP.NET MVC第二个预览版本的想法）

随着这两天新版本ASP.NET MVC框架在MIX08上面发布，这一段的热点也随之来到了这里。作为能够与WebForm媲美的另一种Web开发框架，MVC自然有它存在的位置。

不过这篇文章主要以介绍这个新版本为主，还有一些作者对ASP.NET MVC今后发展方向的自己想法。

[5] ASP.NET MVC Test Framework Integration Walkthrough （ASP.NET MVC中测试框架的集成）

使用过ASP.NET MVC的朋友都不会对这个界面感到陌生：

本文是http://blogs.msdn.com/webdevtools/archive/2008/02/18/asp-net-mvc-test-framework-integration.aspx的姊妹篇。其中介绍了ASP.NET MVC中有关测试框架集成的点点滴滴，并提供了集成几种现有测试框架的模板。通过这个强大特性，我们即可在使用ASP.NET MVC时选择最熟悉的测试框架，而不必局限于某种特别的约定中。

[6] JScript IntelliSense: Working with Ext JS （JavaScript智能感知支持Ext框架）

继官方的ASP.NET AJAX和最近发布的jQuery之后，Visual Studio的智能感知功能又有了新的适用成员，那就是同样流行的Ext框架。不用多说，只要看看效果就知道了：

[7] ASP.NET MVC CAPTCHA （在ASP.NET MVC中实现CAPTCHA）

CAPTCHA即Completely Automated Public Turing Test to Tell Computers and Humans Apart（全自动的公开图灵测试），其目的是让计算机生成区分计算机和人类的程序算法，这种程序必须能够生成并评价出人类能很容易通过但计算机却难以通过的测试。目前常见的验证图片等都属于CAPTCHA。若想了解更多，请访问“The CAPTCHA Project”网站：http://www.captcha.net/。…………

（其实说简单了，CAPTCHA就是网站中常见的“验证码”）

这篇文章介绍了在ASP.NET MVC中实现CAPTCHA的方法，其实核心逻辑上与普通WebForm没有任何区别，只是放在了在ASP.NET MVC中，似乎好像“旧貌换新颜”了……

简单自定义实现jQuery验证

一线风 — 2008-3-14 10:40:24

分两种情况验证，一是直接使用本地验证，二是ajax到服务器验证。

我现在需要验证：用户名，邮箱，电话三个input(text)，用户名、电话号码只需要本地验证格式，只要匹配给定的正则表达式即可，而邮箱首先在本地验证格式，符合格式则ajax到服务器验证是否已被注册，如果被注册了则不能通过验证。

对于每个input后面跟随三种状态，分别表示验证通过、验证未通过、正在提交服务器验证，当未通过验证时，还出示提示信息。

首先设计服务器端的邮箱验证，这里使用.ashx 文件。

转自：http://www.cnblogs.com/somesongs/archive/2008/03/13/1103068.html

C#代码

<%@ WebHandler Language="C#" Class="validateEmail" %>
using System;
using System.Web;
using System.Data.SqlClient;
public class validateEmail : IHttpHandler {
public void ProcessRequest (HttpContext context) {
if (context.Request.QueryString.Count != 0)
{
string email = context.Request.QueryString[0].Trim();
context.Response.ContentType = "text/plain";
SqlConnection conn = new SqlConnection("Server=localhost;User Id=sa;Password=;Database=XXX");
SqlCommand sqlCmd = new SqlCommand("select count(*) from Clients where email=@email", conn);
sqlCmd.Parameters.AddWithValue("@email", email);
try
{
conn.Open();
int result = (int)sqlCmd.ExecuteScalar();
context.Response.Write("{message:'"+result.ToString()+"'}"); //输出为JSON格式
}
finally
{
conn.Close();
}
}
}
public bool IsReusable {
get {
return false;
}
}
}

接下来实现客户端的html，添加对JQuery的引用

js脚本代码：

JavaScript代码

//给定需要验证的input添加 needValidate='true' 的属性对，然后选择他们，添加blur的事件函数。
$("input[needValidate='true']").blur(function()
{
if(requireField(this))//首先客户端验证
{
if(this.id == 'your_email')//如果是邮件则还进行ajax服务器端验证
{
$('#email_img').html("");
$.getJSON("validateEmail.ashx",{email:this.value},processValidateEmail);//getJSON获取服务器端的验证结果
}
else
{
$('#'+this.id+'_img').html("");
$('#'+this.id+'_error').html("");
}
}
}
)
});
//ajax验证完成后的处理函数
function processValidateEmail(data)
{
if(data.message == "0")//表示服务器端没有该邮箱地址
{
$('#your_email_img').html("");
$('#your_email_error').html("");
}
else
{
$('#your_email_img').html("");
$('#your_email_error').html("邮箱已被人注册，请更换重试！").attr("style","color:red;");
}
}
//客户端验证函数
function requireField(o)
{
var your_email = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
var your_name = /^(\w){4,20}|[^u4e00-u9fa5]{2,20}$/;
var your_tel = /^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/;
var your_email_error = "请输入正确的邮箱格式！";
var your_name_error = "请输入您的名字，不少于4个字符！";
var your_tel_error = "请输入正确的电话号码格式！";
if(o.value.match(eval(o.id)))
{
return true;
}
else
{
$('#'+o.id+'_img').html("");
$('#'+o.id+'_error').html(eval(o.id+'_error')).attr("style","color:red;");
}
return false;
}
//submit前的验证函数
function validate() {
var biaozhi = true;
$("input[needValidate='true']").each(function(i){
if(!requireField(this))
{ biaozhi = false; }
}
)
return biaozhi;
}

html须验证的表单代码：

XML/HTML代码

<li><label for="your_name">你的姓名：label>
<input name="your_name" id="your_name" type="text" needValidate="true" value="" /><span id="your_name_img">span><div id="your_name_error">div>li>
<li><label for="your_email">你的邮箱：label>
<input name="your_email" id="your_email" type="text" needValidate="true" value="" /><span id="your_email_img">span><div id="your_email_error">div>li>
<li><label for="your_tel">你的电话：label>
<input name="your_tel" id="your_tel" type="text" needValidate="true" value="" /><span id="your_tel_img">span><div id="your_tel_error">div>li>
<li><label for="comment">相关信息：label>
<input id="comment" name="comment" type="text" value="" />li>

以下为javascript正则表达式的参考：
http://www.ccvita.com/index.php/61.html
http://www.cnblogs.com/westlake/articles/388873.html

C#异步编程

一线风 — 2008-3-13 14:25:30

异步编程概览
.NET Framework 允许您异步调用任何方法。定义与您需要调用的方法具有相同签名的委托；公共语言运行库将自动为该委托定义具有适当签名

的 BeginInvoke 和 EndInvoke 方法。

BeginInvoke 方法用于启动异步调用。它与您需要异步执行的方法具有相同的参数，只不过还有两个额外的参数（将在稍后描述）。

BeginInvoke 立即返回，不等待异步调用完成。
BeginInvoke 返回 IasyncResult，可用于监视调用进度。

EndInvoke 方法用于检索异步调用结果。调用 BeginInvoke 后可随时调用 EndInvoke 方法；如果异步调用未完成，EndInvoke 将一直阻塞到

异步调用完成。EndInvoke 的参数包括您需要异步执行的方法的 out 和 ref 参数（在 Visual Basic 中为 ByRef 和 ByRef）以及由

BeginInvoke 返回的 IAsyncResult。

转自：http://www.cnblogs.com/ericwen/archive/2008/03/12/1101801.html

同步方法和异步方法的区别
同步方法调用在程序继续执行之前需要等待同步方法执行完毕返回结果
异步方法则在被调用之后立即返回以便程序在被调用方法完成其任务的同时执行其它操作

四种使用 BeginInvoke 和 EndInvoke 进行异步调用的常用方法。调用了 BeginInvoke 后，可以：

1.进行某些操作，然后调用 EndInvoke 一直阻塞到调用完成。
2.使用 IAsyncResult.AsyncWaitHandle 获取 WaitHandle，使用它的 WaitOne 方法将执行一直阻塞到发出 WaitHandle 信号，然后调用

EndInvoke。这里主要是主程序等待异步方法，等待异步方法的结果。
3.轮询由 BeginInvoke 返回的 IAsyncResult，IAsyncResult.IsCompeted确定异步调用何时完成，然后调用 EndInvoke。此处理个人认为与
相同。
4.将用于回调方法的委托传递给 BeginInvoke。该方法在异步调用完成后在 ThreadPool 线程上执行，它可以调用 EndInvoke。这是在强制装

换回调函数里面IAsyncResult.AsyncState(BeginInvoke方法的最后一个参数)成委托，然后用委托执行EndInvoke。
警告始终在异步调用完成后调用 EndInvoke。

以上有不理解的稍后可以再理解。

例子
1）先来个简单的没有回调函数的异步方法例子

请再运行程序的时候，仔细看注释，对理解很有帮助。还有，若将注释的中的两个方法都同步，你会发现异步运行的速度优越性。

C#代码

using System;
namespace ConsoleApplication1
{
class Class1
{
//声明委托
public delegate void AsyncEventHandler();
//异步方法
void Event1()
{
Console.WriteLine("Event1 Start");
System.Threading.Thread.Sleep(4000);
Console.WriteLine("Event1 End");
}
// 同步方法
void Event2()
{
Console.WriteLine("Event2 Start");
int i=1;
while(i<1000)
{
i=i+1;
Console.WriteLine("Event2 "+i.ToString());
}
Console.WriteLine("Event2 End");
}
[STAThread]
static void Main(string[] args)
{
long start=0;
long end=0;
Class1 c = new Class1();
Console.WriteLine("ready");
start=DateTime.Now.Ticks;
//实例委托
AsyncEventHandler asy = new AsyncEventHandler(c.Event1);
//异步调用开始，没有回调函数和AsyncState,都为null
IAsyncResult ia = asy.BeginInvoke(null, null);
//同步开始，
c.Event2();
//异步结束，若没有结束，一直阻塞到调用完成，在此返回该函数的return，若有返回值。
asy.EndInvoke(ia);
//都同步的情况。
//c.Event1();
//c.Event2();
end =DateTime.Now.Ticks;
Console.WriteLine("时间刻度差="+ Convert.ToString(end-start) );
Console.ReadLine();
}
}
}

2）下面看有回调函数的WebRequest和WebResponse的异步操作。

C#代码

using System;
using System.Net;
using System.Threading;
using System.Text;
using System.IO;
// RequestState 类用于通过
// 异步调用传递数据
public class RequestState
{
const int BUFFER_SIZE = 1024;
public StringBuilder RequestData;
public byte[] BufferRead;
public HttpWebRequest Request;
public Stream ResponseStream;
// 创建适当编码类型的解码器
public Decoder StreamDecode = Encoding.UTF8.GetDecoder();
public RequestState()
{
BufferRead = new byte[BUFFER_SIZE];
RequestData = new StringBuilder("");
Request = null;
ResponseStream = null;
}
}
// ClientGetAsync 发出异步请求
class ClientGetAsync
{
public static ManualResetEvent allDone = new ManualResetEvent(false);
const int BUFFER_SIZE = 1024;
public static void Main(string[] args)
{
if (args.Length < 1)
{
showusage();
return;
}
// 从命令行获取 URI
Uri HttpSite = new Uri(args[0]);
// 创建请求对象
HttpWebRequest wreq = (HttpWebRequest)WebRequest.Create(HttpSite);
// 创建状态对象
RequestState rs = new RequestState();
// 将请求添加到状态，以便它可以被来回传递
rs.Request = wreq;
// 发出异步请求
IAsyncResult r = (IAsyncResult)wreq.BeginGetResponse(new AsyncCallback(RespCallback), rs);
// 将 ManualResetEvent 设置为 Wait，
// 以便在调用回调前，应用程序不退出
allDone.WaitOne();
}
public static void showusage()
{
Console.WriteLine("尝试获取 (GET) 一个 URL");
Console.WriteLine("\r\n用法：:");
Console.WriteLine("ClientGetAsync URL");
Console.WriteLine("示例：:");
Console.WriteLine("ClientGetAsync http://www.microsoft.com/net/");
}
private static void RespCallback(IAsyncResult ar)
{
// 从异步结果获取 RequestState 对象
RequestState rs = (RequestState)ar.AsyncState;
// 从 RequestState 获取 HttpWebRequest
HttpWebRequest req = rs.Request;
// 调用 EndGetResponse 生成 HttpWebResponse 对象
// 该对象来自上面发出的请求
HttpWebResponse resp = (HttpWebResponse)req.EndGetResponse(ar);
// 既然我们拥有了响应，就该从
// 响应流开始读取数据了
Stream ResponseStream = resp.GetResponseStream();
// 该读取操作也使用异步完成，所以我们
// 将要以 RequestState 存储流
rs.ResponseStream = ResponseStream;
// 请注意，rs.BufferRead 被传入到 BeginRead。
// 这是数据将被读入的位置。
IAsyncResult iarRead = ResponseStream.BeginRead(rs.BufferRead, 0, BUFFER_SIZE, new AsyncCallback(ReadCallBack), rs);
}
private static void ReadCallBack(IAsyncResult asyncResult)
{
// 从 asyncresult 获取 RequestState 对象
RequestState rs = (RequestState)asyncResult.AsyncState;
// 取出在 RespCallback 中设置的 ResponseStream
Stream responseStream = rs.ResponseStream;
// 此时 rs.BufferRead 中应该有一些数据。
// 读取操作将告诉我们那里是否有数据
int read = responseStream.EndRead(asyncResult);
if (read > 0)
{
// 准备 Char 数组缓冲区，用于向 Unicode 转换
Char[] charBuffer = new Char[BUFFER_SIZE];
// 将字节流转换为 Char 数组，然后转换为字符串
// len 显示多少字符被转换为 Unicode
int len = rs.StreamDecode.GetChars(rs.BufferRead, 0, read, charBuffer, 0);
String str = new String(charBuffer, 0, len);
// 将最近读取的数据追加到 RequestData stringbuilder 对象中，
// 该对象包含在 RequestState 中
rs.RequestData.Append(str);
// 现在发出另一个异步调用，读取更多的数据
// 请注意，将不断调用此过程，直到
// responseStream.EndRead 返回 -1
IAsyncResult ar = responseStream.BeginRead(rs.BufferRead, 0, BUFFER_SIZE, new AsyncCallback(ReadCallBack), rs);
}
else
{
if (rs.RequestData.Length > 1)
{
// 所有数据都已被读取，因此将其显示到控制台
string strContent;
strContent = rs.RequestData.ToString();
Console.WriteLine(strContent);
}
// 关闭响应流
responseStream.Close();
// 设置 ManualResetEvent，以便主线程可以退出
allDone.Set();
}
return;
}
}

在这里有回调函数，且异步回调中又有异步操作。

首先是异步获得ResponseStream，然后异步读取数据。

这个程序非常经典。从中可以学到很多东西的。我们来共同探讨。

总结
上面说过，.net framework 可以异步调用任何方法。所以异步用处广泛。

在.net framework 类库中也有很多异步调用的方法。一般都是已Begin开头End结尾构成一对，异步委托方法，外加两个回调函数和AsyncState参数，组成异步操作的宏观体现。所以要做异步编程，不要忘了委托delegate、Begin，End，AsyncCallBack委托，AsyncState实例(在回调函数中通过IAsyncResult.AsyncState来强制转换)，IAsycResult(监控异步），就足以理解异步真谛了。

ASp.net中Froms验证方式

一线风 — 2008-2-29 14:01:33

微软的ASP.NET提供了３种用户验证方式，即Windows验证、窗体(Forms)验证和护照验证(Passport)验证。
　　
由于验证方式各不相同，因而这3种验证方式在使用范围上也有很大的不同,　Windows验证方式只适用于放在受控环境里的网站;　也就是说，更适合于企业内网(Intranet)。窗体认证特别适合布置于互联网的应用，而护照验证方式适合于跨站之间的应用，用户只用一个用户名和密码就可以访问任何成员站，并且在注销离开时，所有护照信息都会清除，你可以在公共场所放心的使用。
我们在编写Web程序时，最多用到的便是窗体(Forms)验证方式，而微软提供了只要简单的配置Web.config文件就可实现这种简单的窗体(Forms)验证。为了能更好的使用窗体验证，我对这种验证方式进行了研究。
　　　

原文：http://blog.csdn.net/xiaoling9/archive/2007/04/10/1559085.aspx

基于表单身份验证的类的命名空间：System.Web.Security
常用的几个类分别为：
１．FormsAuthentication
作用：为 Web 应用程序管理 Forms 身份验证服务
２．FormsAuthenticationTicket
　作用：提供对票证的属性和值的访问，这些票证用于 Forms 身份验证对用户进行标识
３．FormsIdentity
　作用：表示一个使用 Forms 身份验证进行了身份验证的用户标识.(用户身份)
４．FormsAuthenticationModule
作用：启用 Forms 身份验证的情况下设置 ASP.NET 应用程序用户的标识

一、实现简单的验证方式

首先，我们可以通过配置Web.Config文件来实现简单的验证方式。先建立一个Web工程，然后在首页放登录控件。然后在这个工程下再建立一个目录，在这个目录下添加两个Web页面，设置成这个目录下的页面只有通过验证后再能访问。
在Default.aspx页中，输入用户名和密码，然后Click,如果密码和用户名正确，则通过验证就能转到新建目录下的一个页面上。如果没有通过验证，则不能访问目录下的页面。代码如下：

C#代码

Void Logon_Click(object sender, EventArgs e)
{
String UserName = UserEmail.Text;
String UserPass = UserPass.Text;
If(通过连接数据库判断用户和密码是否正确)
{
　//将经过身份验证的用户重定向回最初请求的 URL 或默认 URL
FormsAuthentication.RedirectFromLoginPage(UserName, Persist.Checkd);
　 //这个函数是否建立Cookie:解决：建立Cookie
Else
{
Msg.Text = Invalid credentials. Please try again.";
}
}

然后在建立的目录下，新建一个Web.Config文件

XML/HTML代码

<configuration>
　　　　<system.web>
　　　 <authorization>
　　　　<deny users="?" />　　　不充许没经过身份验证的用户进行访问
　　　 authorization>
　　　　system.web>
configuration>

在这个Web.Config文件中，设置了这个目录下所有文件的授权方式。这是一种URL授权。应用程序根据配置对匿名用户进行检查。ＵＲＬ授权在Web.config中的区段内定义。
区段中有两个标记，标记定义了许的用户、任务和操作，在标记中包含了不被充许的用户、任务和操作。
例如:

“*”代表所有的用户，“？”表示匿名(没经过身份验证的)用户。

在要目下的Web.Config中，我们同时要设置验证方式是基于Forms的

XML/HTML代码

<authentication mode="Forms">
<forms loginUrl="Logon.aspx" name=".ASPXFORMSAUTH">forms>
authentication>
<authorization>
<allow users="*"/>
authorization>

元素的有效属性
Name: 用于身份验证的Http Cookie的名称。
LoginUrl:没有通地验证的用户将要被重定向到的登录页面的URL.
Protection: Cookie数据的保护方法。
TimeOut: Cookie的过期时限，以分钟为单位。默认值为30
Path:Path用于已发出Cookie的路径。默认值为”/”。

二、实现复杂的验证方式（角色控制）

　　构造GenericPrincipal 和　FormsIdentity　对象
GenericPrincipal :　表示一般用户
FormsIdentity:表示一个使用 Forms 身份验证进行了身份验证的用户标识
FormsIdentity类由 FormsAuthenticationModule在通过 Forms 身份验证对用户进行身份验证时使用。使用从 Forms 身份验证 Cookie 或 URL 解密的 FormsAuthenticationTicket创建一个 FormsIdentity的实例。然后，使用此 FormsIdentity类的新实例构造一个新的 GenericPrincipal 对象，该对象将设置为当前 HttpContext的 User属性的值

在Global.asax文件中，添加事件Application_AuthenticateRequest代码：
注：Application_AuthenticateRequest在这个事件中添加自定义身份验证的代码。

1、页面请求时获得cookie及角色值

C#代码

using System.Web.Security;
using System.Security;
//这个事件用于页面请求时获得cookie及角色值
protected void Application_AuthenticationRequest(object sender, EventArgs e)
...{
//请求传递的Cookie集合中获得窗体身份验证Cookie
//FormsCookieName:获取用于存储Forms 身份验证票证的Cookie 名称
//FormsCookieName 用于引用存储FormsAuthenticationTicket 信息的Cookie
string cookiename = FormsAuthentication.FormsCookieName;
//提供创建和操作各HTTP Cookie 的类型安全方法
//HttpCookie类获取和设置各Cookie 的属性
HttpCookie cookie = Reauest.Cookies[cookiename]; /**//*从cookiename得到cookie*/
if (cookie == null)
return;
//从窗体身份验证cookie中提取和解密身份验证票据
FormsAuthenticationTicket ticket = null;
try
...{
//返回值：一个FormsAuthenticationTicket 对象
ticket = FormsAuthentication.Decrypt(cookie.Value); //cookie:加密的身份验证票
}
catch(Exception err)
...{
return;
}
if (ticket == null)
return;
//解析出用户在最初对用户进行身份验证时附加到票上的管道分隔的角色名称列表
string[] roles = ticket.UserData.Split(new char[] ...{ '|' });
//创建一个FormsIdentity对象和一个GenericPrincipal对象。前一个对象从票名称中
//获得用户名，后一个对象将此标识与用户角色列表包含在一起
FormsIdentity ident = new FormsIdentity(ticket);
GenericPrincipal princ = new GenericPrincipal(ident, roles);
HttpContext.Current.User = princ;
}

2、登录时可以得到用户信息以及是否已经登录　

C#代码

//验证及得到用户信息
private void Page_Load(object sender, System.EventArgs e)
...{
FormsIdentity userIdentiy;
FormsAuthenticationTicket objTecket;
if (System.Web.HttpContext.Current.User.Identity.IsAuthenticated)
...{
userIdentiy = HttpContext.Current.User.Identity;
objTecket = userIdentiy.Ticket;
//可以从Ticket中获取用户信息
}
else
...{
Response.Write("");
//或者指向登录页面
Response.Redirect("Login.aspx");
}
}

3、登录时生成用户票据

C#代码

private string Authorization(string username, string password)
...{
//用户登录验证
string ip = System.Web.HttpContext.Current.Request.UserHostAddress;
string name = username;
string pwd = password;
if (ValidatePwd(name, pwd) = true) //数据库验证，代码略
...{
//创建身份验证票证
FormsAuthenticationTicket ticker = new FormsAuthenticationTicket(1, name, DateTime.Now,
DateTime.Now.AddMinutes(30), false, "");
string encryptTicket = FormsAuthentication.Encrypt(ticker);
HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptTicket);
Reponse.AppendCookie(cookie);
//将用户重定向到最初的请求页面
Response.Redirect(FormsAuthentication.GetRedirectUrl(name, false));
//Resonse.Redirect(FormsAuthentication.RedirectFromLoginPage(name, false));
//this.Session["UserName"] = username;
}
else
...{
Response.Write("");
}
}

　　解释：

Context.User.Identity.IsAuthenticated

　　Context：获取与该页关联的 System.Web.HttpContext 对象

　　User：为当前 HTTP 请求获取或设置安全信息

　　Identity：获取当前用户的标识

　　IsAuthenticated：获取一个bool值，该值指示是否验证了用户

VisualStudio 2008 团队套件简体中文正式版+TFS2008英文正式版BT发布

一线风 — 2008-2-4 18:14:27

感谢wildfire的放种
VS2008团队套件简体中文正式版
Microsoft.Visual.Studio.Team.System.2008.Team.Suite.Chs-wildfire.iso
Visual Studio Team Foundation Server 2008

下载:VisualStudio 2008 团队套件简体中文正式版+TFS2008英文正式版

asp.net页面间数据传递(总结篇)

一线风 — 2008-2-2 15:33:33

当然可以变通下灵活应用来解决问题，但是要选择合适的，常见到滥用Get和Session。
建议在用Request的时候要指明所取的集合，比如Get方法传来的参数从QueryString集合取,Post的从Form取，cookie从Cookies里取。虽然用Request[]集合，以上几种都可以取到，但是却造成性能上的浪费，本来直接在Form集合中，却遍历了QueryString,Form,Cookies等集合才取出来。

ps:在计算机的世界里，凡是提供服务的一方我们称为伺服端（server），而接受服务的另一方我们称作客户端（client）。

原文地址：http://www.cnblogs.com/angelfeather/archive/2008/02/02/1062168.html

1. Get(即使用QueryString显式传递)
     方式：在url后面跟参数。
     特点：简单、方便。
     缺点：字符串长度最长为255个字符；数据泄漏在url中。
     适用数据：简单、少量、关键的数据。
     适用范围：传递给自己、传递给另一个目标页面；常用于2个页面间传递数据。
     用法：例如：url后加?UserID=…，跳转到目标页面，目标页面在伺服端可用Request.QueryString["InputText"]获取其指定参数值。

2. Post
     方式：通用的方式。利用form提交。
     特点：最常用的方法。常用技巧是把隐秘的数据存在隐藏域中由form提交。
     适用数据：大量数据，包括文件上传。
     适用范围：同Get方法
     用法：在客户端form指定action目标后submit、在asp.net的伺服端中使用server.Transfer(url)提交；在伺服端中用Request.Form["FormFieldID"]获取。

3. 页面对象的属性
     方式：asp.net特有方式。利用HttpContext获取发请求的页面的信息。
     特点：可以直接存储对象。
     缺点：注意强制转换的类型要正确。
     适用数据：各种数据。
     适用范围：页面之间传递复杂数据。
     用法：获取Context.Handler将其转换为发请求的页面的实例，随后就可以轻松访问其form中的字段、甚至属性。其中的Context是指HttpContext对象，Handler是其属性，Context.Handler的意思可以理解为创建源页类的实例变量，而得到此实例之后，就可以直接访问其中的属性和Public方法了。

4. cookie
     方式：将数据存在客户端的经典方法。
     缺点：安全性低、受客户端设置限制、一个站点仅存20个cookie，每个容量4096字节。
     有效期：自定义或被用户清除
     适用数据：用户的会话数据(一般是用户名，用户的个性化设置信息等)
     适用范围：单个用户、整个站点所有页面
     用法：引用Request.Cookies（读取信息）、Response.Cookies（写入信息）、或用HttpCookieCollection直接创建Cookie对象。

5. Session
     方式：将用户数据存储在伺服端。
     特点：asp.net中可以设置session的存储方式、位置、SessionID的保存是否依赖cookie。
             可以直接存储对象。
     缺点：asp.net中有失效的隐患
     有效期：用户活动时间+自定义延迟。
     适用数据：用户的特有信息。
     适用范围：单个用户、整个站点所有页面。
     用法：Session["CollectionName"] = value/object;

6. Cache
     方式：将用户数据存储在伺服端数据缓存中。
     特点：可以大大提高效率。可以直接存储对象。
     缺点：数据更新不及时。
     有效期：应用程序生命周期或自定义。
     适用数据：所有页面、所有用户都可以共享的数据。
     用法：Cache["CollectionName"] = value|object;

7. Appliction
     方式：将数据存储于此,相当于全局变量。
     特点：可以直接存储对象。整个站点的共享数据。
     有效期：应用程序生命周期。
     适用数据：所有页面、所有用户共享的数据。
     用法：Appliction["CollectionName"] = value|object;

8. ViewState
     方式：asp.net特有机制，用来恢复页面状态。
     特点：将页面各控件及其所存数据序列化存在name为_ViewState的隐藏域中。
     缺点：存在HTML中，安全性较低。可以设置加密和验证，但数据量会大增、效率有影响。
     适用数据：页面PostBack需要保存的数据，数据太大会影响页面发送效率。
     适用范围：页面自身数据保存。
     用法：ViewState["CollectionName"] = value；

9. Static
     方式：将数据存于静态变量中。
     特点：利于提高效率。
     缺点：若用不好会致使用户或页面间数据紊乱，造成极大的隐患。建议只赋值一次，绝对禁止为单个用户而更改此值。
     适用数据：所有用户共享的数据。
     适用范围：此类所有的页面实例。
     用法：在class中声明静态变量。

整理：
     页面自身保存数据可用的有ViewState,static变量。
     页面之间传递数据常用get,post,HttpContext,当然可以变通一下用于自身数据保存。
     单用户的所有页面数据共享常用session,cookie,当然也可以应用在以上两种情况。
     整个应用程序(所有用户所用页面)的数据共享常用Appliction,cache,static变量。

总结：
     当然可以变通下灵活应用来解决问题，但是要选择合适的，常见到滥用Get和Session。
     建议在用Request的时候要指明所取的集合，比如Get方法传来的参数从QueryString集合取,Post的从Form取，cookie从Cookies里取。虽然用Request[]集合，以上几种都可以取到，但是却造成性能上的浪费，本来直接在Form集合中，却遍历了QueryString,Form,Cookies等集合才取出来。

ps:在计算机的世界里，凡是提供服务的一方我们称为伺服端（server），而接受服务的另一方我们称作客户端（client）。

C#设计模式之： Observer （观察者模式）

一线风 — 2008-1-31 14:55:58

观察者模式（Observer）完美的将观察者和被观察的对象分离开。举个例子，用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上。面向对象设计的一个原则是：系统中的每个类将重点放在某一个功能上，而不是其他方面。一个对象只做一件事情，并且将他做好。观察者模式在模块之间划定了清晰的界限，提高了应用程序的可维护性和重用性。

观察者模式有很多实现方式，从根本上说，该模式必须包含两个角色：观察者和被观察对象。在刚才的例子中，业务数据是被观察对象，用户界面是观察者。观察者和被观察者之间存在“观察”的逻辑关联，当被观察者发生改变的时候，观察者就会观察到这样的变化，并且做出相应的响应。如果在用户界面、业务数据之间使用这样的观察过程，可以确保界面和数据之间划清界限，假定应用程序的需求发生变化，需要修改界面的表现，只需要重新构建一个用户界面，业务数据不需要发生变化。

“观察”不是“直接调用”

实现观察者模式的时候要注意，观察者和被观察对象之间的互动关系不能体现成类之间的直接调用，否则就将使观察者和被观察对象之间紧密的耦合起来，从根本上违反面向对象的设计的原则。无论是观察者“观察”观察对象，还是被观察者将自己的改变“通知”观察者，都不应该直接调用。

实现观察者模式的例子

实现观察者模式有很多形式，比较直观的一种是使用一种“注册——通知——撤销注册”的形式。下面的三个图详细的描述了这样一种过程：

1：观察者（Observer）将自己注册到被观察对象（Subject）中，被观察对象将观察者存放在一个容器（Container）里。

2：被观察对象发生了某种变化（如图中的SomeChange），从容器中得到所有注册过的观察者，将变化通知观察者。

3：观察者告诉被观察者要撤销观察，被观察者从容器中将观察者去除。

观察者将自己注册到被观察者的容器中时，被观察者不应该过问观察者的具体类型，而是应该使用观察者的接口。这样的优点是：假定程序中还有别的观察者，那么只要这个观察者也是相同的接口实现即可。一个被观察者可以对应多个观察者，当被观察者发生变化的时候，他可以将消息一一通知给所有的观察者。基于接口，而不是具体的实现——这一点为程序提供了更大的灵活性。

使用C#实现观察者模式的例子

//“观察者”接口
public interface IObserver {
void Notify(object anObject);
}
//“被观察对象”接口
public interface IObservable {
void Register(IObserver anObserver);
void UnRegister(IObserver anObserver);
}

观察者和被观察对象都分别从这两个接口实现，所有的操作都是由这两个接口定义的，而不是具体的实现。所以观察者和被观察对象没有绑定在一起。我们可以方便的更改观察者和被观察对象的任意部分而不影响其他部分。

下面实现具体的被观察对象。下面的类是所有被观察对象的基类，实现了所有被观察对象都必须的方法。我们使用一个Hashtable作为观察者的容器

C#代码

//所有被观察对象的基类
public class ObservableImpl : IObservable {
//保存观察对象的容器
protected Hashtable _observerContainer = new Hashtable();
//注册观察者
public void Register(IObserver anObserver){
_observerContainer.Add(anObserver,anObserver);
}
//撤销注册
public void UnRegister(IObserver anObserver){
_observerContainer.Remove(anObserver);
}
//将事件通知观察者
public void NotifyObservers(object anObject) {
//枚举容器中的观察者，将事件一一通知给他们
foreach(IObserver anObserver in _observerContainer.Keys) {
anObserver.Notify(anObject);
}
}
}

上面的类不是最终要实现的被观察对象，而是所有被观察者的基类，其中实现了所有观察对象共有的功能。这个类可以干脆定义为abstract，使得程序员不可以创建其实例。接口以及实现这个接口的虚类既保持了类之间松散的耦合，又使多个具体实现可以使用相同的功能。

最终实现观察者模式，使用用户界面——业务数据作为例子

//业务数据（被观察对象）
public class SomeData : ObservableImpl {
//被观察者中的数据
float m_fSomeValue;
//改变数据的属性
public float SomeValue {
set {
m_fSomeValue = value;
base.NotifyObservers(m_fSomeValue);//将改变的消息通知观察者
}
}
}
//用户界面（观察者）
public class SomeKindOfUI : IObserver {
public void Notify(object anObject){
Console.WriteLine("The new value is:" + anObject);
}
}
//实际调用的过程
public class MainClass{
public static void Main() {
//创建观察者和被观察者
SomeKindOfUI ui = new SomeKindOfUI();
SomeData data = new SomeData();
//在被观察对象中注册观察者
data.Register(ui);
//改变被观察对象中的数据，这时被观察者会通知观察者
data.SomeValue = 1000f;
//注销观察者，停止观察
stock.UnRegister(stockDisplay);
}
}

.NET中更好的实现方式

上面的形式是我们用一种最基本的方式实现了观察者模式，我们为观察者模式开发了一种特定的类型。在.NET框架中，使用代理以及事件，可以更好的实现观察者模式。C#中代理和事件的介绍可以看这一篇文章：在C#中使用代理的方式触发事件，里面有对代理和事件的详细描述，还有例程，这里就不多说了。在.NET支持的其他语言中也有各自的实现方式。

在事件的模式下，声明事件的类就是被观察者。被观察者不需要实现对观察者的注册，只需要公开一个事件，而不实行任何操作。被观察者也不需要将自己注册到观察对象中，而是要创建一个特定的代理的实例，将这个代理绑定到某个方法上。用这样的方式注册或者撤销观察者对观察对象的观察。仔细研究代理和事件的模式就不难发现，IObserver和IObservable接口的方法可以减少观察者和观察对象之间的耦合，而代理和事件几乎消除了这两个模块之间的耦合，灵活性提高了很多。

以上文章来自：http://www.cnblogs.com/lane_cn/articles/73240.html

在C#.Net中，观察者模式就是对事件委托的完美应用。

C#代码

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace Observer
{
///
/// Observer 观察者模式入口 .这个才是一个真正的有效的产品。由三个对象构成：烧水品，报警器，显示器
///
class Program
{
static void Main(string[] args)
{
Heater heater = new Heater();
Alarm alarm = new Alarm();
heater.BoilEvent += alarm.Alert; //注册方法
heater.BoilEvent += new Alarm().Alert; ////给匿名对象注册方法
heater.BoilEvent += Display.Show; //注册静态方法
heater.BoilWater(); //烧水，会自动调用注册过对象的方法
Console.ReadLine();
}
}
#region 热水品成品，由三个部件组成一个有效产品
///
/// 热水器
///
class Heater
{
private int temperature; //当前水温
public delegate void BoilHandler(int t); //委托
public event BoilHandler BoilEvent; //事件
public Heater() { }
///
/// 烧水的过程
///
public void BoilWater()
{
for (int i = 0; i <= 100; i++)
{
Thread.Sleep(50); //摸拟烧水耗时,没到设定值时没有动劲
temperature = i;
if (temperature > 92)
{
Thread.Sleep(1500); //为了显示明显，增加耗时
if (BoilEvent != null) //如果有对象注册
{
BoilEvent(temperature); //调用所有注册对象的方法
}
}
}
}
}
///
/// 报警器
///
class Alarm
{
public Alarm() { }
public void Alert(int temperature)
{
Console.WriteLine("Alarm:嘀嘀嘀，水温已经{0}度了。",temperature);
}
}
///
/// 显示器
///
class Display
{
private Display() { }
public static void Show(int temperature)
{
Console.WriteLine("Display:注意，水温{0}度。", temperature);
}
}
#endregion
}

下面这个是我写的，应该是没有错

C#代码

using System;
using System.Collections.Generic;
using System.Text;
namespace Observer
{
///
/// Blog 类
///
public class Blog
{
public Blog() { }
# region Blog类的 OnSaved事件设定
public delegate void SavedEventHandler(object sender, BlogEventArgs e);
public event SavedEventHandler OnSaved;
protected virtual void OnSavedEvent(BlogEventArgs e)
{
if (OnSaved != null)
{
OnSaved(this, e);
}
}
#endregion
public void Save()
{
Console.WriteLine("保存成功！");
OnSavedEvent(new BlogEventArgs(401)); //发生保存后的事件
}
}
///
/// 日志事件数据传递类
///
public class BlogEventArgs :EventArgs
{
public readonly int blogId;
public BlogEventArgs(int blogId)
{
this.blogId = blogId;
}
}
///
/// 分类类
///
public class Sort
{
public Sort() { }
public void UpdateSortCount(object sender, BlogEventArgs e)
{
Console.WriteLine("this is blogId:{0}", e.blogId);
}
}
///
/// 应用程序入口
/// 总结：
/// 1. 定的义事件一定要在相应的方法内触发；
/// 2. 别的类里的方法要在相应的方法执行前挂接到事件上。
///
public class Door
{
public static void Main()
{
Blog blog = new Blog();
blog.OnSaved += new Sort().UpdateSortCount; //调用别的类里的方法，多个方法直接+=
blog.Save();
Console.ReadLine();
}
}
}

C#设计模式之：Singleton（单例模式）

一线风 — 2008-1-31 10:25:19

场景

我们现在要做一个网络游戏的服务端程序，需要考虑怎么样才能承载大量的用户。在做WEB程序的时候有各种负载均衡的方案，不管是通过硬件实现还是软件实现，基本的思想就是有一个统一的入口，然后由它来分配用户到各个服务器上去。

需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入了Singleton模式来实现这个唯一的入口。

无废话C#设计模式之二：Singleton

原文地址：http://www.cnblogs.com/lovecherry/archive/2007/10/05/914653.html

意图

保证一个类只有一个实例，并提供访问它的全局访问点。

场景

需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入了Singleton模式来实现这个唯一的入口。

C#代码

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace Singleton
{
///
/// 入口类
///
class Program
{
static void Main(string[] args)
{
ParameterizedThreadStart ts = new ParameterizedThreadStart(EnterPlayer);
//20个玩家会平均分配到不同的服务器上，如果用户过多就要增加服务器的数量了
for (int i = 0; i < 20; i++)
{
Thread t = new Thread(ts);
t.Start(string.Concat("player_",i));
}
LoadBalanceServer.GetLoadBalanceServer().ShowServerInfo(); //显示玩家信息
Console.ReadLine();
}
///
/// 玩家进入，由负载均衡服务器分配至相应大厅
///
///
static void EnterPlayer(object playerName)
{
LoadBalanceServer loadBalanceServer = LoadBalanceServer.GetLoadBalanceServer(); //获取入口，即负载均衡服务器入口
loadBalanceServer.GetLobbyServer().EnterPlayer(playerName.ToString()); //入口，分配玩家至游戏服务大厅
}
}
#region LoadBalanceServer 负载均衡服务器类单件类
///
/// 负载均衡服务器，实现了Singleton模式
///
class LoadBalanceServer
{
private const int SERVER_COUNT = 3; //大厅服务器数量定义
private List _lobbyList = new List(); //大厅服务器集合
//volatile关键字可以保证对特殊地址的稳定访问，每次都从原始内存中读取，而不进行优化处理
private static volatile LoadBalanceServer loadBalanceServer; //懒汉模式[载入类时不实例化单件，使用时才实例化单件，饿汉相反]
private static object syncLock = new object(); //线程锁
///
/// 禁止实例化的构造，载入类时，创建大厅服务器集合
///
private LoadBalanceServer()
{
for (int i = 0; i < SERVER_COUNT; i++)
{
_lobbyList.Add(new LobbyServer(string.Concat("LobbyServer",i)));
}
}
///
/// 获取单件实例，双重锁定方式实现
///
///
public static LoadBalanceServer GetLoadBalanceServer()
{
if (loadBalanceServer == null)
{
lock (syncLock)
{
if (loadBalanceServer == null)
{
Thread.Sleep(100); //模拟高并发的情况，在正式代码中没有必要这样做
loadBalanceServer = new LoadBalanceServer(); //创建自已，反身关联
}
}
}
return loadBalanceServer;
}
///
/// 返回一个压力最小的LobbyServer对象
///
///
public LobbyServer GetLobbyServer()
{
LobbyServer lobbyServer = _lobbyList[0]; //默认大厅定义第一台服务器
for (int i = 1; i < SERVER_COUNT; i++)
{
if (_lobbyList[i].PlayList.Count < lobbyServer.PlayList.Count)
{
lobbyServer = _lobbyList[i];
}
}
return lobbyServer;
}
///
/// 显示所有服务器大厅及玩家信息
///
public void ShowServerInfo()
{
foreach (LobbyServer ls in _lobbyList)
{
Console.WriteLine(string.Concat("==============", ls.LobbyName, "=============="));
foreach (string player in ls.PlayList)
{
Console.WriteLine(player);
}
}
}
}
#endregion
#region LobbyServer 服务大厅类，非静态类，必须实例化后使用
///
/// 服务大厅。每一台服务器有一个服务大厅，即本服务器的入口。
///
class LobbyServer
{
private List<string> _playList = new List<string>(); //玩家集合
private string _lobbyName; //大厅名称(即游戏服务器名)，唯一标识
///
/// 默认构造
///
///
public LobbyServer(string lobbyName)
{
_lobbyName = lobbyName;
}
///
/// 玩家加入
///
///
public void EnterPlayer(string playerName)
{
_playList.Add(playerName);
}
public string LobbyName
{
get {return _lobbyName ; }
}
public List<string> PlayList
{
get { return _playList; }
}
}
#endregion
}

代码说明

l LoadBalanceServer类实现了Singleton模式，也就是说无论在什么情况下，只会有一个LoadBalanceServer类的实例出现。

l LobbyServer类表示大厅服务，用户进入大厅后和大厅服务进行服务，在这里我们仅仅在大厅服务里面保存了用户列表。

l Singleton模式有很多实现方式，在这里使用的是双重锁定方式。对于C#来说，可能使用静态初始化方式是最简洁的，这里就不演示了。

l LoadBalanceServer类的GetLobbyServer()方法负责返回一个压力最小的LobbyServer对象。

l 实例化LoadBalanceServer的时候Sleep了线程，目的是模拟高并发的情况，在正式代码中没有必要这样做。

何时采用

l 从代码角度来说，当你希望类只有一个实例的时候。

l 从应用角度来说，你希望有一个总管来负责某一件事情。并且这件事情的分配只能有一个人进行，如果有多个人进行肯定会弄乱。比如创建处理流水号如果有两个地方在创建的话是不是就会重复了呢？

实现要点

l 一个Singleton类，它能确保自身的实例是唯一的。

注意事项

l 不要滥用Singleton模式，只有非一个实例不可的情况下才考虑引入Singleton。否则，程序的可扩展性可能会受到限制。

-----------------------------------------------------------
1. 整个系统中存在一个实例
2. 在系统的任何角落都可以访问它
(在一个系统中往往只有一个工厂，这样我们可以引入单件模式来解决这个问题。 )

设计模式－开篇－.NET中的一些常用设计模式：索引

一线风 — 2008-1-30 11:12:46

Singleton Pattern （单例模式）

Oberver Pattern （观察者模式）委托和事件的应用

C#设计模式之：总结(针对GOF23)

开篇

Singleton Pattern （单例模式）

Oberver Pattern （观察者模式）委托和事件的应用

Factory Method：IHttpHandlerFactory

Adapter Pattern：COM Interop、DataAdapter

Decorator Pattern：BufferedStream、CryptoStream

Composite Pattern：Enterprise Library2.0中的ObjectBuilder

Facade Pattern：Duwamish

Flyweight Pattern：.NET中的String类型

Template Method：服务器控件

Command Pattern：MVC

Iterator Pattern：IEnumerator

Strategy Patterm：System.Configuration.Provider、IComparer

C#设计模式之：总结(针对GOF23)

System.Diagnostics命名空间里的Debug类和Trace类的用途

一线风 — 2007-12-3 16:04:11

在 .NET 类库中有一个 System.Diagnostics 命名空间，该命名空间提供了一些与系统进程、事件日志、和性能计数器进行交互的类库。当中包括了两个对开发人员而言十分有用的类——Debug类和Trace类。本文介绍了这两个类的一些基本用途，旨在提高广大开发人员的开发效率。
使用Debug类来帮助调试

调试程序对每个程序员来说是家常便饭。可是我们会经常遇到一些情况让我们头疼，例如：

当我们在开发一个界面控件的时候，简单的设断点会增加Paint事件的响应次数，而造成的环境参数改变。
断点设多了，程序常常停在正常运行的地方；这样一来，调试一个错误要花费大量时间去寻找错误。
这时，我们就需要利用System.Diagnostics.Debug类来帮助我们调试。我们可以通过调用Debug.WriteLine(String message)函数，将我们所关心的信息打印在Visual Studio IDE的Output窗口中。也可以利用Debug.Assert(bool condition)来让程序停在错误的地方，并且显示Call stack。

Debug类中所有函数的调用都不会在Release版本里有效。也就是说，我们通过这种方法所加的代码可以仅用于调试；在发布的时候无需删任何代码，就可以给用户一个没有调试指令的程序了。
在 .NET 类库中有一个 System.Diagnostics 命名空间，该命名空间提供了一些与系统进程、事件日志、和性能计数器进行交互的类库。当中包括了两个对开发人员而言十分有用的类——Debug类和Trace类。本文介绍了这两个类的一些基本用途，旨在提高广大开发人员的开发效率。
使用Debug类来帮助调试

调试程序对每个程序员来说是家常便饭。可是我们会经常遇到一些情况让我们头疼，例如：

Debug类中所有函数的调用都不会在Release版本里有效。也就是说，我们通过这种方法所加的代码可以仅用于调试；在发布的时候无需删任何代码，就可以给用户一个没有调试指令的程序了。

下面的这个例子演示了这两个函数来帮助调试的方法：

1、新建一个Visual Studio C# Project，采用默认的项目名。

2、往Form1上拖一个label，并采用其缺省ID。

3、在Form1.cs中的Form1类中添加下面的函数代码：

private int time=0;
protected override void OnPaint(PaintEventArgs e)
{
time++;
this.label1.Text="OnPain called "+time.ToString()+" Times.";
}

protected override void OnResize(EventArgs e)
{
System.Diagnostics.Debug.Assert(this.Width>200,"Width should be larger than 200.");
System.Diagnostics.Debug.WriteLine(Size.ToString());
}

4、编译并运行项目的Debug版本。

5、切换Visual Studio .NET IDE到Output窗口。

6、切换到刚才的程序，改变主窗口的大小，您可以在IDE中看到Form1窗口的实时大小，并在Form1上看到OnPaint被调用的次数。当窗口的宽度小于等于200个像素的时候，系统会弹出一个Assertion Fail的对话框。里面显示了当前程序的Call Stack。如果您在OnPaint中设置了断点，想要调试程序的话，那么您会进入一个死循环，直到您停止调试。

Debug类和Trace类的区别

您一定发现了在System.Diagnostics命名空间中还有一个名为Trace的类。它的函数功能和Debug非常相似。为什么要有这样两个功能类似的类呢？

原因是这样的，Debug类里所提供的函数仅在编译时带#Debug宏参数才奏效，一旦到了Release版本中，这些函数都会被忽略。也就是说Debug类的功能仅在程序员开发的时候能用。而Trace则不同，它能在Release版本的程序中也被运行，这样程序员就可以在Release版本的程序中添加一些Debug类提供的功能了。

使用Trace类来做程序日志

接下来的问题就是：我们程序员能利用Trace类的功能做些什么呢？我们可以用它来做程序的日志。

1、打开刚刚的project。

2、用下面的代码覆盖刚才第2步的代码：

private void Calculate()
{
int a=1,b=1;
try
{
System.Random r = new Random();
while (true)
{
a=(int)(r.NextDouble()*10);
b=(int)(r.NextDouble()*10);
System.Diagnostics.Trace.WriteLine(System.DateTime.Now.ToString()+": "+
a.ToString()+"/"+b.ToString()+"="+(a/b).ToString());
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(System.DateTime.Now.ToString()+": "+a.ToString()+
"/"+b.ToString()+"="+" ERROR: "+ex.Message);
MessageBox.Show(ex.Message);
}
}

3、在构造函数Form1()的最后添加下面的代码，将Trace的输出重定向到app.log文件中：

System.Diagnostics.Trace.Listeners.Clear();
System.Diagnostics.Trace.AutoFlush=true;
System.Diagnostics.Trace.Listeners.Add(new System.Diagnostics.TextWriterTraceListener("app.log"));

4、拖一个按钮到该Form上，双击按钮，在button1_Click函数中添加如下代码：

Calculate();
Application.Exit();

5、运行该程序的Release版本，点击添加的按钮，程序便开始执行一位随机数除法。由于是随机数，可能会出现出数为0的情况，这样程序就会抛出Exception，这是程序会自动中止。

6、在该程序所在的目录里您可以发现出现了一个新的文件app.log，里面记录了各个时刻的运算纪录，并把Exception纪录在日志中。

小结

利用 System.Diagnostics.Debug 类和 System.Diagnostics.Trace 类可以帮助程序员方便地进行调试程序并检测程序运行情况。

Debug类的所有调用仅在程序的Debug版本中有效；而Trace类的调用能在Release版本和Debug版本中都有效。

asp.net 线程休眠会不会消耗CPU

一线风 — 2007-10-19 10:07:29

在ASP里执行1000W次For循环大约是5.2X秒的时间（CPU消耗为方波）
在ASP.Net里执行1000W次的For循环大约是300毫秒左右（CPU消耗为尖波）
在ASP.net里执地6000毫秒的休眠，执行的时间为5秒钟，（CPU消耗看不出来）

－－－－－－－－－－－－－
Dim t1
t1 = timer()

Call test()
在ASP里执行1000W次For循环大约是5.2X秒的时间（CPU消耗为方波）
在ASP.Net里执行1000W次的For循环大约是300毫秒左右（CPU消耗为尖波）
在ASP.net里执地6000毫秒的休眠，执行的时间为5秒钟，（CPU消耗看不出来）

－－－－－－－－－－－－－
Dim t1
t1 = timer()

Call test()

Response.write timer() - t1

Function test()

For i = 0 To 10000000
Response.write ""
Next

End Function

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

using System.Threading;

namespace Test.Web
{
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
DateTime dt1 = DateTime.Now;

//for (int i = 0; i < 100000000; i++)
//{

// Response.Write("");

//}

Thread.Sleep(6000);

TimeSpan ts = DateTime.Now - dt1;
Response.Write(ts.Seconds.ToString());
}
}
}

结论：仁人仁智

通过对DNT的源码分析深化自己的面向对象开发思维

一线风 — 2007-9-18 10:17:57

DNT是discuz的又一"力作",前些时间还发布了源代码,为向"开源"迈进踏出坚实的一步.通过仔细阅读它的源代码,分析整个项目的结构,可以令人思维能力上升到一个新的高度.下面我们就来解剖一下这个"力作"吧

使用visual studio 2005打开工程.出现在我们眼前的结构令人顿时有庞然大物扑面而来之感.花了不少时间适应了它的"结构",就想先来看看Common里有什么吧.由于篇幅有限,我们就只挑了一两个地方出来和大家共赏了

首先,从结构上来看,它把一众输入输出的操作封装到Common里,例如Request,它给我最大的感觉就是HttpContext无处不在.这就好象你封装了一个类,然后又在类的内部使用类外部的变量/方法等等.大家觉得这种封装有意义么.由这个地方,我们可以深切地感受到如何创建一个有意义的类,如何设计你的类使它具有良好的输入输出接口并有绝对的外界无关性.这是一个很好的反面例子.

接着我们再来看Utils类,咋一看此类内容,我恍惚以为自己在看asp程序代码,封装了一大堆对字符串的操作等等,美其名曰:工具类.当然,这个类里还是少不了HttpContext的.呵呵
在这里,我们又学到了一样东西,不能归为一个物体拥有的方法或属性千万不要强归在一起并拼凑出一个也许并不存在的物体

打开XmlWriter.cs,一开始我还以为和我朋友一样,因为XmlDocument的性能较低,所以选择了自己封装Xml操作对象呢.一看才知道是为了其他目的封装了一个大杂烩,其中既有一个内部的XmlDocument实例,又有其他毫无关联的属性和方法.更有甚者,它又定义了一些类似XmlDocument对象自身方法的方法,例如AppendChildElement等,在这些方法里又有传递XmlDocument对象参数.伟大的先辈们教育我们:要扩展一类物体功能,不能以改变物体来达到目的,所以我们需要继承
DNT是discuz的又一"力作",前些时间还发布了源代码,为向"开源"迈进踏出坚实的一步.通过仔细阅读它的源代码,分析整个项目的结构,可以令人思维能力上升到一个新的高度.下面我们就来解剖一下这个"力作"吧

由于时间的关系,就先这么多吧,至于其他的string to int不知道用int自身方法
甚至还到处使用new Regex这些就不说了.分析到这里我已经有了80%的asp意味
唉,由此可见,能吹牛往往比能学习的更吸引别人注意的.

有关.NET中序列化的一些知识

一线风 — 2007-9-12 16:06:22

“序列化”可被定义为将对象的状态存储到存储媒介中的过程。在此过程中，对象的公共字段和私有字段以及类的名称（包括包含该类的程序集）都被转换为字节流，然后写入数据流。在以后“反序列化”该对象时，创建原始对象的精确复本。
一、为什么要选择序列化
一个原因是将对象的状态保持在存储媒体中，以便可以在以后重新创建精确的副本；
另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。
例如，序列化可用于在 ASP.NET 中保存会话状态并将对象复制到 Windows 窗体的剪贴板中。远程处理还可以使用序列化通过值将对象从一个应用程序域传递到另一个应用程序域中。
二、如何实现对象的序列化及反序列化
要实现对象的序列化，首先要保证该对象可以序列化。而且，序列化只是将对象的属性进行有效的保存，对于对象的一些方法则无法实现序列化的。
实现一个类可序列化的最简便的方法就是增加Serializable属性标记类。如：
[Serializable()]
public class MEABlock
{
private int m_ID;
public string Caption;

public MEABlock()
{
///构造函数
}
}
即可实现该类的可序列化。
要将该类的实例序列化为到文件中？.NET FrameWork提供了两种方法：
1、XML序列化
使用 XmLSerializer 类，可将下列项序列化。

公共类的公共读／写属性和字段
实现 ICollection 或 IEnumerable 的类。（注意只有集合会被序列化，而公共属性却不会。）
XmlElement 对象。
XmlNode 对象。
DataSet 对象。
要实现上述类的实例的序列化，可参照如下例子：
MEABlock myBlock = new MEABlock();
// Insert code to set properties and fields of the object.
XmlSerializer mySerializer = new XmlSerializer(typeof(MEABlock));
// To write to a file, create a StreamWriter object.
StreamWriter myWriter = new StreamWriter("myFileName.xml");
mySerializer.Serialize(myWriter, MEABlock);
需要注意的是XML序列化只会将public的字段保存，对于私有字段不予于保存。
生成的XML文件格式如下：

Test

对于对象的反序列化，则如下：
MEABlock myBlock;
// Constructs an instance of the XmlSerializer with the type
// of object that is being deserialized.
XmlSerializer mySerializer = new XmlSerializer(typeof(MEABlock));
// To read the file, creates a FileStream.
FileStream myFileStream = new FileStream("myFileName.xml", FileMode.Open);
// Calls the Deserialize method and casts to the object type.
myBlock = (MEABlock)mySerializer.Deserialize(myFileStream)
2、二进制序列化
与XML序列化不同的是，二进制序列化可以将类的实例中所有字段（包括私有和公有）都进行序列化操作。这就更方便、更准确的还原了对象的副本。
要实现上述类的实例的序列化，可参照如下例子：
MEABlock myBlock = new MEABlock();
// Insert code to set properties and fields of the object.
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin",FileMode.Create,FileAccess.Write, FileShare.None);
formatter.Serialize(stream, myBlock);
stream.Close();
对于对象的反序列化，则如下：
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin", FileMode.Open,FileAccess.Read, FileShare.Read);
MEABlock myBlock = (MEABlock) formatter.Deserialize(stream);
stream.Close();

三、如何变相实现自定义可视化控件的序列化、反序列化
对于WinForm中自定义控件，由于继承于System.Windows.Form类，而Form类又是从MarshalByRefObject继承的，窗体本身无法做到序列化，窗体的实现基于Win32下GUI资源，不能脱离当前上下文存在。
当然可以采用变通的方法实现控件的序列化。这里采用的是记忆类模型。
定义记忆类（其实就是一个可序列化的实体类）用于记录控件的有效属性，需要序列化控件的时候，只需要将该控件的实例Copy到记忆类，演变成序列化保存该记忆类的操作。
反序列化是一个逆过程。将数据流反序列化成为该记忆类，再根据该记忆类的属性生成控件实例。而对于控件的一些事件、方法则可以继续使用。

Asp.Net Forums中对.Net中序列化和反序列化的应用

一线风 — 2007-9-12 15:42:46

在Forums中，有些内容是不固定的，例如用户资料，除了一些基本资料，可能还要有一些其他资料信息，例如MSN、个人主页、签名档等，一般对于这样的都是每一个属性对应于数据库中的一个字段。但是如果以后我们因为需要增加一些属性，例如QQ号、Blog地址等，如果还是用这种增加数据表字段的方法，那么将会频繁的修改数据库表结构、存储过程、数据库访问的程序。

或许您也遇到过类似问题，看Forums中是怎么借用.Net的序列化和反序列化来解决的：
例如我需要在用户资料里面增加QQ号这个属性，那么我只需要在User类中增加一个属性
public String QQIM
{
get { return GetExtendedAttribute("QQIM"); }
set { SetExtendedAttribute("QQIM", value); }
}
不需要修改数据库表结构，不需要修改存储过程，连数据库访问的程序都不需要动。
在Forums中，有些内容是不固定的，例如用户资料，除了一些基本资料，可能还要有一些其他资料信息，例如MSN、个人主页、签名档等，一般对于这样的都是每一个属性对应于数据库中的一个字段。但是如果以后我们因为需要增加一些属性，例如QQ号、Blog地址等，如果还是用这种增加数据表字段的方法，那么将会频繁的修改数据库表结构、存储过程、数据库访问的程序。

其具体实现的主要代码：

// 首先新建在User类中新建一个NameValueCollection对象，将这些扩展属性都保存在NameValueCollection对象中
NameValueCollection extendedAttributes = new NameValueCollection();

// 从NameValueCollection集合中取纪录
public string GetExtendedAttribute(string name)
{
string returnValue = extendedAttributes[name];

if (returnValue == null)
return string.Empty;
else
return returnValue;
}

// 设置扩展属性的在NameValueCollection中的键值和值
public void SetExtendedAttribute(string name, string value)
{
extendedAttributes[name] = value;
}

// 将extendedAttributes对象（前面定义的用来保存所有的用户扩展信息的NameValueCollection对象）序列化为内存流
// 可以用来保存到数据库中
public byte[] SerializeExtendedAttributes()
{

// 序列化对象
BinaryFormatter binaryFormatter = new BinaryFormatter();

// 创建一个内存流，序列化后保存在其中
MemoryStream ms = new MemoryStream();
byte[] b;

// 将extendedAttributes对象（里面保存了所有的用户扩展信息）序列化为内存流
//
binaryFormatter.Serialize(ms, extendedAttributes);

// 设置内存流的起始位置
//
ms.Position = 0;

// 读入到 byte 数组
//
b = new Byte[ms.Length];
ms.Read(b, 0, b.Length);
ms.Close();

return b;
}

// 反序列化extendedAttributes对象的内容
// 从数据库中读取出来的
public void DeserializeExtendedAttributes(byte[] serializedExtendedAttributes)
{

if (serializedExtendedAttributes.Length == 0)
return;
try
{

BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream ms = new MemoryStream();

// 将 byte 数组到内存流
//
ms.Write(serializedExtendedAttributes, 0, serializedExtendedAttributes.Length);

// 将内存流的位置到最开始位置
//
ms.Position = 0;

// 反序列化成NameValueCollection对象，创建出与原对象完全相同的副本
//
extendedAttributes = (NameValueCollection) binaryFormatter.Deserialize(ms);

ms.Close();
}
catch {}

}
实质上序列化机制是将类的值转化为一个一般的（即连续的）字节流，然后就可以将该流保存到数据库的某个字段中（在数据库中forums_UserProfile表中有一个字段“StringNameValues varbinary(7500)”）。读取的过程对对象进行反序列化时，创建出与原对象完全相同的副本。

注意一般这类属性在数据库中是不能被检索到的，并且要这些属性能被序列化。

更详细内容请查阅MSDN和Asp.Net Forums源码

Interface是一种契约, abstract class是事物本质的抽象概括

一线风 — 2007-8-31 16:27:21

Interface是一种契约, abstract class是事物本质的抽象概括

由以上两点, 什么时候用Interface什么时候用abstract class有看你如何理解你的设计对象, 例如, 某一天你可能会要设计一个Door的类, 它有Open和Close两个功能, 于是

public interface Door
{
void Open();//只能定义其标签，不可以带函数的实现
void Close();
}

public abstract class Door
{
void Open(){};//可以带函数的实现
void Close(){};
}

就目前来说, 你用Interface还是用abstract class基本上没什么区别, 两者都用来描述Door的行为, 只不过用Interface是在强调Door额外的有Open和Close这两个功能, 而用abstract class则是在强调Door自带有Open和Close的能力, 因为他还可以有其它的东西。

走远一点, 假如又有一天, 你要写一个AlarmDoor的类, 这个时候...

public interface AlarmDoor
{
void open();
void close();
void alarm();
}

public abstract class AlarmDoor
{
void open(){};
void close(){};
void alarm(){};
}

现在, 你应该想清楚你究竟是想设计一个报警器还是想设计一扇门, 如果选择Interface, 那你是在想设计一个报警器, 如果选择abstract class, 那你是在想设计一扇门, 说到现在, 是否有点眉目了?

C#里面不允许多个父类, 但却允许多个接口, 接口无非是让某个类拥有某种行为, 而抽象类却是在让某个类拥有某种本质, 因此, 我们设计的类, 应该用一个抽象类把它的所有本质都抽象出来, 而它的一些行为(或者说是契约)则通过Interface来实现, 这也能说明为什么C#会不允许多层父类却允许多层接口

C#/.Net - 艺风在线 - Power By CSZI.com

C#语言的几个层次

子类与父类的小关系：盒子套盒子

C#位运算讲解与示例[转]

VS项目里*.sln和*.suo文件的作用

C# String小技巧

用重复的字符填充一个 String

用重复的字符填充一个 String

检查空字符串

String.Empty vs. ""? 并不重要

反转字符串

字符串比较

转换字符串为数字类型

IndexOf 忽略大小写

本周ASP.NET英文技术文章推荐[03/02 - 03/15]：ASP.NET AJAX、LinqDataSource、ListView、MVC、JavaScript、智能感知、Ext、CAPTCHA

简单自定义实现jQuery验证

C#异步编程

ASp.net中Froms验证方式

VisualStudio 2008 团队套件简体中文正式版+TFS2008英文正式版BT发布

asp.net页面间数据传递(总结篇)

C#设计模式之 ： Observer （观察者模式）

C#设计模式之：Singleton（单例模式）

设计模式－开篇－.NET中的一些常用设计模式： 索引

System.Diagnostics命名空间里的Debug类和Trace类的用途

asp.net 线程休眠会不会消耗CPU

通过对DNT的源码分析深化自己的面向对象开发思维

有关.NET中序列化的一些知识

Asp.Net Forums中对.Net中序列化和反序列化的应用

Interface是一种契约, abstract class是事物本质的抽象概括

VS项目里.sln和.suo文件的作用

C#设计模式之： Observer （观察者模式）

设计模式－开篇－.NET中的一些常用设计模式：索引