Silverlight_Team

 

 

转载自：http://www.360doc.com/content/090305/19/15822_2721806.html

首先看一下IDE方面的改进：
1）javacscript html css 智能感知，这个功能还是比较期待的
2）javascript调试功能
3）html编辑器在源文件和设计的基础增加split查看方式，这样就可以边改源文件边查看效果了
4）智能感知方面，在可选列表可见状态下按下Ctrl键，可以使列表透明，以查看被遮盖的部分，松开Ctrl后继续进行选择。
5）在创建项目之前，可以选择.net framework 的版本。这样，在使用vs 2008 强大IDE 的同时，可以创建 .基于net fx2.0 或 .net fx 3.0 的项目，而不用切换到vs2005下面。 

重要的还是语言特性方面的改进：
1）扩展方法：
     扩展方法允许编程人员在静态类上编写自己的方法，以扩充静态类的功能。
     比如我们可以写这样一个方法：
     public static bool IsPrime(this int integer)
     {
           if(integer == 1)
            {
                   return false;
            }
            for(int i = 2;i <= Math.Sqrt(integer); i++)
            {
                    if(integer % 2 == 0)
                           return false; 
             }
             return true;
      }
之后就可以这么写：
      int i = 1798517;
      if(i.IsPrime())
      {
              Console.WriteLine(i);
      } 

注意 static 和 this  关键字。这样做可以使程序更符合人的思维，更接近自然语言。看我们现在是怎么做的：
定义一个MyUtils类：
Class MyUtils
{
       public bool IsPrime(int integer)
       {
           if(integer == 1)
            {
                   return false;
            }
            for(int i = 2;i <= Math.Sqrt(integer); i++)
            {
                    if(integer % 2 == 0)
                           return false; 
            }
             return true;
      }
}
使用：
MyUtil mu = new MyUtil（);
bool flag = mu.IsPrime(12517)
if(flag)
{
 ......
}
2） lambda表达式
.net 2.0 引进了匿名方法，.net 3.5进一步引进了lambda表达式来简化。
lambda表达式允许这样写:
IEnumerable <Book> cheapBooks = books.where(b => b.Price <=50)
(where 关键字是下面要提到的Linq中提供的功能)
相应的匿名方法:
IEnumerable <Book> cheapBooks = books.where(
                                                                 delegate(Book b)
                                                                 {
                                                                         return b.Price <=50;
                                                                }
                                                                );
3）Linq 语言集成查询(Language Integrated Query)
.net 3.5中增加了很多查询关键字，这样就可以直接编写查询，而不用再写sql语句。例如:
         var cheapBooks = from book in books
                                 orderby book.Price 
                                 select book.Name, book.Author,book.Price
                                 where book.Price <= 50
books可以使一个数组，可以使一个集合，可以是XML文件也可以是数据库里的一个表
4）自动属性
自动属性允许编程人员在定义一个类时作如下简化:
public class Book
{
        public string Name{ get; set; }
        public string Author{ get; set; }        
        public int    Price{ get; set; }
}
当然也可以没有set，如果属性是只读的话。这样就免去了定义私有的 _name, _author, _price及get set方法体，编译器会自动生成相应的私有变量和方法体。
5）对象初始化器，集合初始化器
在2.0中，我们这初始化一个对象；
Book book = new Book();
book.Name = "C# in a nutshell";
book.Author = "Peter Drayton";
book.Price = 30;
3.5中我们可以这么写：
Book book = new Book
{
        Name = "C# in a nutshell", Author = "Peter Drayton",Price = 30;
}
集合初始化器允许我们批量添加对象，而不用一条一条的用add方法添加：
List<Book> books = new List<book>
{
        new Book{Name = "C# in a nutshell", Author = "Peter Drayton",Price = 30;};
        new Book{Name = "Ajax in a nutshell", Author = "Peter Drayton",Price = 40;};
         new Book{Name = "Python in a nutshell", Author = "Peter Drayton",Price = 50;};
};
6)隐式本地变量
3.5中引入了var关键字，允许开发者在定义变量时不指定类型：
var a  = 15;
var b = new string[] {"a","b","c","d"}
但是c#仍然是强类型的，只不过编译器是根据后面所赋的值来推断出变量的类型，因此赋值是必须的，且只能有一种类型，定义后也就不能再进行改变，它在Linq 中非常有用，能极大地简化代码。
7）匿名变量
var w = new [] {"a","b","c","d"}
var b = new {Name  = "xml", Author = "aa",Price = 50};
C# 编译器会自动生成一个完整的匿名类包括私有字段，属性，get set，还有最后的赋值语句

 

Candy.Zhai

ssy1990 21:08:05
有没有人？
青润 21:14:50
??
ssy1990 21:16:50
java编写的，那两个应用程序可以可以连接，但就是没有显示要求接收的字符

青润 21:17:55
你的表达，我看不懂。
苦行憎  21:19:38
说的详细点，是socke连接吗，还是webservices，说不清楚，青润大哥没有办法帮你解决哈
ssy1990 21:19:51
socket
ssy1990 21:19:54
恩
苦行憎  21:20:00
否则就是浪费时间
ssy1990 21:22:49
就是客户机通过输出流对象把字符串”hello“发送到服务器
然后服务器通过输入流对象接收到”hello“，在服务器窗口显示出来，并向客户机发出确认的字符串”ok”，但是这个都没有

青润 21:24:48
这个只能看代码，你说的都是可以实现的东西，不是不可以实现的，所以，没办法帮你。
ssy1990 21:25:36
代码方面是不是缓冲区的问题？
青润 21:26:09
从这里看不出来问题。
苦行憎  21:26:25
客户端和服务端的控制台都打印了那些东西，是不是控制台没有切换，这方面的知识网上很多哈
青润 21:26:57
建议你考虑调试方式，进行单步打印，看看控制台输出信息，来判断问题在哪里
苦行憎  21:27:08
 
ssy1990 21:27:22
恩，好的，我试试，谢谢指教哈
青润 21:27:43
这是代码出现问题时侯，最常用的办法。
ssy1990 21:28:23
嗯嗯.....
谢谢了
青润 21:28:23
除非你自己分析不出来，逻辑判断出现错误，否则，一般情况下都能找到问题所在。
ssy1990 21:29:05
一般调试的好少，一遇到问题就上网查了
青润 21:29:40
调试，是程序员的基本功，这个都不做，我可以认为，你根本不会写程序。
ssy1990 21:30:32
恩恩.....
知道了，今后努力提高

 

后记：

调试的手段有很多种，这个网络上可以查到很多，就不赘述了。

很多人遇到代码问题就到处找人问，找人看代码，其实，至少百分之七八十是因为他不懂得如何调试。而且，调试是需要部署同样的环境，还需要花费大量时间，所以，我一般都拒绝给别人看代码。

另外，调试和测试不同，也有些人拿调试来替代测试，这也是常遇到的一些严重问题。

 

唐月华

现在距离gmail改变大家对使用网页应用程序的方式,已经有一年多了。但是目前很多网页应用程序,并没有使用充满活力的Ajax的优势,来代替以前沉闷的html功能。

下面是当前网页应用程序应该出现的地方：

• 基于表单的交互

表单是很慢的，非常慢。尝试编辑位于del.icio.us上面的一个书签？点击编辑链接打开一个编辑书签的表单页面，然后编辑你的内容并点击提交按钮等待整个提交过程结束，最后返回上一页并向下滚动到你刚才编辑的书签那里查看内容是否已经正确更改。那AJAX呢？点击编辑链接马上开始更改标签内容，点击提交按钮开始异步传输标签编辑的内容并立即看到更改后的内容而无需重载整个页面。

• 深层树状导航

总而言之，带有深层树状导航的应用程序通常是一个噩梦。在大多数情况中简单平直的拓扑结构以及搜索/标记可以很好的工作。但是如果一个应用程序真正使用深层树状导航，使用JavaScript来管理拓扑ui(user interface用户接口)，则使用Ajax懒加载深层数据可以降低服务器的负载。举例来说，为了阅读一个只有一行的结果来加载整个一个新页面是非常耗时的。

• 实时用户对用户通讯

在一个允许用户创建实时讨论的信息公告系统中，迫使用户一次又一次的更新完页面看到答复是非常愚蠢的。回复应该是实时的，用户不应被迫总是去痴迷于刷新操作。即使是gmail这个已经对以前像hotmail/yahoo mail的收件箱刷新，刷新收件箱标记的操作有所改进，也并没有充分的使用Ajax的功能来提示有新邮件到达。

• 投票、是否选择、等级评价

如果Ajax提交过程没有一个协调的UI提示是非常糟糕的，通过使用Ajax来提交一个调查或是否选择可以减少提交过程等待的痛苦。通过减少点击的等待时间，Ajax应用程序变得越来越有交互性-如果要用40秒来提交一个投票，除非非常在意的话大多数人会选择放弃。如果只花1秒呢，非常大比例的人会乐于参加投票的。（我在Netflix versus有2008张电影投票在IMDb.com有210张电影投票）

• 过滤和复杂数据操作

应用一个过滤、按日期排序、按日期和姓名排序、打开或关闭过滤器等等。任何一种高交换型操作应该交给JavaScript来处理而不是通过向服务器来提交一系列的请求。在查找或者操作大量数据的时候带来的视图上的改变最多不会超过30秒，Ajax真的使这些操作加速了。

• 普通录入时的提示/自动补齐

一些软件/JavaScript是擅长于帮助用户完成键入相同的文字或可以预测的文字的工作的。在del.icio.us 和 Gmail 中该功能是非常有益的，可以用来快速增加标记/email等。

对于一个频繁使用的应用程序诸如网页邮件客户端或博客阅读器来说，用户有充足的时间来学习如何使用新的UI概念但是他们却无法接受一个非常缓慢 的反应速度。这种应用为Ajax变的更加普及起到了一个完美的杠杆作用。随着用户使用频率的增加，更多的Ajax部件应该加强用户的使用体验。

但是对于网页应用程序来说，把每件事甚至任何事都用JavaScript来实现也是没有意义的。Ajax只是针对一些特定的环境才能带来显著的 帮助。在Ajax出现之前网页应用程序已经可以工作的很好了并且目前在网页开发中Ajax还存在着许多的缺陷和缺点。就算不从服务器端取得一个异步的信息 数据流一个平直的html网页日志也可以工作的很好。对于文档或文档之间的跳转来说，老旧的纯HTML仍然是最好的选择。简单或很少使用的应用程序就算不 用JavaScript同样可以很好的工作。

下面是一些不应该用到Ajax的地方：

• 简单的表单

就算表单是Ajax技术的最大受益人，一个简单内容的表单，或提交订货单，或一次性的很少用到的表单都不应该使用以Ajax驱动的表单提交机制。总的来说，如果一个表单不是很长用，或已经工作的很好，那么就算使用Ajax也没有什么帮助。

• 搜索

实时搜索带来的痛苦要远大于他带来的帮助。这就是为什么Google Suggest还处于beta测试而并没有放在主页上的原因。在Start.com Live.com上搜索的时候你是不能使用返回按钮来查看上一次搜索或返回上一页的。或许还没有人来完成这项工作，但是完成这个工作应该是很困难的至少是不太明知的或者会因此带来更多的麻烦。（译注：现在已经有很多开源的框架可以实现历史记录功能）

• 基本导航

总的来说，使用Ajax为一个基础的网站/程序做导航是一个可怕的念头。谁会把用来使自己的程序变的更好的时间花在编写代码模仿浏览器的行为上面？在基础页面中导航的操作中JavaScript是没有用的。

• 替换大量的信息

Ajax可以不用整页刷新来动态更新页面中改变的一小部分。但是如果一页上的大部分内容都需要更新，那为什么不从服务器那里获得一个新页面呢？

• 显示操作

虽然看上去Ajax是一个纯UI技术，其实不是这样的。他实际上是一个数据同步、操作、传输的技术。要想得到一个稳定的干净的网页程序，不使用Ajax/JavaScript来直接完成用户接口是明智的。JavaScript可以分散分布并简单的操作XHTML/HTML DOM，根据CSS规则来决定如何让UI显示数据。查看

这里（http://www.sourcelabs.com/blogs/ajb/2005/08/powering_javascript_ui_with_cs.html）

来查看如何使用CSS来替代JavaScript来控制数据的显示。

• 无用的网页小部件

滑块选择控件、拖拽控件、弹性控件（此处原文为bouncies，不知指为何物？）、鼠标样式、天气预报控件，这些小部件应该可以被更直接的控件代替或者为了整洁干脆整个去掉。为了选择一种颜色，也许滑块选择控件可以选择一个正确的阴影颜色，但是在一个商店中选择一个价格，使用滑块选择控件选到分这个单位对于用户来说有点过分。

 

唐月华

1. $() = $(document)  
2. //实现window.onload()效果  
3. $().ready(  
4.     function(){  
5.         //需要执行的内容  
6.     }  
7. );  
8. //获取DOM元素(返回值为jQuery对象)  
9. $("element") //相应元素名的  
10. $(".classname") //class值匹配的  
11. $("element.classname") //相应元素中，class值匹配的  
12. $("#id") //id匹配的  
13. $("element#id") //相应元素中，id匹配的  
14. $("element1 > element2") //元素一 下 的所有元素二（只包括儿子）  
15. $("element1 element2")      //元素一 中 的所有元素二（包括子孙等）  
16. $("element1 + element2")    //元素一 后 的所有元素二（代码后）  
17. $("element1 ~ element2")    //与元素一 并列 的所有元素二（兄弟元素二）  
18. $("#id").html("")   //设置 getElementById("id").innerHTML = ""  
19. $("#id").html()     //取出 getElementById("id").innerHTML  
20. //动画出现效果  
21. $("#id").show(speed, [callback])  
22. $("#id").slideDown(speed, [callback])  
23. ……  
24.   
25. /*========= 
26.  2009-1-16 
27. =========*/  
28. //在<p>外面包围另一个结构（html代码/元素）  
29. $("p").wrap("<div class='wrap'></div>")  
30. $("p").wrap(document.getElementById('content'))  
31. $("p").append("<b>Hello</b>");  //<p>I would like to say: <b>Hello</b></p>  
32. $("p").prepend("<b>Hello</b>"); //<p><b>Hello</b>I would like to say: </p>  
33. $("p").before("<b>Hello</b>");  //<b>Hello</b><p>I would like to say: </p>  
34. $("p").after("<b>Hello</b>");   //<p>I would like to say: </p><b>Hello</b>   
35. //【删除相应class的p元素】  
36. //<p class="classname">AAA</p> BBB <p>CCC</p>  
37. //BBB <p>CCC</p>  
38. $("p").remove(".classname");  
39. /*========= 
40.  2009-1-18 
41. =========*/  
42. //获取具有某属性值的相应元素  
43. $("input[name=qq]") //获取<input name="qq" type="text" />元素  
44. //属性与值关系  
45. =   //等于  
46. *=  //包含该值  
47. !=  //不包含该值  
48. ^=  //以该值开头  
49. $=  //以该值结尾  
50. //为每一个匹配的元素执行该函数  
51. $("element").each(function(){  
52.     //需要执行的内容  
53. })    
54. /*========= 
55.  2009-1-19 
56. =========*/  
57. /* 
58. jQuery中用post和get方法 
59. （ajax高层抽象方法，对ajax方法进行了封装） 
60. 【当JQ中用post方式】 
61. PHP用$_POST接收时，只有n2 
62. PHP用$_GET接收时，只有n1 
63. 【当JQ中用get方式】 
64. PHP用$_GET接收，n1 n2都有 
65. PHP用$_POST接收时，都没有 
66. */  
67. $.post("do.php?n1=a", {n2: "b"},      
68.     function(data){  
69.         ;  
70.     }  
71. );  
72. /*========= 
73.  2009-1-20 
74. =========*/  
75. //DOM对象 -> jQuery对象  
76. //$(DOM对象)  
77. var v = document.getElementById("id");  //DOM对象 v   
78. var $v = $(v); //jQuery对象 $v  
79. //jQuery对象 -> DOM对象  
80. //jQuery对象.get(0) 或者 jQuery对象[0]  
81. var $v = $("#id");  //jQuery对象 $v  
82. var v = $v.get(0); //DOM对象 v  
83. var v = $v[0]; //DOM对象 v  
84. $("element").get(); //获取指定元素的集合  
85. //jQuery用ajax方法（ajax低层方法）  
86. $.ajax({  
87.     type:   "POST", //POST时PHP中用$_POST接收，GET反之。  
88.     url:    "do.php",  
89.     data:   "n1="+x+"&n2="+y,  
90.     success: function(data){ ; }   
91. });  
92. /*========= 
93.  2009-1-21 
94. =========*/  
95. //序列表表格内容为请求字符串  
96. //返回值：（例）name=linvo&age=22  
97. $("form").serialize() //序列化整个表单元素内容  
98. $("input[type=text]").serialize() //序列化指定元素内容（例）  
99. $("element").empty(); //移除指定元素下所有元素  
100. /* 
101.  CSS设置 
102. */  
103. $("element").addClass("classname"); //为指定元素添加css样式  
104. $("element").removeClass("classname") //移除指定元素的css样式  
105. $("element").toggleClass("classname") //指定元素的css样式，有则删除，无则添加  
106. $("element").css("attname"); //获取指定元素相应属性的值（attname例：color）  
107. $("element").css("attname","value"); //设置……属性值（例："color","#FF0000"）  
108. $("element").css({ "margin-left": "10px", "background-color": "blue" });   
109. //使用“名/值对”进行批量设置……（例子见自身）  
110. /*========= 
111.  2009-1-22 
112. =========*/  
113. $("element1").next(element2) //与指定元素一 紧邻 的指定元素二  
114. $("element1").parent().is(element2) //元素一的父元素在元素二的集合中吗   
115. //模仿鼠标悬停事件  
116. //hover(over,out)  
117. //over:在上方执行 | out：移出时执行  
118. $("element").hover(  
119.     function(){  
120.         //在上方执行  
121.     }, function(){  
122.         //移出时执行  
123.     }  
124. ) 
     

Lad.li

Lad.li

 

Lad.li

   假设我们公司有两种程序员：VB程序员，指的是用VB写程序的程序员，用clsVBProgramer这个类表示；Delphi程序员指的是用Delphi写程序的程序员，用clsDelphiProgramer这个类来表示。 每个类都有一个WriteCode()方法。定义如下：

class clsVBProgramer()
{
  ....
  WriteCode()
  {
     //用VB语言写代码；
  }
  ....
}

class clsDelphiProgramer()
{
  ....
  WriteCode()
  {
    //用Delphi语言写代码；
  }
   ....
}

现在公司来了一个项目，要求派某个程序员写一个程序。
class clsProject()
{
  ....
  WritePrograme(clsVBProgramer programer)//用VB写代码
  {
    programer.WriteCode();
  }
  WritePrograme(clsDelphiProgramer programer)//重载方法，用Delphi写代码
  {
    programer.WriteCode();
  }
 ......
}
在主程序中我们可以这样写：
main()
{
   clsProject proj=new  clsProject;
   //如果需要用VB写代码
   clsVBProgramer programer1=new clsVBProgramer;
   proj.WritePrograme(programer1);
   //如果需要用Delphi写代码
   clsDelphiProgramer programer2=new clsDelphiProgramer;
   proj.WritePrograme(programer2);
}

但是如果这时公司又来了一个C#程序员，我们怎么改这段程序，使它能够实现用C#写程序的功能呢？我们需要增加一个新类clsCSharpProgramer,同时在此clsProject这个类中要再次重载WritePrograme（clsCSharpProgramer programer）方法。这下麻烦多了。如果还有C程序员，C++程序员，JAVA程序员呢。麻烦大了！

但是如果改用接口，就完全不一样了：
首先声明一个程序员接口：
interface IProgramer()
{
  WriteCode();
}
然后声明两个类，并实现IProgramer接口：
class clsVBProgramer():IProgramer
{
  ....
  WriteCode()
  {
     //用VB语言写代码；
  }
  ....
}

class clsDelphiProgramer():IProgramer
{
  ....
  WriteCode()
  {
    //用Delphi语言写代码；
  }
   ....
}
对clsProject这个类进行一下修改：
class clsProject()
{
  ....
  WritePrograme(IProgramer programer)
  {
    programer.WriteCode();//写代码
  }
  ......
}

main()
{
   clsProject proj=new  clsProject;
   IProgramer programer;
   //如果需要用VB写代码
   programer=new clsVBProgramer;
   proj.WritePrograme(programer);
   //如果需要用Delphi写代码
   programer=new clsDelphiProgramer;
   proj.WritePrograme(programer);    
}
如果再有C#，C，C++，JAVA这样的程序员添加进来的话，我们只需把它们相关的类加进来，然后在main()中稍做修改就OK了。扩充性特别好！

另外我们如果把clsProject这个类封成一个组件，那么当我们的用户需要要扩充功能的时候，我们只需要在外部做很小的修改就能实现，可以说根本就用不着改动我们已经封好组件！是不是很方便，很强大！
Lad.li

在开发Web应用时，无一例外地需要访问数据库，以完成对数据的查询、插入、更新、删除等操作。受应用逻辑的影响，有时需要将多条数据库操作指令组成一个工作单元（事务）。在数据库中，所谓事务是指一组逻辑操作单元，它使数据从一种状态变换到另一种状态。为确保数据库中数据的一致性，应当用离散的成组的逻辑单元操作数据：当它全部完成时，数据的一致性可以保持;而当单元中的一部分操作失败时，整个事务会被全部忽略，所有从起始点以后的操作全部退回到开 始状态。
实际上，在默认方式下对数据库的每一次操作都是隐含的事务处理。本文以一个典型的用户注册程序为例，介绍三种利用 ASP实现事务处理的方法：基于ASP数据库组件的解决方法、基于数据库内部的事务处理机制的解决方法和基于MTS组件的解 决方法。

程序功能
在SQL Server数据库中建立两个表：USER表和USERDOC表。其中USER表中存放的是注册用户的用户名和密码，USERDOC表中存放的是该注册用户的个人资料，并且以用户名为索引。下面是表USER和USERDOC的定义：
Create Table USER(userName varchar(30),userPasswd varchar(30))
Create Table USERDOC(userName varchar(30),Age int,Sex int,PhoneNumber varchar(20),Address varchar(50))
当用户请求注册时，ASP脚本先将用户名和密码插入到USER表中，然后在USERDOC表中插入用户个人信息（年龄、性别、联系电话和家庭住址等）。同时，应用程序还必须保证USER表中的每一条记录在USERDOC表中都有相应的记录。
方法一
利用ASP内置ADO组件中的Connection对象可以实现对数据库操作的事务性处理。Connection对象的部分方法如下：
●Connection.BeginTrans方法：启动一个事务;
●Connection.CommitTrans方法：完成/提交一个事务;
●Connection.RollBackTrans方法：撤消/放弃一个事务。
//启动一个事务操作
<% Conn.BeginTrans %>
<% sqlText=“Insert into USER(userName,userPasswd) values(‘” %>
<% sqlText=sqlText ＆ request(“usrName”) ＆ “’，‘”＆request(“usrPasswd”)＆“’) ” %>
<% conn.execute(sqlText) %>
<% if conn.Errors.Count>0 then %>
<% conn.Errors.Clear %>
//如果插入数据操作失败，则事务向前回滚
<% conn.RollBackTrans %>
<% response.Redirct RegisterFail.html %>
<% end if %>
<% sqlText=“Insert into USERDOC(userName,Age,Sex,PhoneNumber,Address) ”%>
<% sqlText=sqlText ＆ “values(‘”＆ request
(“usrName”) ＆ “’, ” ＆ request(“Age”) %>
<% sqlText=sqlText ＆ “,‘” ＆ request
(“PhoneNum”) ＆ “’,‘” %>
<% sqlText=sqlText ＆ request(“Address”) ＆ “’) ” %>
//执行事务单元中的第二条插入语句
<% conn.execute(sqlText) %>
<% if conn.Errors.Count>0 then %>
<% conn.Errors.Clear %>
//如果操作失败，则事务向前回滚
<% conn.RollBackTrans %>
<% response.Redirct RegisterFail.html %>
<% end if %>
//如果整个事务操作执行正确，则提交事务
<% Conn.CommitTrans %>
//转向注册成功处理页面
<% response.Redirct RegisterOk.html %>
方法二
可以利用数据库系统内部的事务处理机制，通过在数据库服务器中编写包含事务的存储过程，完成对数据操作的事务处理。同时，利用ADO组件调用存储过程，还可以根据存储过程的返回代码判断事务处理是否执行成功。
在数据库系统中，每一条SQL语句都是一个事务。因此可以保证每条语句要么完成，要么退回到开始之处。但是如果希望一组SQL语句的操作要么全部完成，要么全部无效，就需要利用数据库的事务处理机制来实现。
在数据库中生成存储过程的主要代码如下：
Create proc RegisterUser
(@usrName varchar(30), @usrPasswd varchar(30),@age int, @PhoneNum varchar(20), @Address varchar(50) )
as
begin
//显示定义并开始一个事务
begin tran
insert into USER(userName,userPasswd) values(@usrName,@usrPasswd)
if @@error<>0
begin
//操作失败，则事务回滚
rollback tran
//返回存储过程，并设置返回码为事务操作失败
return －1
end
insert into USERDOC(userName,age,sex,PhoneNumber,Address)
values(@Usrname,@age,@PhoneNum,@Address)
if @@error<>0
begin
//操作失败，则事务回滚
rollback tran
return －1
end
//如果操作执行正确，则提交事务
commit tran
return 0
end
在ASP脚本中调用数据库存储过程的主要代码如下：
<% Set Comm=server.CreateObject
(“ADODB.Command”) %>
<% Set Comm.ActiveConnection=conn %>
<% Comm.CommandType=adCmdStoredProc %>
<% Comm.CommandText=“RegisterUser” %>
//创建存储过程返回参数对象
<% Set RetCode=Comm.CreateParameter
(“RetCode”,adInteger,adParamReturnValue) %>
//创建存储过程输入参数对象
<% Set usrName=Comm.CreateParameter
(“usrName”,adVarchar,adParamInput,30) %>
<% Set usrPwd=Comm.CreateParameter
(“usrPasswd”,adVarchar,adParamInput,30) %>
<% Set age=Comm.CreateParameter(“age”,adInteger,adParamInput) %>
<% Set PhoneNum=Comm.CreateParameter
(“PhoneNum”,adVarchar,adParamInput, 20) %>
<% Set Address=Comm.CreateParameter(“Address”,adVarchar,adParamInput,50) %>
<% Comm.Parameters.Append usrName %>
<% Comm.Parameters.Append usrPwd %>
<% Comm.Parameters.Append age %>
<% Comm.Parameters.Append PhoneNum %>
<% Comm.Parameters.Append Address %>
<% Comm.Parameters(“usrName”)=request
(“usrName”) %>
<% Comm.Parameters(“usrPasswd”)=request
(“usrPasswd”) %>
<% Comm.Parameters(“age”)=request(“age”) %>
<% Comm.Parameters(“PhoneNum”)=request
(“PhoneNum”) %>
<% Comm.Parameters(“Address”)=request
(“Address”) %>
<% Comm.Execute %>
<% RetValue=Cint(Comm(“RetCode”)) %>
//根据数据库存储过程返回代码判断注册是否成功
<% if RetValue< 0 then %>
<% response.Redirect RegisterFail.html %>
<% else %>
<% response.Redirect RegisterOk.html %>
<% end if %>
方法三
利用MTS(Microsoft Transaction Server)组件的事务处理机制实现事务处理时，需要特别注意的是，这种机制下的事务不能跨越多个ASP页，如果一个事务处理需要来自多个组件的对象，则须将对这些对象的操作组合在一个ASP页中。
首先需要在页首添加指令@TRANSACTION，将一个ASP页面声明为事务性。@TRANSACTION指令必须在一页中的第一行，否则将产生错误。当页面中ASP脚本处理结束时，当前事务即告结束。
<%@ TRANSACTION=Required Language=
VB Script %>
//事务执行成功触发事件
<% Sub OnTransactionCommit() %>
<% response.Redirect RegisterOk.html %>
<% End Sub %>
//事物执行失败触发事件
<% Sub OnTransactionAbort() %>
<% response.Redirect RegisterFail.html %>
<% End Sub %>
<% sqlText=“Insert into USER(userName,userPasswd) values(‘” %>
<% sqlText=sqlText ＆ request(“usrName”) ＆ “’,‘” ＆request(“usrPasswd”)＆“’) ” %>
<% conn.execute(sqlText) %>
<% if conn.Errors.Count>0 then %>
<% conn.Errors.Clear %>
<% ObjectContext.SetAbort %>
<% end if %>
<% sqlText=“Insert into USERDOC(userName,Age,Sex,PhoneNumber,Address) ”%>
<% sqlText=sqlText ＆ “values(‘” ＆ request
(“usrName”)＆ “’, ” ＆ request(“Age”) %>
<% sqlText=sqlText ＆ “,’” ＆ request
(“PhoneNum”) ＆ “’,‘” %>
<% sqlText=sqlText ＆ request(“Address”) ＆ “’) ” %>
<% conn.execute(sqlText) %>
<% if conn.Errors.Count>0 then %>
<% conn.Errors.Clear %>
<% ObjectContext.SetAbort %>
<% end if %>
<% ObjectContext.SetComplete %>
方案比较
从灵活的角度考虑，选择采用ASP数据库组件的方法具有一定的优势：既可以选用ADO数据库组件完成事务处理，同时还可以根据实际需要，定制自己的数据库组件（只要满足ASP组件编写规范即可）。如果从数据库事务处理的可靠性等角度考虑，则采用数据库内部的事务处理存储过程更好。这样可以直接利用数据库事务机制完成应用程序的逻辑事务处理，安全可靠，并且减少了Web服务器与数据库服务器之间的数据交互。这一点对分布式数据库系统尤为重要。采用MTS组件的事务处理方法的优势在于：由MTS服务器直接控制和管理组件（在MTS中注册的组件）操作的完成和撤消，具有良好的扩展空间和应用前景，可以充分发挥MTS的技术优势，增强网络应用的容错性能，提高IIS Web服务器的动态性能。

张海