博客园-慕容星空小站

最新新闻：
· 9大IT科技公司总部览(2010-03-21 21:00)
· 五个广泛流传的对大龄程序员的误解(2010-03-21 19:51)
· 意大利研发出“移动虚拟校园”技术(2010-03-21 19:33)
· 如果 Facebook 是一个国家，它将是第三大人口国(2010-03-21 17:50)
· 德国公司推出Android平板电脑WePad(2010-03-21 17:43)

关于.NET邮件的收发问题总结(带附件)

ustbwuyi — Mon, 28 May 2007 07:29:00 GMT

阅读: 4632 评论: 22 作者: ustbwuyi 发表于 2007-05-28 15:29 原文链接

最近因为项目需要，研究了一下邮件的发送和接收，发现现在这方面的问题很多.虽然网上这方面的资料很多，但是真正应用起来
仍然会发现不少问题，而且很多人都抱怨书上或者网上的一些代码应用起来是失败的，并且针对附件方面的处理不太完善，针对这种情况我把最近研究所得做一个小小的总结，希望能对大家有所帮助。
首先来谈谈发送邮件的问题。

       发送邮件现在应用得最多的两种情况就是利用.NET自带的发送邮件和利用jmail组件来发送邮件。
       .NET自带的邮件发送利用了System.Web.Mail.MailMessage这个类，这是在VS2003的情况下，在VS2005下更多的是利用System.Net.Mail.MailMessage，下面的例子是在VS2003的情况下写的,请在应用的时候自己替换掉里面的参数。

            string SendTos=SendTo.Text.Trim();　　//发送人
            string CcTos=CcTo.Text.Trim();  　　  //抄送人
            string[] Receiver=System.Text.RegularExpressions.Regex.Split(SendTos+CcTos,",");  //总收件人
            string FromMail="ustbwuyi1@163.com";//发件人
            string Title="你好"; //邮件主题
            string Body="附件里重要文档,请查收!";   //邮件主体
            string ShowName="ustbwuyi";//显示名字

            if(SendTos!="" || CcTos!="")
            {
                //用户名(取发送邮箱的@前面的部分,即ustbwuyi1
                string MailUserName=FromMail.Substring(0,FromMail.IndexOf("@"));

                //密码
                string MailPassword="ustbwuyi";
                System.Web.Mail.MailMessage mailmessage=new MailMessage();
                mailmessage.From=FromMail;
                mailmessage.Subject=Title;
                mailmessage.Body=Body;

                //添加附件

                ArrayList FileNames;
                //如果存在附件
                if(FileNames.Count>=1)
                {
                    //添加附件
                        string Filename;
                        for(int k=0;k<FileNames.Count;k++)
                        {
                            Filename=FileNames[k].ToString();
                            mailmessage.Attachments.Add(new MailAttachment(Filename));
                        }
                    }
                }
                mailmessage.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate",1);
                mailmessage.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername",MailUserName);
                mailmessage.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword",MailPassword);


            //向收件人和抄送人循环发送
                for(int j=0;j<Receiver.Length;j++)
                {
                    mailmessage.To=Receiver[j].ToString();
                    System.Web.Mail.SmtpMail.SmtpServer="smtp.163.com";
                    try
                    {
                        System.Web.Mail.SmtpMail.Send(mailmessage);
                    }
                    catch(Exception ex)
                    {
                        Response.Write("alert('邮件发送失败,请您和ustbwuyi联系(QQ:108556024)！')");
                    }
                }
            }

上面的例子是利用163的SMTP邮件服务器来发送邮件，当然，如果你有自己的邮件服务器更好。

其次，是利用jmail组件来发送，现在jmail组件的版本很多，在这里我个人推荐jmail4.4pro版本，因为如果你要收邮件的话，必须用pro版本，另外，个人经过测试了其它几个版本，发现只有这个版本不会出现附件丢失的情况，其他几个版本都会出现附件丢失或者损坏的情况，这个对txt文件来说没有影响，但是对于传送图片或者其他的一些压缩文件，会发现从pop服务器上下过来的附件有一些损坏，从而不能正常打开文件。下面是jmail发送邮件的代码。

jmail.MessageClass MyMail = new jmail.MessageClass();

            string SendTos=SendTo.Text.Trim();　　//发送人
            string CcTos=CcTo.Text.Trim();  　　  //抄送人
            string[] Receiver=System.Text.RegularExpressions.Regex.Split(SendTos+CcTos,",");  //总收件人
            string FromMail="ustbwuyi1@163.com";//发件人
            string Title="你好"; //邮件主题
            string Body="附件里是重要文档,请查收!";   //邮件主体
            string ShowName="ustbwuyi";//显示名字
            //取email的@前面部分为用户名,即ustbwuyi1,当然也可以自己设置.
            string MailUserName=FromMail.Substring(0,FromMail.IndexOf("@"));
            string MailPassword="ustbwuyi";
            if(SendTos!="" || CcTos!="")
            {

                // 字符集
                MyMail.Charset = "GB2312";
                //附件的编码格式
                MyMail.Encoding = "BASE64";
                ////是否将信头编码成iso-8859-1字符集
                     MyMail.ISOEncodeHeaders = false;
                //发送人邮件地址
                MyMail.From = FromMail;
                //发送人姓名
                MyMail.FromName = ShowName;
                // 邮件主题
                MyMail.Subject =Title;
                     //身份验证的用户名
                MyMail.MailServerUserName = MailUserName;
                //用户密码
                MyMail.MailServerPassWord = MailPassword;
                     //邮件内容
                MyMail.Body = Body;
                ArrayList FileNames;
                    //如果存在附件
                    if(FileNames.Count>=1)
                    {
                        //添加附件
                        string Filename;
                        for(int k=0;k<FileNames.Count;k++)
                        {
                            Filename=FileNames[k].ToString();
                            MyMail.AddAttachment(Filename,false,HttpUtility.UrlDecode(Filename.Substring(Filename.LastIndexOf(".")+1,3)));
                        }
                    }

                try
                {
                    //循环发送
                    for(int i=0;i<Receiver.Length;i++)
                    {
                        MyMail.AddRecipient(Receiver[i],"","");
                        MyMail.Send("Mail.rshi.cn",false);
                    }


                }
                catch(Exception ex)
                {
                Response.Write("alert('邮件发送失败,请您和ustbwuyi联系(QQ:108556024)！')");

                }
            }

好了，现在我们来看看接收邮件的问题。一般来说，接收邮件主要分为两部分，一是将接收到的邮件的信息保存到数据库，如邮件的
主题，内容，发送人，发送时间等。其次是对邮件附件的处理，主要将邮件附件从POP服务器上下载下来并保存到数据库，然后将附件
信息保存到数据库，如附件的路径，附件对应的邮件编号等信息。这一点.NET自带的似乎并不太好处理，没有jmail组件处理方便，
当然关于.NET自带的我并没有深入研究，个人经过比较还是推荐jmail，当然前面说过关于jmail几个版本在这方面的差异，所以个人
还是推荐jmail4.4pro版本。下面是收邮件的代码：

    public void ReceiveMails(string Username)
        {

            jmail.Message Msg=new jmail.Message();
            jmail.POP3 jpop = new jmail.POP3();
            jmail.Attachments atts;
            jmail.Attachment att;

            //username为用户名,该方法通过用户名获取该用户的pop设置,即用户的POP用户名,密码,POP服务器地址以及端口号这四个参数,这四个参数是连接POP服务器的必用参数.
                SqlDataReader dataReader = this.ExtGetSetting(Username);
                if(dataReader.Read())
                {
                    if(dataReader["PopServer"].ToString()!=""&&dataReader["PopUsername"].ToString()!="")
                    {
                        //连接POP服务器
                        jpop.Connect(dataReader["PopUsername"].ToString(),dataReader["PopPassword"].ToString(),dataReader["PopServer"].ToString(),Int32.Parse(dataReader["PopPort"].ToString()));
                        //如果服务器上有邮件
                        if(jpop.Count>=1)
                        {
                         for(int i=1;i<=jpop.Count;i++)
                            {

                                Msg = jpop.Messages[i];
                                atts=Msg.Attachments;

                             //取数据库中邮件信息中的最大发送时间,即最近接收到的一封邮件的时间
                                Database dbase=new Database();
                                DataTable data=dbase.GetDataTable("select max(MailSendDate) as MailSenderDate from TabMailList where MailTypeFlag='1'");

                             //对服务器上的邮件的发送时间和数据库最近一封邮件的时间进行比较,如果大那么证明该邮件还未被收取,是一封新邮件,这样避免重复收取邮件入库
                                if(Msg.Date>Convert.ToDateTime(data.Rows[0][0].ToString()))

                                {
                                    //将这封新邮件的信息保存到数据库
                                    this.SaveExtMail(Msg,Username,dataReader["Email"].ToString(),jpop.GetMessageUID(i));

                                    //获取附件上传到服务器并且将信息存入数据库
                                    if(atts.Count>=1)
                                    {
                                        for(int k=0;k<atts.Count;k++)
                                        {

                                            att=atts[k];//获得附件

                                            string attname=att.Name;
                                            try
                                            {

                                                Random TempNameInt    = new Random();
                                                string NewMailDirName  = TempNameInt.Next(100000000).ToString();
                                                Directory.CreateDirectory(System.Web.HttpContext.Current.Server.MapPath(".")+"\\AttachFiles\\"+Username+"\\"+NewMailDirName);

                                                string mailPath="\\AttachFiles\\"+Username+"\\"+NewMailDirName+"\\"+attname;

                                                att.SaveToFile(System.Web.HttpContext.Current.Server.MapPath(".")+mailPath);

                                                //获取该封邮件在数据库的ID,以便和附件信息相对应,取邮件表中的最大ID即可
                                                int mailID=this.GetMailID();
                                               //将附件信息存入数据库
                                                this.AttExtSend(mailID,attname,att.Size,mailPath,Msg.From);
                                            }
                                            catch(Exception ex)
                                            {
                                                throw new Exception(ex.Message);
                                            }

                                        }
                                    }
                                }
                            }
                        }

                        //删除服务器上的邮件
                        jpop.DeleteMessages();
                        //断开连接
                        jpop.Disconnect();
                    }

            }
        }

至于将邮件信息和附件信息如何存入数据库，就看你自己对表的设计了，我就不多说了，经过上面就可以完全将你ＰＯＰ服务器上的
邮件完全接收到你的本地了。

评论: 22　查看评论　发表评论

C#2.0新特性之泛型与迭代器

ustbwuyi — Thu, 12 Apr 2007 09:43:00 GMT

阅读: 501 评论: 1 作者: ustbwuyi 发表于 2007-04-12 17:43 原文链接

泛型

1、什么是泛型？

　泛型允许你在编译时间实现类型安全。它们允许你创建一个数据结构而不限于特定的数据类型。即通过参数化类型来实现在同一份代码上操作多种数据类型。

泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。

之所以我们称它为泛型，是因为我们在定义的时候，只为它所包含的对象指派了一个类型占位符，而不是将它定义为确定的类型，只有在创建该集合的实例时，才会给它指派一个确定的类型。

2、泛型的优点

我们都知道，泛型是.NET2.0里面新引入的特性，至于泛型的作用，我们都知道，它只是使C#里面的类型免去了相互转换的麻烦和复杂度。而且，我们也知道，.NET是一个单根继承系统，即.NET里面所有的类都是单继承的，一个类不能继承多个类，即一个派生类不能继承多个基类，这一点和C，C++是不同的。另外，在C#里面，所有的类型都可以作为Object来进行传递，也就是说，Object类实际上完全可以实现泛型的功能。既然如此，那么Java和.NET为什么还要引入泛型呢？泛型的引入究竟有什么作用呢？

我们来归纳一下，泛型和非泛型相比，主要有二个优点。

首先，泛型更加安全。为什么这么说呢，虽然所有的类型都可以作为Object来传递，但是在传递的过程中无法避免进行类型转换，而类型转换在运行的时候是不安全的，在某个时候，它和程序的环境配置以及具体的数据有关，比如曾经我碰到的一个问题就是，将string类型转换成int型的时候，用int.parse进行转换，结果在本地运行正常，但是上传到服务器的时候却无法显示网页，结果后来用Convert.ToInt32转化就正常了。在C#中，仅整数就有九种类型，它们的范围各不相同，再加上其他类型，如此多的类型，它们相互之间的转换是存在不安全性的因素的，而泛型的使用避免了不必要的类型转换，从而提高了安全性。

比如，我们来看下面这个例子
Stack myStack=new Stack();

myStack.Push("ustbwuyi");

myStack.Push(4);

Array myArray = myStack.ToArray();

foreach (string item in myArray)

{

label1.Text += item + "
";

}上述的这个例子，我们在编译该函数的时候，程序是不会报错的，而当程序执行的时候，程序才会抱错，这样的话我们很难在编译的时候发现程序中的错误。那么，如果我们用泛型情况又如何呢？

Stack myStack = new Stack();

myStack.Push("ustbwuyi1");

myStack.Push(5);

Array myArray = myStack.ToArray();

foreach (string item in myArray)

{

label1.Text += item + "
";

}

像上面这种情况在编译的时候就会报错，因为创建该泛型的时候就指定了特定类型string。

当然，对于C#和VB.NET来说，在原理上还是有一些区别。比如我来看一个例子。

ArrayList list = new ArrayList();

list.Add(3);

list.Add(4);

list.Add(5.0);

int total = 0;

foreach (int i in list)

{

total = total + i;

}

Response.Write(total);

对于上面的代码，我们可以看到明显是出错的，类型转换上有错误，那么这个错误是怎么引起的，对于C#来说，当执行list.Add(3);时，已经将3装箱了，而在循环的时候，该元素将拆箱成int型，而对于

list.Add(5.0);来说，程序先将double型5.0装箱，然后再循环的时候该double值被拆箱成int型，所以引发程序的异常。

对于VB来说，这个过程是有所不同的，因为在VB中不使用装箱机制，而是激活一个将double型转化成int类型的方法。但是如果这个值不能被转化为整形，那么这个过程也是失败的。

其次，泛型的效率更高，在非泛型编程中，将简单类型作为Object传递会引起装箱和拆箱操作，这两个过程是具有很大的系统开销的，而用泛型就不会存在这个问题。比如在栈中添加值类型时，如整数，在添加之前必须装箱。装箱的时候在栈上分配一个对象，该对象包括该值类型的一个引用。

.NET中的泛型和其它平台的泛型有一些区别，他们具有很好的二进制重用性。这一点主要是因为.NET将泛型内建在CLR之中。而C++和Java中的泛型所依靠的是它们各自的编译器所提供的特性，编译器在编译泛型代码时将确切的类型展开，这就难免会出现代码膨胀的问题。而.NET的泛型代码是在运行时由JIT（just-in-time,CLR所使用的编译器,负责把MSIL翻译的代码编译成真正的机器代码.）即时编译的，这样CLR就可以为不同类型重用大部分的即时编译代码了。

除此之外，泛型极大的节省了我们的时间，提高了我们的开发效率。我们在创建自定义集合的时候，只需要一行代码，就可以创建一个自定义集合的匹配物，而不用为每种存储类型分别创建不同的独立的集合。只需要在初始化泛型集合的时候将其初始化为一个你需要用到的类型。

在什么情况下使用泛型？

一般来说，在通常情况下，在集合类型中，我们都建议使用泛型，因为它具有类型安全的优点，而不需要从基集合类型派生并实现类型特定的成员。另外，如果集合元素为值类型，泛型集合类型一般都会优于非泛型集合类型，因为在使用泛型的时候不必对元素进行装箱。

泛型集合的种类？

泛型一般来说有下面这些集合类型：

1 List，这是我们应用最多的泛型种类，它对应ArrayList集合。

2 Dictionary，这也是我们平时运用比较多的泛型种类，对应Hashtable集合。

3 Collection对应于CollectionBase

4 ReadOnlyCollection 对应于ReadOnlyCollectionBase,这是一个只读的集合。

5 Queue,Stack和SortedList，它们分别对应于与它们同名的非泛型类。

除此之外，还有一些没有对应非泛型类型的泛型种类，这个在我们平时中应用比较少，在这就不多阐述了。

泛型中的关键字default

在泛型的使用过程中，我们经常会遇到这样一种情况。怎样给泛型方法中的参数化类型T设置默认值。因为对于T来说，它的类型是不定的，它可能是值类型，也可能是引用类型。即使知道它是值类型，也有数值和结构之分。这样就给我们定义它的默认值带来了困难，如果我们定义t=null，这只有在T为引用类型时才有效。如果我们定义t=0，这只有在T为数值类型而不是结构时才有效。怎么解决这个问题呢？泛型的解决方案是利用default关键字，这个关键字有什么作用呢？它对引用类型会返回null，对数值类型会返回0，也就是说，它会根据每个结构成员的不同类型来返回不同的默认值。

public class GenericList

{

private class Node

{

public Node Next;

public T Data;

}

private Node head;

public T GetNext()

{

T temp = default(T);

Node current = head;

if (current != null)

{

temp = current.Data;

current = current.Next;

}

return temp;

}

虽然泛型的引入虽然给我们带来很多好处，但是同时也使C#中的语法有一些变化，这是我们在使用泛型的过程中应该注意的。

下面我们着重在类中来讲叙泛型，在实际中它在类方法、接口、委托和结构上都是可以使用的。

1、泛型中的静态成员变量

对于类的静态成员变量来说，在C#1.1中，类的静态成员变量在不同的类实例中是共享的，并且都是通过类名来访问的。在2.0中，这个机制有了一些变化，即静态成员变量在相同封闭类间共享，在不同的封闭类间不共享。

为什么呢？因为在泛型中，不同的封闭类虽然有相同的类名称，但是传入的数据类型是不同的，它在本质上来说是不同的类。

比如下面：

Test a=new Test();

Test b=new Test();

Test c=new Test();

a和b是同一类型，但是c和a，b是完全不同的类实例，所以它们之间不能共享静态成员变量。

2、泛型中的方法重载

我们知道，方法重载在C#中应用非常广泛，对方法进行重载的时候，要求它们具有不同的签名。但是在对泛型进行重载的时候，通用类型T在编写的时候是不确定的，这是和传统的重载方法所不同的地方，对这种情况我们怎样进行处理呢？下面我们来看这个例子。

public class Example

{

public T add(T a, V b) //第一个add

{

return a;

}

public T add(V a, T b) //第二个add

{

return b;

}

public int add(int a, int b) //第三个add

{

return a + b;

}

对于上面的类来说，如果我们将T和V都传入int类型的话，那么这三个add方法将具有相同的签名，但是这个类仍然能够通过编译，只有在将这个类实例化并且调用add方法时编译器才能判断是否会引起调用混淆。

下面我们来看第一种情况，看是否会引起混淆。

Example example1=new Example();

object x=example1.add(1,1);

如果我们按照上面的情况实例化，类中的三个方法都符合，因为它们具有相同的签名。但是在这里，是可以调用成功的，因为在这里有一个原则：

如果一般方法和泛型方法具有相同的签名，一般方法会覆盖泛型方法。

也就是说，在上面进行实例化的并且调用类中的方法时，第三个方法已经覆盖了前面两个泛型方法，所以在这里是可以调用成功的。

如果我们删除了第三个add方法，那么上面的代码编译的时候是无法通过的，因为前两个add方法引起了混淆。

3、泛型类中数据类型的约束

在泛型的使用过程中我们经常会遇到这种问题，虽然这个数据类型T是通用类型，但是在有些特殊情况下我们必须对传入的数据进行一定的限制，即我们经常说的泛型的数据类型约束。约束的方式是指定T的祖先，即它继承的接口或者类，这里要注意的是C#是单根继承的，所以约束可以有多个接口，但是最多只能有一个类，并且类必须在接口之前。下面我们来看一个约束。

Public class Test where T:Stack,IComparable

Where V:Stack

{…}

上面这个约束说明，T必须从Stack和Icomparable继承，V必须是Stack或者从Stack继承。否则它是无法通过编译器的类型检查的。

看到这里有人也许会问，既然T是通用类型，各种数据类型都支持，那还需要对它进行约束干什么呢？不是多此一举吗？其实不然，约束在泛型中是有很重要的作用的，举个例子，比如现在我设计的类只需要两种数据类型int和string，并且需要对T类型的变量比较大小。但是对于object来说，它是没有比较大小的方法的，这是很显然的。这时候我们就可以利用约束来进行处理。

比如说下面的方法：

public static T Max＜T＞(T op1, T op2)

{

　if (op1.CompareTo(op2) ＜ 0)

　　return op1;

　return op2;

}

这个例子在编译的时候是不能通过的，因为没有对它添加IComparable约束，没有实现IComparable接口所以不支持CompareTo方法。

public static T Max＜T＞(T op1, T op2) where T : IComparable

{

　if (op1.CompareTo(op2) ＜ 0)

　　return op1;

　return op2;

}

我们知道，在C#里数据类型有两大类，值类型和引用类型，在泛型的约束里面，我们也可以指定通用类型T是值类型还是引用类型，值类型用关键字struct来标识，而引用类型用关键字class来标识。如：

Public class Test where T:class

Where V:struct

{……}

如果在类Test里需要对T重新进行实例化，而我们又不知道类Test中类T到底有哪些构造函数。这个时候需要用到new约束：

如：

public class Test where T : Stack, new()

where V: IComparable

要注意的一点是，当与其他约束一起使用时，new() 约束必须最后指定。另外，new约束只能是无参数的，所以也要求相应的类Stack必须有一个无参构造函数，否则编译失败。

泛型方法：

泛型不仅能作用在类上，也可单独用在类的方法上，他可根据方法参数的类型自动适应各种参数，这样的方法叫泛型方法。

对于下面的泛型方法，原来的类Stack一次只能Push一个数据，这个类Stack2扩展了Stack的功能（当然也可以直接写在Stack中），他可以一次把多个数据压入Stack中。其中Push是一个泛型方法。

class Program

{

static void Main(string[] args)

{

Stack<int> x = new Stack<int>(100);

Stack2 x2 = new Stack2();

x2.Push(x, 1, 2, 3, 4, 6);

string s="";

for (int i = 0; i < 5; i++)

s += x.Pop().ToString();

}

public class Stack2

{

//一个泛型方法，将多个数据压入堆栈

public void Push(Stack s, params T[] p)

{

foreach (T t in p)

s.Push(t);

}

迭代器（Iterator）

迭代器和泛型一样，也是C#2.0中的新功能，迭代器是方法、get访问器或者运算符。它是用来干什么的呢？它的主要作用是使类或者结构，包括我们自己定义的数据集等中能够支持foreach遍历。在C#中，我们主要通过继承IEnumerable接口和实现该接口的GetEnumrator方法来创建迭代器。只要我们在程序中提供一个迭代器，就可以遍历类中的数据结构，在程序进行编译的时候，当编译器检测到迭代器，它会自动生成IEnumerable或者IEnumerable接口的Current、MoveNext和Dispose方法。

下面我们看一个简单的例子，来看C#是如何实现迭代的。

例一：

public class Example1:IEnumerable

{

public IEnumerator GetEnumerator()

{

for (int i = 0; i < 10; i++)

{

yield return i;

}

class Program

{

static void Main(string[] args)

{

Example1 test = new Example1();

foreach (int i in test)

Console.WriteLine(i);

}

输出结果：0123456789

关于迭代器：

2 迭代器是可以返回相同类型的值的有序序列的一段代码。

3 迭代器可用作方法、运算符或get访问器的代码体。

4 迭代器使用yield return语句依次返回每个元素，到达yield break将终止迭代。

5 在一个类中可以实现多个迭代器。但是在一个类里面的迭代器必须有唯一的名称。

6 迭代器的返回类型必须为IEnumerable和IEnumerator类型。

现在，我们大概知道了迭代器的一些概念，也知道迭代器是用来做什么的，简单的说就是实现对一个类（主要是容器类）或者结构的循环。而它的主要用途也在这里，如果我们不做容器类，并且如果我们不需要实现容器类循环这个需求，那迭代器对我们来说就没有什么用处了。前者没有必要，后者可以直接用容器内部的GetEnumerator方法。

迭代器的实现模式。

通常情况下，实现IEnumrable接口的类是作为要遍历的集合类型的嵌套类来提供。将嵌套类作为枚举器。这样既可以保证它访问所包含的类的其他私有成员，又对迭代客户端隐藏了底层数据结构的实现细节。

迭代器中有三个很重要的属性和方法，即Current、MoveNext和Dispose方法。下面我们先介绍一下这三个方法。

MoveNext方法封装了迭代器块的代码，调用MoveNext方法将执行迭代器内的代码。并且将对象的current属性设为合适的值。至于设为什么值，由MoveNext方法被调用时枚举器对象的状态决定。比如如果当前枚举器对象状态是before或者suspended，那么调用MoveNext将把对象的状态改为running。如果当前枚举器对象状态是running，那么调用MoveNext方法的结果是未知的。

Current属性受yield return语句影响，它的值是最后一次调用MoveNext时被设置的值，当枚举器对象处于before、after或者running时，Current的值是不确定的。

Dispose方法通过将枚举器对象的状态置为after，以清理迭代结果。如果状态是before，调用Dispose将改变其状态为after；如果状态为running，调用Dispose的结果是为指定的；如果枚举器对象状态为suspended，调用Dispose将先改变其状态为running，并且执行finally块，最后改变其状态为after；如果枚举器对象状态为after，那么调用Dispose没有效果。

使用迭代器有一个问题我们必须有清晰的认识，那就是，迭代器的主要功能是实现容器类和自定义集合的循环。但是，在我们的实际开发中，容器类和自定义集合都不会是单一的数据类型，肯定包含了多种数据类型。如果包含了值类型，那么需要对它们进行装箱和拆箱才能获得选项。因为IEnumerator.Current返回一个Object类的对象。这必然会导致潜在的性能降低和托管堆上的压力增大。如果包含的是引用类型，那么必然存在类型之间的转换，这样同样是会带来效率的损失和存在一定的安全性问题。那么这个问题怎么解决呢？

前面我们讲泛型的时候曾经提到了泛型的优点，恰好是避免装箱拆箱，并且避免在类型转换中的安全问题，可以说，泛型的优点正好可以补迭代器在容器类中使用的缺点。所以，在实际的开发过程中，我们一般将迭代器和泛型结合起来使用。

最后，我们综合泛型和迭代器来看一个例子，这个例子是微软提供的，我稍微做了一下改动。

public class Ustbwuyi : IEnumerable

{

protected Node Node1;

protected Node current = null;

//该嵌套类型同样为T上的泛型

protected class Node

{

public Node next;

public Node Next

{

get { return next; }

set { next = value; }

}

private T data;

public T Data

{

get { return data; }

set { data = value; }

}

//在非泛型构造函数中使用T

public Node(T t)

{

next = null;

data = t;

}

public Ustbwuyi()

{

Node1 = null;

}

public void AddHead(T t)

{

Node n = new Node(t);

n.Next = Node1;

Node1 = n;

}

// 实现 GetEnumerator 以返回 IEnumerator，从而启用列表的

// foreach 迭代。请注意，在 C# 2.0 中，

// 不需要实现 Current 和 MoveNext。

// 编译器将创建实现 IEnumerator 的类。

public IEnumerator GetEnumerator()

{

Node current = Node1;

while (current != null)

{

yield return current.Data;

current = current.Next;

}

//必须实现次方法，因为IEnumerable 继承 IEnumerable

IEnumerator IEnumerable.GetEnumerator()

{

return GetEnumerator();

}

///

/// 一个排序算法

///

public class SortedList : Ustbwuyi where T : IComparable

{

public void BubbleSort()

{

if (Node1 == null || Node1.Next == null)

return;

bool swapped;

{

Node previous = null;

Node current = Node1;

swapped = false;

while (current.next != null)

{

if (current.Data.CompareTo(current.next.Data) > 0)

{

Node tmp = current.next;

current.next = current.next.next;

tmp.next = current;

if (previous == null)

{

Node1 = tmp;

}

else

{

previous.next = tmp;

}

previous = tmp;

swapped = true;

}

else

{

previous = current;

current = current.next;

}

while (swapped);

}

public class Person : IComparable<Person>

{

string name;

int age;

public Person(string s, int i)

{

name = s;

age = i;

}

public int CompareTo(Person p)

{

return age - p.age;

}

public override string ToString()

{

return name + "的年龄是：" + age;

}

public bool Equals(Person p)

{

return (this.age == p.age);

}

class Program

{

static void Main(string[] args)

{

SortedList<Person> list = new SortedList<Person>();

string[] names = new string[] { "邬琳伟", "吴娟", "吴倚", "胡娭毑", "唐志科" };

int[] ages = new int[] { 31, 25, 23, 24, 25 };

//填充列表

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

{

list.AddHead(new Person(names[i], ages[i]));

}

Console.WriteLine("未排序的列表：");

//输出未排序的列表

foreach (Person p in list)

{

Console.WriteLine(p.ToString());

}

//对列表进行排序

list.BubbleSort();

Console.WriteLine(String.Format("{0}排序的列表：", Environment.NewLine));

//输出排序的列表

foreach (Person p in list)

{

Console.WriteLine(p.ToString());

}

Console.WriteLine("Filished");

}

该程序的输出结果为：

未排序的列表：

唐志科的年龄是：25

胡娭毑的年龄是：24

吴倚的年龄是：23

吴娟的年龄是：25

邬琳伟的年龄是：31

排序的列表：

吴倚的年龄是：23

胡娭毑的年龄是：24

唐志科的年龄是：25

吴娟的年龄是：25

邬琳伟的年龄是：31

Filished

请按任意键继续. . .

评论: 1　查看评论　发表评论

ajax完美解决的一个麻烦问题

ustbwuyi — Mon, 19 Mar 2007 03:26:00 GMT

阅读: 2341 评论: 7 作者: ustbwuyi 发表于 2007-03-19 11:26 原文链接

     最近老总提了一个小功能，在搜索网吧列表的时候加上网吧所属代理商这个条件，原有的搜索条件是一个地区二级联动，现在需要根据不同的地区显示不同的代理商集合。
即在触发地区下拉框的onchange事件时，代理商的下拉框选项也相应的改变，比如选择地区湖南—〉长沙，那么代理商下拉框只显示长沙的代理商。
    本来认为这个很好实现，但实际改起来的时候发现问题多多，主要问题是原有的地区联动是用js实现的，它的数据源是一个xml文件，当然如果下拉框是服务器端控件那么问题是很好解决的，现在是html控件一下子似乎还真有些不好改，想了几种办法实现起来都不理想，最后将思路转向用ajax来实现问题才迎刃而解，现在仔细一想，像这种情况似乎只有用ajax才能比较好的解决，如果是在地区下拉框的onchange事件里向后台进行一次提交，将地区下拉框的id传过去的话，实际上产生的回发会将地区联动下拉框重新初始化。
    现在我具体谈谈这个ajax实现的过程。
    首先页面当然需要定义一个下拉框的html控件。

<select id="Agent" name="Agent">select>

接下来当然是定义XmlHttpRequest对象。

var xmlhttp;
function CreateXmlHttp()
   {

   //非IE浏览器创建XmlHttpRequest对象
    if(window.XmlHttpRequest)
    {
     xmlhttp=new XmlHttpRequest();
    }
    //IE浏览器创建XmlHttpRequest对象
     if(window.ActiveXObject)
    {
    try
    {
     xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
    }
    catch(e)
    {
    try{
     xmlhttp=new ActiveXObject("msxml2.XMLHTTP");
     }
     catch(ex){}
    }
    }
   }

这个在我的多篇blog文章里都有阐述，就不多说了。

接下来当然是利用该对象来发送条件，获得数据,并且将获得的数据绑定到agent这个下拉框。
在地区下拉框的onchange事件里面触发函数AjaxSend()；

另外顺便介绍一下UserAjax接收到该地区编号后获取数据返回字符串的过程。

string Area = Request.QueryString["area"].ToString();
        DataTable data = "生成DataTable，涉及到公司核心代码，省略"
        string aa = "";
        for (int i = 0; i < data.Rows.Count; i++)
        {
            if (aa == "")
            {
                aa = data.Rows[i]["id"].ToString()+"/"+data.Rows[i]["name"].ToString();
            }
            else
            {
                aa = aa + "," + data.Rows[i]["id"].ToString() +"/"+ data.Rows[i]["name"].ToString();
            }
        }
       Response.Write(aa);

这样，一个比较棘手的问题用ajax就获得了完美解决，并且不会因向后台回发而导致下拉框初始化，导致选项改变，亲爱的朋友，看了这个例子，你对ajax是不是也有了
更好的认识呢？

评论: 7　查看评论　发表评论

Ajax的原理和应用(给公司做所的培训)

ustbwuyi — Thu, 08 Feb 2007 08:31:00 GMT

阅读: 4958 评论: 55 作者: ustbwuyi 发表于 2007-02-08 16:31 原文链接

在写这篇文章之前，曾经写过一篇关于AJAX技术的随笔，不过涉及到的方面很窄，对AJAX技术的背景、原理、优缺点等各个方面都很少涉及null。这次写这篇文章的背景是因为公司需要对内部程序员做一个培训。项目经理找到了我，并且征询我培训的主题，考虑到之前Javascript、CSS等WEB开发技术都已经讲解过了，所以决定针对AJAX这一块做一个比较系统的培训，所以这篇文章实际上是一个培训的材料。

在这篇文章中，我将从10个方面来对AJAX技术进行系统的讲解。

1、ajax技术的背景

不可否认，ajax技术的流行得益于google的大力推广，正是由于google earth、google suggest以及gmail等对ajax技术的广泛应用，催生了ajax的流行。而这也让微软感到无比的尴尬，因为早在97年，微软便已经发明了ajax中的关键技术，并且在99年IE5推出之时，它便开始支持XmlHttpRequest对象，并且微软之前已经开始在它的一些产品中应用ajax，比如说MSDN网站菜单中的一些应用。遗憾的是，不知道出于什么想法，当时微软发明了ajax的核心技术之后，并没有看到它的潜力而加以发展和推广，而是将它搁置起来。对于这一点来说，我个人是觉得非常奇怪的，因为以微软的资源和它的战略眼光来说，应该不会看不到ajax技术的前景，唯一的解释也许就是因为当时它的主要竞争对手Netscape的消失反而使它变得麻痹和迟钝，毕竟巨人也有打盹的时候，比如IBM曾经在对微软战略上的失误。正是这一次的失误，成就了它现在的竞争对手google在ajax方面的领先地位，而事实上google目前在ajax技术方面的领先是微软所无法达到的，这一点在后面我讲述ajax缺陷的时候也会提到。现在微软也意识到了这个问题，因此它也开始在ajax领域奋起直追，比如说推出它自己的ajax框架atlas，并且在.NET2.0也提供了一个用来实现异步回调的接口，即ICallBack接口。那么微软为什么对自己在ajax方面的落后如此紧张呢？现在就让我们来分析一下ajax技术后面隐藏的深刻意义。

2、ajax技术的意义

我们在平时的开发中都多多少少的接触或者应用到了ajax，谈到ajax技术的意义，我们关注得最多的毫无疑问是提升用户的体验。但是，如果我们结合将来电脑和互联网的发展趋势，我们会发现ajax技术在某些方面正好代表了这种趋势。为什么这样说呢？我们知道，自从电脑出现以来，一直是桌面软件占据着绝对主导的地位，但是互联网的出现和成功使这一切开始发生着微妙的变化。相当一部分的人都相信，迟早有一天，数据和电脑软件将会从桌面转移到互联网。也就是说，将来的电脑有可能抛弃笨重的硬盘，而直接从互联网来获取数据和服务，我记得我念大学的时候，有位教授给我们上课的时候，曾经设想过这样一种情景，也许在将来的电脑桌面上，没有任何多余的软件和程序，而仅仅只有一个IE，虽然现在看起来我们距离这一天还很遥远，并且这其中还有很多的问题需要解决，但是我觉得这个并非梦想，而是迟早将实现的现实。那么，这其中的主要问题就是互联网的连接不稳定，谁也不愿意看着自己的电脑从服务器一点一滴的下载数据，那么，ajax是不是解决了这个问题呢，说实话，与其说ajax解决了这个问题，倒不如它只是掩盖了这个问题，它只是在服务器和客户端之间充当了一个缓冲器，让用户误以为服务没有中断。精确的说，ajax并不能提高从服务器端下载数据的速度，而只是使这个等待不那么令人沮丧。但是正是这一点就足以产生巨大的影响和震动，它实际上也对桌面软件产生了巨大的冲击。这一点我用一个例子来说明，我们可以比较一下Outlook Express和Gmail，前者是典型的桌面软件，后者是ajax所实现的B/S模式，实际上后者目前已经在慢慢取代前者了，Gmail在收发邮件的时候已经和Outlook Express的功能几乎没有差别了，而且它不需要安装客户端程序。这就是为什么微软对ajax所带来的冲击有着如此的恐惧心理，并且在它前不久所进行的调查之中，将google看做他们未来十年内的主要竞争对手的主要原因之一。当然，这种变化也并不会将桌面软件全部淘汰，现有的浏览器还没有一个能像PhotoShop等桌面程序那样处理复杂的图像。但是我们也不能忽视它带来的影响和冲击。

3、关于ajax的名字

ajax 的全称是Asynchronous JavaScript and XML，其中，Asynchronous 是异步的意思，它有别于传统web开发中采用的同步的方式。

4、关于同步和异步

异步传输是面向字符的传输，它的单位是字符；而同步传输是面向比特的传输，它的单位是桢，它传输的时候要求接受方和发送方的时钟是保持一致的。

具体来说，异步传输是将比特分成小组来进行传送。一般每个小组是一个8位字符，在每个小组的头部和尾部都有一个开始位和一个停止位，它在传送过程中接收方和发送方的时钟不要求一致，也就是说，发送方可以在任何时刻发送这些小组，而接收方并不知道它什么时候到达。一个最明显的例子就是计算机键盘和主机的通信，按下一个键的同时向主机发送一个8比特位的ASCII代码，键盘可以在任何时刻发送代码，这取决于用户的输入速度，内部的硬件必须能够在任何时刻接收一个键入的字符。这是一个典型的异步传输过程。异步传输存在一个潜在的问题，即接收方并不知道数据会在什么时候到达。在它检测到数据并做出响应之前，第一个比特已经过去了。这就像有人出乎意料地从后面走上来跟你说话，而你没来得及反应过来，漏掉了最前面的几个词。因此，每次异步传输的信息都以一个起始位开头，它通知接收方数据已经到达了，这就给了接收方响应、接收和缓存数据比特的时间；在传输结束时，一个停止位表示该次传输信息的终止。按照惯例，空闲（没有传送数据）的线路实际携带着一个代表二进制1的信号。步传输的开始位使信号变成0，其他的比特位使信号随传输的数据信息而变化。最后，停止位使信号重新变回1，该信号一直保持到下一个开始位到达。例如在键盘上数字“1”，按照8比特位的扩展ASCII编码，将发送“00110001”，同时需要在8比特位的前面加一个起始位，后面一个停止位。

同步传输的比特分组要大得多。它不是独立地发送每个字符，每个字符都有自己的开始位和停止位，而是把它们组合起来一起发送。我们将这些组合称为数据帧，或简称为帧。

　　数据帧的第一部分包含一组同步字符，它是一个独特的比特组合，类似于前面提到的起始位，用于通知接收方一个帧已经到达，但它同时还能确保接收方的采样速度和比特的到达速度保持一致，使收发双方进入同步。

　　帧的最后一部分是一个帧结束标记。与同步字符一样，它也是一个独特的比特串，类似于前面提到的停止位，用于表示在下一帧开始之前没有别的即将到达的数据了。

　　同步传输通常要比异步传输快速得多。接收方不必对每个字符进行开始和停止的操作。一旦检测到帧同步字符，它就在接下来的数据到达时接收它们。另外，同步传输的开销也比较少。例如，一个典型的帧可能有500字节（即4000比特）的数据，其中可能只包含100比特的开销。这时，增加的比特位使传输的比特总数增加2.5%，这与异步传输中25 %的增值要小得多。随着数据帧中实际数据比特位的增加，开销比特所占的百分比将相应地减少。但是，数据比特位越长，缓存数据所需要的缓冲区也越大，这就限制了一个帧的大小。另外，帧越大，它占据传输媒体的连续时间也越长。在极端的情况下，这将导致其他用户等得太久。

了解了同步和异步的概念之后，大家应该对ajax为什么可以提升用户体验应该比较清晰了，它是利用异步请求方式的。打个比方，如果现在你家里所在的小区因某种情况而面临停水，现在有关部门公布了两种方案，一是完全停水8个小时，在这8个小时内完全停水，8个小时后恢复正常。二是不完全停水10 个小时，在这10个小时内水没有完全断，只是流量比原来小了很多，在10个小时后恢复正常流量，那么，如果是你你会选择哪种方式呢？显然是后者。

5、ajax所包含的技术

大家都知道ajax并非一种新的技术，而是几种原有技术的结合体。它由下列技术组合而成。

1.使用CSS和XHTML来表示。

2. 使用DOM模型来交互和动态显示。

3.使用XMLHttpRequest来和服务器进行异步通信。

4.使用javascript来绑定和调用。

在上面几中技术中，除了XmlHttpRequest对象以外，其它所有的技术都是基于web标准并且已经得到了广泛使用的，XMLHttpRequest虽然目前还没有被W3C所采纳，但是它已经是一个事实的标准，因为目前几乎所有的主流浏览器都支持它。

6、ajax原理和XmlHttpRequest对象

Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用javascript来操作DOM而更新页面。这其中最关键的一步就是从服务器获得请求数据。要清楚这个过程和原理，我们必须对 XMLHttpRequest有所了解。

XMLHttpRequest是ajax的核心机制，它是在IE5中首先引入的，是一种支持异步请求的技术。简单的说，也就是javascript可以及时向服务器提出请求和处理响应，而不阻塞用户。达到无刷新的效果。

所以我们先从XMLHttpRequest讲起，来看看它的工作原理。

首先，我们先来看看XMLHttpRequest这个对象的属性。

它的属性有：

onreadystatechange 每次状态改变所触发事件的事件处理程序。

responseText 从服务器进程返回数据的字符串形式。

responseXML 从服务器进程返回的DOM兼容的文档数据对象。

status 从服务器返回的数字代码，比如常见的404（未找到）和200（已就绪）

status Text 伴随状态码的字符串信息

readyState 对象状态值

0 (未初始化) 对象已建立，但是尚未初始化（尚未调用open方法）

1 (初始化) 对象已建立，尚未调用send方法

2 (发送数据) send方法已调用，但是当前的状态及http头未知

3 (数据传送中) 已接收部分数据，因为响应及http头不全，这时通过responseBody和responseText获取部分数据会出现错误，

4 (完成) 数据接收完毕,此时可以通过通过responseXml和responseText获取完整的回应数据

但是，由于各浏览器之间存在差异，所以创建一个XMLHttpRequest对象可能需要不同的方法。这个差异主要体现在IE和其它浏览器之间。下面是一个比较标准的创建XMLHttpRequest对象的方法。

function CreateXmlHttp()

{

//非IE浏览器创建XmlHttpRequest对象

if(window.XmlHttpRequest)

{

xmlhttp=new XmlHttpRequest();

}

//IE浏览器创建XmlHttpRequest对象

if(window.ActiveXObject)

{

try

{

xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");

}

catch(e)

{

try{

xmlhttp=new ActiveXObject("msxml2.XMLHTTP");

}

catch(ex){}

}

function Ustbwuyi()

{

var data=document.getElementById("username").value;

CreateXmlHttp();

if(!xmlhttp)

{

alert("创建xmlhttp对象异常！");

return false;

}

xmlhttp.open("POST",url,false);

xmlhttp.onreadystatechange=function()

{

if(xmlhttp.readyState==4)

{

document.getElementById("user1").innerHTML="数据正在加载...";

if(xmlhttp.status==200)

{

document.write(xmlhttp.responseText);

}

xmlhttp.send();

}

如上所示，函数首先检查XMLHttpRequest的整体状态并且保证它已经完成（readyStatus=4），即数据已经发送完毕。然后根据服务器的设定询问请求状态，如果一切已经就绪（status=200），那么就执行下面需要的操作。

对于XmlHttpRequest的两个方法，open和send，其中open方法指定了：

a、向服务器提交数据的类型，即post还是get。

b、请求的url地址和传递的参数。

c、传输方式，false为同步，true为异步。默认为true。如果是异步通信方式(true)，客户机就不等待服务器的响应；如果是同步方式(false)，客户机就要等到服务器返回消息后才去执行其他操作。我们需要根据实际需要来指定同步方式，在某些页面中，可能会发出多个请求，甚至是有组织有计划有队形大规模的高强度的request，而后一个是会覆盖前一个的，这个时候当然要指定同步方式。

Send方法用来发送请求。

知道了XMLHttpRequest的工作流程，我们可以看出，XMLHttpRequest是完全用来向服务器发出一个请求的，它的作用也局限于此，但它的作用是整个ajax实现的关键，因为ajax无非是两个过程，发出请求和响应请求。并且它完全是一种客户端的技术。而XMLHttpRequest正是处理了服务器端和客户端通信的问题所以才会如此的重要。

现在，我们对ajax的原理大概可以有一个了解了。我们可以把服务器端看成一个数据接口，它返回的是一个纯文本流，当然，这个文本流可以是XML格式，可以是Html，可以是Javascript代码，也可以只是一个字符串。这时候，XMLHttpRequest向服务器端请求这个页面，服务器端将文本的结果写入页面，这和普通的web开发流程是一样的，不同的是，客户端在异步获取这个结果后，不是直接显示在页面，而是先由javascript来处理，然后再显示在页面。至于现在流行的很多ajax控件，比如magicajax等，可以返回DataSet等其它数据类型，只是将这个过程封装了的结果，本质上他们并没有什么太大的区别。

7、ajax的优点

Ajax的给我们带来的好处大家基本上都深有体会，在这里我只简单的讲几点：

1、最大的一点是页面无刷新，在页面内与服务器通信，给用户的体验非常好。

　 2、使用异步方式与服务器通信，不需要打断用户的操作，具有更加迅速的响应能力。

　 3、可以把以前一些服务器负担的工作转嫁到客户端，利用客户端闲置的能力来处理，减轻服务器和带宽的负担，节约空间和宽带租用成本。并且减轻服务器的负担，ajax的原则是“按需取数据”，可以最大程度的减少冗余请求，和响应对服务器造成的负担。

4、基于标准化的并被广泛支持的技术，不需要下载插件或者小程序。

8、ajax的缺点

下面我着重讲一讲ajax的缺陷，因为平时我们大多注意的都是ajax给我们所带来的好处诸如用户体验的提升。而对ajax所带来的缺陷有所忽视。

下面所阐述的ajax的缺陷都是它先天所产生的。

1、ajax干掉了back按钮，即对浏览器后退机制的破坏。后退按钮是一个标准的web站点的重要功能，但是它没法和js进行很好的合作。这是ajax所带来的一个比较严重的问题，因为用户往往是希望能够通过后退来取消前一次操作的。那么对于这个问题有没有办法？答案是肯定的，用过Gmail的知道，Gmail下面采用的ajax技术解决了这个问题，在Gmail下面是可以后退的，但是，它也并不能改变ajax的机制，它只是采用的一个比较笨但是有效的办法，即用户单击后退按钮访问历史记录时，通过创建或使用一个隐藏的IFRAME来重现页面上的变更。（例如，当用户在Google Maps中单击后退时，它在一个隐藏的IFRAME中进行搜索，然后将搜索结果反映到Ajax元素上，以便将应用程序状态恢复到当时的状态。）

但是，虽然说这个问题是可以解决的，但是它所带来的开发成本是非常高的，和ajax框架所要求的快速开发是相背离的。这是ajax所带来的一个非常严重的问题。

2、安全问题

技术同时也对IT企业带来了新的安全威胁，ajax技术就如同对企业数据建立了一个直接通道。这使得开发者在不经意间会暴露比以前更多的数据和服务器逻辑。ajax的逻辑可以对客户端的安全扫描技术隐藏起来，允许黑客从远端服务器上建立新的攻击。还有ajax也难以避免一些已知的安全弱点，诸如跨站点脚步攻击、SQL注入攻击和基于credentials的安全漏洞等。

3、对搜索引擎的支持比较弱。

4、破坏了程序的异常机制。至少从目前看来，像ajax.dll，ajaxpro.dll这些ajax框架是会破坏程序的异常机制的。关于这个问题，我曾经在开发过程中遇到过，但是查了一下网上几乎没有相关的介绍。后来我自己做了一次试验，分别采用ajax和传统的form提交的模式来删除一条数据……给我们的调试带来了很大的困难。

5、另外，像其他方面的一些问题，比如说违背了url和资源定位的初衷。例如，我给你一个url地址，如果采用了ajax技术，也许你在该url地址下面看到的和我在这个url地址下看到的内容是不同的。这个和资源定位的初衷是相背离的。

6、一些手持设备（如手机、PDA等）现在还不能很好的支持ajax，比如说我们在手机的浏览器上打开采用ajax技术的网站时，它目前是不支持的，当然，这个问题和我们没太多关系。

9、ajax的几种框架

目前我们采用的比较多的ajax框架主要有ajax.dll,ajaxpro.dll,magicajax.dll 以及微软的atlas框架。Ajax.dll和Ajaxpro.dll这两个框架差别不大，而magicajax.dll只是封装得更厉害一些，比如说它可以直接返回DataSet数据集，前面我们已经说过，ajax返回的都是字符串，magicajax只是对它进行了封装而已。但是它的这个特点可以给我们带来很大的方便，比如说我们的页面有一个列表，而列表的数据是不断变化的，那么我们可以采用magicajax来处理，操作很简单，添加magicajax之后，将要更新的列表控件放在magicajax的控件之内，然后在pageload里面定义更新间隔的时间就ok了，atlas的原理和magicajax差不多。但是，需要注意的一个问题是，这几种框架都只支持IE，没有进行浏览器兼容方面的处理，用反编译工具察看他们的代码就可以知道。

除了这几种框架之外，我们平时用到的比较多的方式是自己创建xmlHttpRequest对象，这种方式和前面的几种框架相比更具有灵活性。另外，在这里还提一下aspnet2.0自带的异步回调接口，它和ajax一样也可以实现局部的无刷新，但它的实现实际上也是基于xmlhttprequest对象的，另外也是只支持IE，当然这是微软的一个竞争策略。

10、ajax示例

验证用户名是否注册。

采用两种方式

1 ajax.dll

2 自己写xmlhttprequest对象

10.ajax中常见到的一些错误

1 配置的问题

在pageload里面配置该页面的时候

在后台调用的方法里调用了前台的部分…

评论: 55　查看评论　发表评论

最近遇到的几个小问题总结

ustbwuyi — Tue, 30 Jan 2007 09:25:00 GMT

阅读: 436 评论: 1 作者: ustbwuyi 发表于 2007-01-30 17:25 原文链接

1 、文件上传

最近做广告发布系统，不可避免的遇到上传图片文件的问题。基本原理是将图片上传到服务器，然后将它的路径保存在数据库，显示的时候从服务器取出该路径，让img直接指向这个路径即可。当然在上传的时候需要判断文件类型，比如是jpg、gif，swf等。在这里我是用正则表达式来验证的，该方法非常有效，而直接用endwith方法来判断有时候会出现一些莫名其妙的问题。

//获取上传文件的路径
    string filename=this.file1.PostedFile.FileName;
                        //定义正则表达式
                        Regex reg = new Regex(@"^.+\.(jpg)|(gif)|(swf)|(jpeg)$");
                        //用正则表达式来判定
                        if(!reg.Match(filename.ToLower()).Success)
                        {                    base.Alert("上传的文件类型不符合要求！");    }
                        //获取上传文件的名称
                        string name = DateTime.Now.ToString("yyyyMMddhhmmss")+filename.Substring(filename.LastIndexOf("\\")+1);
                        //要上传的服务器地址
                        string path=Server.MapPath(string.Format("~/AdFiles/"))+name;
                        try
                        {                            this.file1.PostedFile.SaveAs(path);
                        }
                        catch(Exception ee)
                        {                      base.Alert("图片上传失败，请与服务器空间商联系确认权限！");
                        }

其次是上传权限的设置，如果是在本地，需要对虚拟目录下该文件夹设置写入权限，在该目录上鼠标右键->属性->安全->everyone->写入即可。
如果是在服务器，除了需要有该文件夹的写入权限之外，还要在web.config里面设置一下。

在system.web节点里面添加如下代码：

评论: 1　查看评论　发表评论

标签包含了，如果这两个标签都有 onclick事件的处理函数，那么执行的情况就是先执行标签的onclick事件处理函数，再执行

javascript中事件的理解

ustbwuyi — Mon, 23 Oct 2006 07:22:00 GMT

阅读: 635 评论: 0 作者: ustbwuyi 发表于 2006-10-23 15:22 原文链接

在javascript中，event事件是一个必不可少的讨论话题，它在和用户的交互中起到了很重要的作用。今天我们就来讨论一下JavaScript中的事件处理，并且结合它来阐叙Ajax框架实现拖动效果的原理了。
一、 Event对象
   1   Event对象的主要属性和方法
　　event代表事件的状态，专门负责对事件的处理，它的属性和方法能帮助我们完成很多和用户交互的操作，下面我们就来看看它的一些属性和方法。
        type：事件的类型，就是HTML标签属性中，没有“on”前缀之后的字符串，例如“Click”就代表单击事件。

　　srcElement：事件源，就是发生事件的元素。比如 a这个链接是事件发生的源头，也就是该事件的srcElement。

　　button：声明了被按下的鼠标键，是一个整数。0代表没有按键，1代表鼠标左键，2代表鼠标右键，4代表鼠标的中间键，如果按下了多个鼠标键，就把这些值加在一起，所以3就代表左右键同时按下。

　　clientX/clientY：是指事件发生的时候，鼠标的横、纵坐标，返回的是整数，它们的值是相对于包容窗口的左上角生成的。

　　offsetX/offsetY：鼠标指针相对于源元素的位置，可以确定单击Image对象的哪个象素。

　　altKey，ctrlKey，shiftKey：顾名思义，这些属性是指鼠标事件发生的时候，是否同时按住了Alt、Ctrl或者Shift键，返回的是一个布尔值。

　　keyCode：返回keydown和keyup事件发生的时候，按键的代码以及keypress事件的Unicode字符。比如event.keyCode=13代表按下了回车键；

　　fromElement、toElement前者是指代mouseover事件移动过的文档元素，后者指代mouseout事件中鼠标移动到的文档元素。

　　cancelBubble：一个布尔属性，把它设置为true的时候，将停止事件进一步起泡到包容层次的元素，它用于检测是否接受上层元素的事件的控制。true代表不被上层元素的事件控制，false代表允许被上层元素的事件控制。

　　returnValue：一个布尔值属性，设置为false的时候可以阻止浏览器执行默认的事件动作，相当于。

         attachEvent()和detachEvent()方法：为制定DOM对象事件类型注册多个事件处理函数的方法，它们有两个参数，第一个是事件类型，第二个是事件处理函数。在attachEvent()事件执行的时候，this关键字指向的是window对象，而不是发生事件的那个元素。

   2    IE Event对象的一些说明
　　Event对象是一个全局属性
　　在IE中，不能把Event对象作为参数传递给事件处理程序，只能用window.event或者event来引用Event对象。因为在IE中，Event是window的一个属性，也就是说event是一个全局变量，这个变量提供了事件的细节。
3 关于事件的起泡的概念

        IE中事件的起泡：IE中事件可以沿着包容层次一点点起泡到上层，也就是说，下层的DOM节点定义的事件处理函数，到了上层的节点如果还有和下层相同事件类型的事件处理函数，那么上层的事件处理函数也会执行。例如，

的事件处理函数。如果希望的事件处理函数执行完毕之后，不希望执行上层的

的onclick的事件处理函数了，那么就把 cancelBubble设置为false即可。
　　
二、 IE中拖动DOM元素的例子
/*
该函数由mousedown事件处理调用
它为随后发生的mousemove和mouseup事件注册了临时的捕捉事件处理程序
并用这些事件处理程序拖动指定的文档元素
第二个参数必须是mousedown事件的事件对象
*/
function beginDrag(elementToDrag,event)
{
//该元素当前位于何处
//该元素的样式性质必须具有left和top css属性
//此外，我们假定他们用象素做单位
//var x=parseInt(elementToDrag.style.left);
//var y=parseInt(elementToDrag.style.top);

//计算一个点和鼠标点击之间的距离，下面的嵌套的moveHandler函数需要这些值
var deltaX=event.clientX-parseInt(elementToDrag.style.left);
var deltaY=event.clientY-parseInt(elementToDrag.style.top);

// 注册mousedown事件后发生的mousemove和mouseup事件的处理程序
// 注意，它们被注册为文档的捕捉事件处理程序
// 在鼠标按钮保持按下的状态的时候，这些事件处理程序保持活动的状态
// 在按钮被释放的时候，它们被删除
document.attachEvent("onmousemove",moveHandler);
document.attachEvent("onmouseup",upHandler);

//我们已经处理了该事件，不要让别的元素看到它
event.cancelBubble=true;
event.returnValue=false;

/*
    这是在元素被拖动时候捕捉mousemove事件的处理程序，它响应移动的元素

*/
function moveHandler(e)
{
    //把元素移动到当前的鼠标位置
    e=window.event;
    elementToDrag.style.left=(event.clientX-deltaX)+"px";
    elementToDrag.style.top=(event.clientY-deltaY)+"px";

    //不要让别的元素看到该事件
    event.cancelBubble=true;

}

/*
    该事件将捕捉拖动结束的时候发生的mouseup事件
*/
function upHandler(e)
{
    //注销事件处理程序
      document.detachEvent("onmouseup",upHandler);
      document.detachEvent("onmousemove",moveHandler);}

      event.cancelBubble=true;
    }
   调用它的HTML文件代码：
　
　
　    Untitled Page
　
　
　
　

　拖动我
　

This is a test.Testing,testing

　
三、 DOM中的高级事件处理
IE 6中的事件处理，并不是W3C DOM标准的事件处理模型，所以如果上述代码运行在Mozilla Firefox的浏览器中，就会失去作用，同时即将发布的IE 7也将支持W3C DOM的二级标准，所以掌握DOM的高级事件处理显得就很重要了，因为W3C DOM二级标准是未来Web的发展方向，同时W3C DOM的API非常常用，为未来更加复杂的Web开发提供了良好的基础。
（一）事件处理程序的作用域和事件的传播
　　在正式讨论DOM高级事件处理之前，我们有必要了解一下事件处理程序的作用域。事件处理程序的作用域要比普通的函数作用域复杂很多。普通的函数作用域链比较容易，例如在一个普通函数中查找一个变量a，那么JavaScript解释器会先在该函数的调用对象中查找是否有a这个变量，如果没有，将会在作用域链的下一个对象，一般是全局对象中查找。但是事件处理程序没这么简单，特别是用HTML的属性定义的，它们的作用域链的头部是调用它们的对象，而下一个对象并不是全局对象，而是触发事件处理程序的对象。这样就会出现一个问题，window和document都有一个方法open()，如果open()前面不加修饰，那么在事件处理的函数中将会调用document.open()方法，而不是常用的window.open()方法，所以使用的时候应该明确指明是 window.open()。
（二）事件传播和注册事件处理程序
1.事件传播
　　在二级DOM标准中，事件处理程序比较复杂，当事件发生的时候，目标节点的事件处理程序就会被触发执行，但是目标节点的父节点也有机会来处理这个事件。事件的传播分为三个阶段，首先是捕捉阶段，事件从 Document对象沿着DOM树向下传播到目标节点，如果目标的任何一个父节点注册了捕捉事件的处理程序，那么事件在传播的过程中就会首先运行这个程序。下一个阶段就是发生在目标节点自身了，注册在目标节点上的相应的事件处理程序就会执行；最后是起泡阶段，事件将从目标节点向上传回给父节点，同样，如果父节点有相应的事件处理程序也会处理。在IE中，没有捕捉的阶段，但是有起泡的阶段。可以用stopPropagating()方法来停止事件传播，也就是让其他元素对这个事件不可见，在IE 6中，就是把cancelBubble设置为true。
2.注册事件处理程序
　　和IE一样， DOM标准也有自己的事件处理程序，不过DOM二级标准的事件处理程序比IE的强大一些，事件处理程序的注册用addEventListner方法，该方法有三个参数，第一个是事件类型，第二个是处理的函数，第三个是一个布尔值，true表示制定的事件处理程序将在事件传播的阶段用于捕捉事件，否则就不捕捉，当事件发生在对象上才触发执行这个事件处理的函数，或者发生在该对象的字节点上，并且向上起泡到这个对象上的时候，触发执行这个事件处理的函数。例如：document.addEventListener("mousemove",moveHandler,true);就是在mousemove事件发生的时候，调用moveHandler函数，并且可以捕捉事件。
　　可以用addEventListener为一个事件注册多个事件处理的程序，但是这些函数的执行顺序是不确定，并不像C#那样按照注册的顺序执行。
在Mozilla Firefox中用addEventListener注册一个事件处理程序的时候，this关键字就表示调用事件处理程序的文档元素，但是其他浏览器并不一定是这样，因为这不是DOM标准，正确的做法是用currentTarget属性来引用调用事件处理程序的文档元素。
3.二级DOM标准中的Event
和IE不同的是，W3C DOM中的Event对象并不是window全局对象下面的属性，换句话说，event不是全局变量。通常在DOM二级标准中，event作为发生事件的文档对象的属性。Event含有两个子接口，分别是UIEvent和MutationEvent，这两个子接口实现了Event的所有方法和属性，而 MouseEvent接口又是UIEvent的子接口，所以实现了UIEvent和Event的所有方法和属性。下面，我们就看看Event、 UIEvent和MouseEvent的主要属性和方法。
　　1.Event
　　 type：事件类型，和IE类似，但是没有“on”前缀，例如单击事件只是“click”。
　　 target：发生事件的节点。
　　 currentTarget：发生当前正在处理的事件的节点，可能是Target属性所指向的节点，也可能由于捕捉或者起泡，指向Target所指节点的父节点。
　　 eventPhase：指定了事件传播的阶段。是一个数字。
　　 timeStamp：事件发生的时间。
　　 bubbles：指明该事件是否起泡。
　　 cancelable：指明该事件是否可以用preventDefault()方法来取消默认的动作。
　　 preventDefault()方法：取消事件的默认动作；
　　 stopPropagation()方法：停止事件传播。
　　2.UIEvent
　　 view：发生事件的window对象。
　　 detail：提供事件的额外信息，对于单击事件、mousedown和mouseup事件都代表的是点击次数。
　　3.MouseEvent
　　　button：一个数字，指明在mousedown、mouseup和单击事件中，鼠标键的状态，和IE中的button属性类似，但是数字代表的意义不一样，0代表左键，1代表中间键，2代表右键。
　　　altKey、ctrlKey、shiftKey、metaKey：和IE相同，但是IE没有最后一个。
clientX、clientY：和IE的含义相同，但是在DOM标准中，这两个属性值都不考虑文档的滚动情况，也就是说，无论文档滚动到哪里，只要事件发生在窗口左上角，clientX和clientY都是0，所以在IE中，要想得到事件发生的坐标相对于文档开头的位置，要加上 document.body.scrollLeft和document.body.scrollTop。
　　　screenX、screenY：鼠标指针相对于显示器左上角的位置，如果你想打开新的窗口，这两个属性很重要。
　　　relatedTarget：和IE中的fromElement、toElement类似，除了对于mouseover和mouseout有意义外，其他的事件没什么意义。
（三）兼容于两种主流浏览器的拖动DOM元素的例子
　　好了，刚才讲了这么多DOM编程和IE中的事件，那么如何编写兼容IE和Mozilla Firefox两种主流浏览器的拖拽程序呢？代码如下：
function beginDrag(elementToDrag,event)
{
var deltaX=event.clientX-parseInt(elementToDrag.style.left);
var deltaY=event.clientY-parseInt(elementToDrag.style.top);

if(document.addEventListener)
{
document.addEventListener("mousemove",moveHandler,true);
document.addEventListener("mouseup",upHandler,true);
}
else if(document.attachEvent)
{
document.attachEvent("onmousemove",moveHandler);
document.attachEvent("onmouseup",upHandler);

}

if(event.stopPropagation)   event.stopPropagation();
else event.cancelBubble=true;
if(event.preventDefault) event.preventDefault();
else event.returnValue=false;

function moveHandler(e)
{
　　if (!e) e=window.event; //如果是IE的事件对象，那么就用window.event
　　//全局属性，否则就用DOM二级标准的Event对象。
    elementToDrag.style.left=(event.clientX-deltaX)+"px";
    elementToDrag.style.top=(event.clientY-deltaY)+"px";

     if(event.stopPropagation)   event.stopPropagation();
    else event.cancelBubble=true;

}

function upHandler(e)
{
       if(document.removeEventListener)
    {
      document.removeEventListener("mouseup",upHandler,true);
      document.removeEventListener("mousemove",moveHandler,true);}
      else
    {
      document.detachEvent("onmouseup",upHandler);
      document.detachEvent("onmousemove",moveHandler);}
    }
      if(event.stopPropagation)   event.stopPropagation();
    else event.cancelBubble=true;

最后我们来回顾一下事件执行过程中的三个阶段：
1 捕捉阶段，事件从Document对象沿Dom解析的树向下传播给目标节点。

2 目标节点触发阶段事件处理程序在目标上的运行阶段
3 起泡阶段事件从目标元素向上传播或者起泡回Document对象的文档层次。

评论: 0　查看评论　发表评论

ajax的原理和运行机制

ustbwuyi — Thu, 28 Sep 2006 06:42:00 GMT

阅读: 1059 评论: 2 作者: ustbwuyi 发表于 2006-09-28 14:42 原文链接

关于ajax，是最近炒得非常火的一种技术，并且时下它也是非常流行。当然，它并不是什么新技术，而是在各种已有的技术和支持机制下的一个统一。在我的项目中，偶尔也会用到ajax，用来给用户一些无刷新的体验。用过几次之后，我个人决定对它的原理和运行机制做一个总结。
    ajax这个名字据说是Asynchronous JavaScript + XML的简写，实际上，它由下列几种技术组合而成。

   1.使用CSS和XHTML来表示。
   2. 使用DOM模型来交互和动态显示。
   3.使用XMLHttpRequest来和服务器进行异步通信。
   4.使用javascript来绑定和调用。

ajax的原理
XMLHttpRequest是ajax的核心机制，它是在IE5中首先引入的，是一种支持异步请求的技术。简单的说，也就是javascript可以及时向服务器提出请求和处理响应，而不阻塞用户。达到无刷新的效果。
所以我们先从XMLHttpRequest讲起，来看看它的工作原理。
首先，我们先来看看XMLHttpRequest这个对象的属性。
它的属性有：
onreadystatechange 每次状态改变所触发事件的事件处理程序。
responseText     从服务器进程返回数据的字符串形式。
responseXML   从服务器进程返回的DOM兼容的文档数据对象。
status                 从服务器返回的数字代码，比如常见的404（未找到）和200（已就绪）
status Text         伴随状态码的字符串信息
readyState         对象状态值，0—未初始化 1—正在加载 2—加载完毕 3—交互 4—完成。

  但是，由于各浏览器之间存在差异，所以创建一个XMLHttpRequest对象可能需要不同的方法。这个差异主要体现在IE和其它浏览器之间。
下面是面对不同浏览器分别创建的XMLHttpRequest对象。

这个过程分为三步，首先我们定义一个xmlHttp来引用创建的XMLHttpRequest。然后，我们尝试在微软的浏览器中创建该对象，先用Msxml.XMLHTTP对象来创建，如果失败再尝试用macrosoft.XMLHTTP来创建它．最后，我们面向非微软浏览器来创建该对象．
　这样，我们创建了一个XMLHttpRequest对象，下面我们来看如何发出一个XMLHttpRequest请求。

由上面可见，执行XMLHttpRequest实际上大多数代码还是用在处理浏览器的区别上面，针对不同的浏览器它还是要做出不同的处理，但是这样看上去也非常的直观。
在上面的代码中，最关键的是：
xhr.onreadystatechage=callback 它定义了回调函数，一旦响应它就会自动执行。
xhr.open(""Get",url,true); true表示您想要异步执行该请求。

对于callback来说，我们有：

function processAjaxResponse() {
//状态标识为已完成
  if (xhr.readyState == 4) {
//已就绪
    if (xhr.status == 200) {
      502 502'votes').innerHTML = xhr.responseText;
    } else {
      alert("There was a problem retrieving the XML data:
" +
      xhr.statusText);
    }
  }
}

就是说，一旦服务器处理完XMLHttpRequest并返回给浏览器，用xhr.onreadystatechange指派的回调方法将自动调用。

上面差不多就是XMLHttpRequest的整个工作流程，它首先检查XMLHttpRequest的整体状态并且保证它已经完成（readyStatus=4），然后根据服务器的设定询问请求状态，如果一切已经就绪（status=200），那么就执行下面需要的操作。

知道了XMLHttpRequest的工作流程，我们可以看出，XMLHttpRequest是完全用来向服务器发出一个请求的，它的作用也局限于此，但它的作用是整个ajax实现的关键，因为ajax无非是两个过程，发出请求和响应请求。并且它完全是一种客户端的技术。而XMLHttpRequest正是处理了服务器端和客户端通信的问题所以才会如此的重要。
现在，我们对ajax的原理大概可以有一个了解了。我们可以把服务器端看成一个数据接口，它返回的是一个纯文本流，当然，这个文本流可以是XML格式，可以是Html，可以是Javascript代码，也可以只是一个字符串。这时候，XMLHttpRequest向服务器端请求这个页面，服务器端将文本的结果写入页面，这和普通的web开发流程是一样的，不同的是，客户端在异步获取这个结果后，不是直接显示在页面，而是先由javascript来处理，然后再显示在页面。至于现在流行的很多ajax控件，比如magicajax等，可以返回DataSet等其它数据类型，只是将这个过程封装了的结果，本质上他们并没有什么太大的区别。

评论: 2　查看评论　发表评论

DOM模型概述

ustbwuyi — Thu, 24 Aug 2006 03:06:00 GMT

阅读: 1610 评论: 0 作者: ustbwuyi 发表于 2006-08-24 11:06 原文链接

   自从W3C建立了DOM标准 (W3C DOM)之后，以及DOM和浏览器兼容之后，DOM在实际应用中越来越广泛。
   DOM是Document  Object Model的简称，中文名称为文档对象模型。它的主要作用是建立网页与 Script 或程序语言沟通的桥梁。

我们平时可操作及建立文件的属性、方法及事件都以并且用“对象”来展现（例如，document 就代表“文件本身”这个对象，table 对象则代表 HTML 的表格对象等等）。这些对象可以由当今大多数的浏览器以 Script 来取用。

   DOM 常用来和JavaScript交互，也就是说程序以 JavaScript写成，但使用 DOM 来存取页面及其元素。它们两者之间的结合非常紧密，甚至可以说如果没有DOM，我们在使用javascript的时候是不可想象的，因为我们每解析一个节点一个元素都要耗费很多精力，DOM 本身是设计为一种独立的程序语言，以一致的 API 存取文件的结构表述；当然除了JavaScript，DOM可还可以与任何程序语言共同运作，如C/C++、VB、VBS。

   在和JavaScript进行交互的时候，DOM主要用来解析XML文档，当你的应用程序需要不断地导航、修改文档或随机地一次访问整个文档时，我们一般就使用DOM来解析。
   在使用DOM进行解析的时候，它在内存中构建起一棵完整的解析树，借此实现对整个XML文档的全面、动态访问。也就是说，它的解析是有层次的，即将所有的html中的元素都解析成树上层次分明的节点，然后我们可以对这些节点进行增删改查等操作，这是对DOM模型的作用的最完善的总结。
   和SAX不同，SAX是顺序解析的，与DOM相比，SAX解析器能提供更好的性能优势，它提供对XML文档内容的有效低级访问。
   SAX模型最大的优点是内存消耗小，因为整个文档无需一次加载到内存中，这使SAX解析器可以解析大于系统内存的文档。另外，你无需像在DOM中那样为所有节点创建对象。最后，SAX“推”模型可用于广播环境，能够同时注册多个ContentHandler，并行接收事件，而不是在一个管道中一个接一个地进行处理。但是SAX的一些缺点使它的流行性不如DOM。

DOM的使用非常简单。你可以随机地访问XML文档，由于整个树都构建在内存中，因此可以通过DOM API修改这些节点，例如增加一个子节点或修改、删除一个节点。
不过，虽然内存树结构提供了很好的导航支持，但仍有一些解析策略问题需要仔细考虑。首先，整个XML文档必须一次解析完成，不可能只做部分解析；其次是效率问题，在内存中加载整个文档和构建完整树结构的成本很高，尤其当文档非常大的时候。典型地，DOM树的容量比文档容量要大一个数量级，所以它要消耗大量内存；第三，一般的DOM节点类型在互操作性上有优势，但对于对象类型绑定也许不是最好的。

评论: 0　查看评论　发表评论