摘要: 1. 下载并安装.Net Framework 2.0 http://www.microsoft.com/downloads/details.aspx?FamilyID=0856EACB-4362-4B0D-8EDD-AAB15C5E04F5&displaylang=zh-cn2. 生成数据库--1)创建数据库USE[master]GO/******创建数据库前,检查是否已存在相同名字的数据...  阅读全文
posted @ 2007-06-27 18:15 MK2 阅读(144) | 评论 (0)编辑
Master page,Theme
记录学习Asp.net 2.0期间的点点滴滴.......
posted @ 2006-10-21 15:55 MK2 阅读(56) | 评论 (8)编辑
     摘要: ASP.NET "Atlas" enables you to create browser-based applications that feature a highly responsive UI and that can harness the power of the server. This brings a richer user experience to Web applicati...  阅读全文
posted @ 2006-10-18 18:58 MK2 阅读(168) | 评论 (0)编辑

In part 1 of this post, I exposed the differences between the closure and the prototype patterns to define JavaScript classes. In this post, I'll show the shortest path to convert an existing class built using Atlas and closures to a prototype-based class. I'll also show a few caveats that you need to be aware of.

Here's an example of a class built using the July CTP of Atlas:

Custom.Color = function(r, g, b) {
Custom.Color.initializeBase(this);
var _r = r || 0;
var _g = g || 0;
var _b = b || 0;
this.get_red = function() {
return _r;
}
this.set_red = function(value) {
_r = value;
}
this.get_green = function() {
return _g;
}
this.set_green = function(value) {
_g = value;
}
this.get_blue = function() {
return _b;
}
this.set_blue = function(value) {
_b = value;
}
this.toString = function() {
return Custom.Color.callBaseMethod(this, "toString") +
"(" + _r + "," + _g + "," + _b + ")";
}
Custom.Color.registerBaseMethod(this, "toString");
}
Custom.Color.registerClass("Custom.Color", Sys.Component);

The first thing you need to do is insert the following right after the private variable initialization, as this is all that's needed now in the constructor:

}
Custom.Color.prototype = {

Then you need to replace the variable initializations in the constructor with instance variable initialization:

  this._r = r || 0;
this._g = g || 0;
this._b = b || 0;

The next step is of course to replace all occurrences of _r, _g and _b with this._r, this._g and this._b throughout the rest of the code.

Note the convention that private members (fields and methods) are prefixed with an underscore. This convention will be adopted by Visual Studio Orcas in IntelliSense.

For each method and property accessor, you need to remove the "this." before the name and replace the " = " with ": ". Also add a comma after the closing brace of each method but the last one. Finally, remove any registerBaseMethod you may have (in prototype-based classes, everything is virtual).

That's it, your class is now built using prototypes:

Custom.Color = function(r, g, b) {
Custom.Color.initializeBase(this);
this._r = r || 0;
this._g = g || 0;
this._b = b || 0;
}
Custom.Color.prototype = {
  get_red: function() {
return this._r;
},
set_red: function(value) {
this._r = value;
},
get_green: function() {
return this._g;
},
set_green: function(value) {
this._g = value;
},
get_blue: function() {
return this._b;
},
set_blue: function(value) {
this._b = value;
},
toString: function() {
return Custom.Color.callBaseMethod(this, "toString") +
"(" + this._r + "," + this._g + "," + this._b + ")";
}
}
Custom.Color.registerClass("Custom.Color", Sys.component);

I've highlighted where the code differs in both samples for easy reference.

So that was easy. Now let's enumerate a few do's and don't's...

  • Do transform private constructor variables into underscore-prefixed instance fields.
    Foo.Bar = function() {
        var _baz = "";
        }
    becomes
    Foo.Bar = function() {
        this._baz: ""
        }
  • Do move all methods and property accessors from the constructor to the prototype.
  • Do update all references to fields and methods to be dereferenced through the this pointer.
    _member
    becomes
    this._member
  • Do separate prototype members with commas, but don't leave a comma after the last one (JSON syntax doesn't allow it).
  • Don't use the instanceof operator with Atlas classes. Do use 
    MyNamespace.MyType.isInstanceOfType(myInstance)
    instead of 
    myInstance instanceof MyNamespace.MyType
  • Do continue to set initial values of fields from the constructor.
  • Don't move field initializations that depend on the this pointer to prototype (but do make them fields)
    Foo.Bar = function() {
        var _delegate = Function.createDelegate(this, this._handler);
        }
    becomes
    Foo.Bar = function() {
        this._delegate = Function.createDelegate(this, this._handler);
        }
  • Don't register base methods: with the prototype pattern, all methods are virtual. The registerBaseMethod will not be available in Atlas starting with Beta 1, which makes it impossible for closure-based classes to be base Atlas classes.
  • Do move private functions to the prototype (prefixing the name with underscore) unless they have a compelling use of the closure pattern (for security for example), which is quite rare.
    Foo.Bar = function() {
        function privateMethod() {
        //...
        }
        }
    becomes
    Foo.Bar = function() {}
        Foo.Bar.prototype = {
        _privateMethod: function() {
        //...
        }
        }

In the next posts, I'll get into other specific changes that we're making in Beta 1.

posted @ 2006-10-18 18:39 MK2 阅读(8) | 评论 (0)编辑

呵呵,因为购买了《Atlas基础教程(Foundations of Atlas)》,所以决定放弃Visual Studio 2003了,还有就是开始全面地学习Atlas,毕竟使用的是asp.net。不过之前的Prototype,Ajax.net等等,都不会白费,没有它们,我根本不会了解什么是Ajax,还有Ajax的魅力和魔力。

  当当送货的,快点到啊`````

 

以下是安装过程的截图,作个留念。

 

 

图片次序是乱的,呵呵,我很懒的,不整理了。


    文章来源:http://blog.163.com/fengmk2/blog/static/891324020069182045791
    posted @ 2006-10-18 14:01 MK2 阅读(30) | 评论 (0)编辑

    Example:

        string str = string.Format(@"{0}\sss\dddd\{1}","str1","str2");

    String.Format(format,string[])用来对字符串进行格式化的,第一个参数format是表示格式的字符串,通常包含格式项(类似于{0},{1},{2}等)的字符。这些格式项将被传入对应的参数string[i]替换。

     

    在字符串之前的@操作符用来告诉编译器不要处理转义字符串。


      文章来源:http://blog.163.com/fengmk2/blog/static/8913240200691785144139
      posted @ 2006-10-17 20:52 MK2 阅读(21) | 评论 (0)编辑

      呵呵,以前好似有过一片,不过依家都唔知去左边Lu。。。。

      • 哈哈,好嘢……
        ---- 风雪梨花 (Email) 评论于 2006-10-17 23:29:50
      • 呵呵,甘送多两个俾你玩下啦
        ---- mk2 (Email) 评论于 2006-10-17 22:44:06
      • 唔系你以为点样先至叫做有前途啊?

        我觉得呢度D表情好得意啊……


        ---- 风雪梨花 (Email) 评论于 2006-10-17 10:26:05
      • 原来识路去找你都算有前途噶,哇``
        ---- mk2 (Email) 评论于 2006-10-16 03:15:19
      • 哈哈,有前途喔
        ---- 风雪梨花 (Email) 评论于 2006-10-16 00:23:39
      • 呵呵,不过我仲记得路去找你,唔使怕```我唔会撞失路噶
        ---- mk2 (Email) 评论于 2006-10-13 01:37:58
      • 叫《当四叶草遇上剑尖时》啊……

        你成日都唔记得D嘢去咗边度噶啦


        ---- 风雪梨花 (Email) 评论于 2006-10-13 01:32:35

      文章来源:http://blog.163.com/fengmk2/blog/static/891324020069131649314
      posted @ 2006-10-13 01:07 MK2 阅读(5) | 评论 (0)编辑

      转至:http://tech.163.com/06/1012/10/2T7P48L200091JUR.html

       

      服务器市场现阶段的推动力主要由产品来主导,而产品的牵引主要由上游芯片厂商的性能提升来指向。更新年年有,今年特别多。越来越多、越来越快的服务器硬件新品推出似乎产生了更多的商机,但有时候也让使用者的眼神感觉疲惫。

      产品总是为服务做准备,而服务器应用的基础是操作系统。本章中,笔者将把长期以来对于一些主流操作系统的应用体验在此展示一下,希望在感觉一丝新意之余,能够为朋友们选择服务器操作系统提供些微的参考。

      1、服务器操作系统的分类

      操作系统英文原称Operating System(简称OS),主要功能是实现计算机硬件与软件的直接控制,并进行管理协调。

      操作系统主要分为两部分:内核(Kernel),壳(Shell)。

      顾名思义,内核主要实现计算机硬件与壳之间的信息传递与沟通,是一个操作系统最核心技术的体现;壳主要负责传递内核与应用程序之间的信息交流,将内核与软件的内外部命令用利用底层语言进行相互转译,实现一个个的操作请求。对于Windows系统来说,内核与壳之间相互联系,就如同一个只会外语的洋老板与中国翻译的位置,是一个管理与被管理的关系;对于Unix与Linux来说,由于将内核与壳完全分离,就如同一个厂商与一个代理商之间的关系,双方互利协作,厂商可以随时取消代理商的代理权来另找代理,而代理同时也可以不需要这个代理权。

      服务器操作系统,又名网络操作系统。相比个人版操作系统,在一个具体的网络中,服务器操作系统要承担额外的管理、配置、稳定、安全等功能,处于每个网络中的心脏部位,其网络操作系统的别称也由此而来。

      服务器操作系统主要分为四大流派:WINDOWS、NETWARE、UNIX、LINUX。

      WINDOWS服务器操作系统大家应该都不会陌生,这是全球最大的操作系统开发商——Microsoft公司开发的。其服务器操作系统重要版本WINNT 4.0 Server、Win2000/Advanced Server、Win2003/Advanced Server,也支撑起目前市面上应用最多的服务器操作系统——Windows服务器操作系统派应用。

      NetWare服务器操作系统对现在一些IT圈里的朋友可能就比较陌生,由于种种原因,它的市场占有率已经非常局限,主要应用在某些特定的行业中。也就是因为此,在很多朋友在划分操作系统派系的时候,去除了NETWARE的代表权。其实,如果80年代前出生的老IT,对于NetWare这个名词就会异常熟悉了,因为在当初各种设备和网络都比较落后的年代,NetWare在局域网应用中占据着绝对的高额市场;而就算是目前,在一些特定行业和事业单位中,NetWare优秀的批处理功能和安全、稳定的系统性能也有很大的生存空间。NetWare目前常用的版本主要有Novell的3.11、3.12、4.10、5.0等中英文版。

      Unix服务器操作系统由AT&T公司和SCO公司共同推出,主要支持大型的文件系统服务、数据服务等应用。由于一些出众的服务器厂商生产的高端服务器产品中甚至只支持Unix操作系统,因而在很多人的眼中,Unix甚至成为高端操作系统的代名词。目前市面上流传的主要有SCO SVR、BSD Unix、SUN Solaris、IBM-AIX 。

      Linux服务器操作系统是国外几位IT前辈,在Posix和Unix基础上开发出来的,支持多用户、多任务、多线程、多CPU。Linux开放源代码政策,使得基于其平台的开发与使用无须支付任何单位和个人的版权费用,成为后来很多操作系统厂家创业的基石,同时也成为目前国内外很多保密机构服务器操作系统采购的首选。目前国内主流市场中使用的主要有Novell的中文版Suse Linux 9.0、小红帽系列、红旗Linux系列等。

       

      2、Windows服务器操作系统

      1)WINNT 4.0

      WINNT Server可算得是开了直观、稳定、安全的服务器平台的先河。

      当Windows操作系统以第一人性化的操作界面占据大片江山的时候,Windows系列产品在当时的主流的95、97系列中表现出的频繁死机、后门敞开等问题,却成为竞争对手与用户同时攻击的对象。痛定思痛,在经过很长一段时间的闭门练功之后,Microsoft对自己的Windows系列产品与竞争对手的产品经过各方位测试比较,总结各自的优缺点,融入新的安全观念,在人性化的直观操作基础上,开发出影响深远的新技术NT架构内核。尽管由于技术的发展,后来的业内人员还是找出其中不少的缺点,但是其NT内核技术的开发与操作直观、安全等理念的实现,对于服务器操作系统的发展来说,仍然具有划时代的意义。时至今日,虽然Microsoft已经取消了对NT版本的升级服务,但一些怀旧和追求简单实用功能的IT人士,还是在一些特定的应用中使用到它。

      优点:操作直观,易于使用,功能实用,安全性能比较好,可用于单一的防火墙等服务器上。

      缺点:运行速度慢,功能不够完善,当进行超出系统处理能力的多项并发处理时,单个线程的不响应将会系统由于不堪重负产生死机现象,需要对服务器进行重启操作,Microsoft已停止对其进行所有升级服务,市面上已无正版产品的销售。

      2)Win2000/Advanced Server

      Win2000/Advanced Server是在NT技术上发展起来的,当越来越多的人指责NT系统运行速度慢如蜗牛时,Microsoft对NT内核的壳部分进行了很大程度的响应与传输优化,并在NT基础上增加了很多的附加管理功能,这样就诞生了Win2000/Advanced Server的初始版本(Advanced Server版本相对Server版本所具有的管理功能更加全面)。Win2000系列服务器操作系统秉承了Windows一贯的直观易用的优良传统,并在原有的基础上实现了速度与功能的提升,在安全上也修补了所有以往的后门,是目前为止Windows服务器操作系统中市场使用最普遍的一款服务器,为Windows市场分额的直线提升立下了汗马功劳。但随着时间的推移,Windows一贯的后门失守现象也越来越多的呈现在大众的面前,而且目前Microsoft公司也已经停止此系列产品的销售与系统升级服务,不免使得很多仍执着跟随的朋友产生了很多遗憾。

      优点:操作直观,易于使用,功能随着时代的发展具有大幅的提升,管理更加全面,相对NT版本,当单个线程不响应时,其他线程的处理仍然可以继续进行,系统无需重启,现代社会的很多应用仍然能够实现。

      缺点:运行速度虽然较NT版本有不小的提升,但是在有一部分追求完美的应用者来说,仍然有恨铁不成钢的情绪;由于是在原有完整NT内核的基础上对所有的高端功能应用进行开发的,系统的稳定与安全性有部分的削弱;Microsoft已停止对Win2000系列服务器进销售与升级服务支持。

      3)Win2003/Advanced Server

      Win2003/Advanced Server继承了有历以来最具人性化的WinXP界面,对于原由内核处理技术进行了更大程度的改良,在安全性能上相对以前版本也有很大的提升,在管理功能上增加了许多流行的新技术,目前在Windows系列服务器中,其实际应用的比例与2000系列服务器产品基本相当。

      优点:操作易用性是除了XP以外最人性化的版本,安全性是目前为止Windows全系列服务器产品中最好的,线程处理速度跟随硬件的发展有不小的提升,管理能力也有不小的提升,是目前Windows服务器中主流产品。

      缺点:安全性能仍有待更加完善,由于管理功能的增加,需要处理的线程更加繁杂,如果使用同样的硬件,2000系列比2003系列产品在处理速度上会稍快。

      3、UNIX服务器操作系统

      Unix服务器操作系统最初是由AT&T与SCO两家公司共同推出,由于看到其系统的高稳定性与安全性,兼且对于大型文件系统、大型数据库系统的支持,使得在服务器领域具有卓越硬件研发功力的SUN与IBM两家公司也忍不住诱惑,加入其中,并且在其服务器操作系统推出不久,就借助其在服务器硬件领域的市场,推动了两家服务器操作系统赶超UNIX创始人的局面。

      1)SCO SVR、BSD Unix

      Unix由,Unix SCO SVR就是Unix技术创始人之一SCO公司的产品。由SCO公司开发的Unix SCO SVR和由AT&T主导的BSD Unix能够支持所有Unix系统都能实现的网络大型文件系统、数据库系统的支持,并且随着时代发展,能够支持越来越多的软件应用。此外,由于Unix系列的所有系统都属于非开源代码,而其系统的技术研发层面没有得到更多的推广,在外界对其知晓并不是很多的情况下,其本来就高高在上的系统稳定性与安全性地位就更加显得无法动摇。

      优点:系统安全性与稳定性犹如业界无法动摇的泰山,能够支持大型文件系统与数据库系统,处于技术创始人地位的两位元老级Unix,一直在业界受到无数人狂热的追捧;

      缺点:所有操作都需要输入代码式的命令触动,人性化显得非常差,这样也绊住了其对于中低端服务器市场的发展;虽然厂家位于技术创始人的地位,而且产品对于应用软件的支持一直都有所改善,但是临到后来,因为其本身的高端服务器操作系统定义,深层的技术研发没有得到更多的推广,导致这些改善的结果并未有太大的起色。

      2)SUN Solaris、IBM-AIX

      之所以把以上的四家产品只分为两组来谈,主要原因是笔者以实际应用的角度来看:四者其实都是定位于高端服务器操作系统市场的,在实际应用中,四者在处于高端定位上的技术差别非常微小,如果非要分一个具体的差别,那就从四位历史的起源与科技的进一步发展状况来区别——SCO与AT&T属于创业始祖,SUN与IBM属于后来居上者。而从结果中所得的猜测是,由于本组所谈的这两者的服务器产品市场占有率稍高,服务器厂商对于己身的服务器操作系统支持比较足够,这就对两这服务器的市场占有率和技术含量起了很大的推动力。

      优点:支持大型文件系统与数据库,传承了UNIX一贯的高能级系统安全性、稳定性,对于系统应用软件的支持比较完善。

      缺点:沾染了Unix系操作系统的通病,人性化界面肯定谈不上好了;由于IBM-AIX属于非开源代码,技术层面未能得到有效推广,使得相关维护人员的雇佣成本比较高,不利于占有率更多的中低端市场的进一步推广与普及;SUN对于源代码的开放时日尚短,目前也还没有享受到开源代码比较新颖的技术创新推动;两者面向企业的服务器端都是采取收费服务的方式,用户在享受两家高稳定性与安全性的硬件产品同时与服务器操作系统技术支持服务之时,“物美价廉”的想法是可以作罢了。

      4、Linux服务器操作系统

      1)小红帽系列、红旗Linux

      Linux在中国的商用,很大程度上是政府采购的推动。考虑到机密数据的安全性,在前几年的一次政府采购中,具有开放的源代码基础的Linux操作系统似乎意外但也带有些必然性的中标,对于服务器操作系统市场来说,无意于引起了一场大地震,而官方获利最大的红旗和民间流传最广的小红帽也就成为国内Linux系统的代表。但其实在真正的使用中,除了在图标与细枝末节的功能差别外,这两个Linux厂商代表的核心技术都是无差别化的雷同。

      优点:源代码的开放,使得该类服务器操作系统的技术完善从民间得到了其他厂商无法比拟的雄厚力量,在此基础上所形成的一件服务器操作系统成品是任何力量都不可忽视的,因而其所具有的兼容、安全、稳定的Linux特性也是其他服务器操作系统厂商不容易实现的;Linux

      缺点:由于其是基于Unix系统所做的开发修补,属于类Unix模式,这就决定了其系统的兼容性相比其他服务器操作系统兼容的软件来说,还是具有一定差距的;Linux的操作基本也是利用输入代码命令进行应用实现的方式,使得其在人性化方面还是处于相当的劣势,其后果必然导致维护成本的相对偏高。

      2)Suse Linux

      其实在本组中笔者要提到的是Suse Linux10,不过因为其推出的时间只是上月末,离现在刚刚半个月的时间,在市面上最多的还是它的前辈Suse Linux9.0,所以笔者在之前Linux技术与产品介绍中提到的只是大家都比较熟悉的9.0版本。

      很幸运,在Novell将Suse Linux10正式发布后第二天,笔者一位同事通过一些渠道获得其试用版,并且在笔者身旁做完了长达三天的测试,笔者也切身体验了这个结合Linux开源与微软人性化的新服务器操作系统。以下的优缺点分析也就是笔者要谈到的Suse Linux10的特点。

      优点:具有Linux一贯稳定、安全的系统性能,兼容性相对目前主流的服务器操作系统也有很大的提升,具有相当于微软系列操作系统般的人性化设计,增加操作系统中绚丽而高难的三维立体空间显示,属于另一个划时代的产品。

      缺点:虽然相对以前各家的软件兼容性有不小的提高,但因为市场中对于Linux系统支持的软件开发商本来就不多,所以它还是延续了Linux兼容性暂时差于微软的特性;系统所需的立体空间显示技术,并不是如同发布会当天Novell发言人所说的那样,只需要四五年前的主流PC的CPU性能和主板集成的显卡就可以完成。笔者看到的实际情况是,在微软系统中播放正常的一集美国大片,当在Suse Linux10.0上以三维立体空间技术播放时,播放了不到30秒钟,音频就一桢桢的跳着继续,视频更是好象播放划花的盗版光碟一样,在显示器上显示一个大花脸和不断颤动的波纹。


        文章来源:http://blog.163.com/fengmk2/blog/static/89132402006912114014540
        posted @ 2006-10-12 23:40 MK2 阅读(66) | 评论 (0)编辑

        暂时只能送“一部”啦,呵呵,用住先啦````

        再送到部黑色噶,嘿嘿````

         

        呵呵,好少见到噶标志

        • 死啦,我半知半解嘅?
          ---- 风雪梨花 (Email) 评论于 2006-10-17 23:30:58
        • 晕````LX你都唔知系咪?甘XM知了挂
          ---- mk2 (Email) 评论于 2006-10-17 22:44:40
        • 乜嘢叫LX先?等我去准备下……
          ---- 风雪梨花 (Email) 评论于 2006-10-17 10:27:08
        • 法拉利先算可以````晕````我要LX
          ---- mk2 (Email) 评论于 2006-10-16 03:13:43
        • 乜你唔系话想要甲虫咩?哈哈,等我……

          呢个奖励尚算可以啦


          ---- 风雪梨花 (Email) 评论于 2006-10-16 00:21:46
        • 晕,等紧你买俾我呢````
          ---- mk2 (Email) 评论于 2006-10-13 01:39:35
        • 好型啊,好想要啊,两部都要……

          哈哈,我嘅目标,虽然有D不切实际


          ---- 风雪梨花 (Email) 评论于 2006-10-13 01:36:08
        • 拉利性能最出色的前置12缸发动机两座跑车。
          呵呵,可以两个人坐啦`````

          ---- mk2 (Email) 评论于 2006-10-12 23:17:54
        • 里个奖励应该合心意了挂````


          ---- mk2 (Email) 评论于 2006-10-12 23:15:08

        文章来源:http://blog.163.com/fengmk2/blog/static/89132402006912111349463
        posted @ 2006-10-12 23:14 MK2 阅读(6) | 评论 (0)编辑

        一睇就知系咩啦````

        呵呵,可以做头像啦````


          文章来源:http://blog.163.com/fengmk2/blog/static/8913240200691211631628
          posted @ 2006-10-12 23:07 MK2 阅读(9) | 评论 (0)编辑

          怎么会这样的,如果是大3考,估计到毕业都拿不到证了````

          救命啊````````


            文章来源:http://blog.163.com/fengmk2/blog/static/89132402006911114613321
            posted @ 2006-10-11 23:46 MK2 阅读(10) | 评论 (0)编辑

            从一开始去百度搜索资料,到开始阅读资料和代码,到下载了WebbUpload 的源代码,进行分析,到一个Http请求的详细过程,到一大堆二进制数据........一段看似短暂而又漫长的时间,几乎没有关注其它问题与事情,专注研究单一的问题--"上传文件",到现在,总算有点成果了...

            从头到尾认真研究了WebbUpload 的代码,学到了IHttpModule和IHttpHandler的应用,还有很多之前很模糊的东西都部得很清楚了,真的很感谢作者Wu.Country@侠缘(http://wucountry.cnblogs.com/),要不是他公开源码和他的"SunriseUpload_0_9_1的源码分析"文章,可能我的进度会慢上几倍.

            在弄明白代码后,对WebbUpload的代码进行了一些修改,使它能在Ajax上应用.

            最后用了三天时间写Javascript代码,真的很痛苦,呵呵,但收到成果后,会发现Javascript其实也是一种很美的语言,绝对不会比C#,Java逊色(呵呵,可能是我个人意见).使用了prototype.js库,json.js,scriptaculous.js,这几个js库是我经常用到的,真是有了它们,才使我对Javascript大大改观.

             

            这是效果图:

             

            源代码下载:(其中WebbUpload是我修改过的,要下载原版,请到WebbUpload下载)

            MK2_Webb.WAVE.Controls.Upload2.rar

             

            具体使用方法,请参考demo1Ajax.aspx例子,而Ajax版本的MK2.WebbUpload类,请查看MK2_WebbUpload.js中的相关说明.若界面不好,可自行修改有关代码......,终于可以休息几天咯,然后就继续下一个专题研究.....

            • 唉,好累啊,最近都忙死了,想将这个上传功能加到FCKediter那都没时间,一定要加紧,不能浪费时间了,时间无多了。。。。
              ---- mk2 (Email) 评论于 2006-10-11 23:24:14

            文章来源:http://blog.163.com/fengmk2/blog/static/8913240200691112510924
            posted @ 2006-10-11 01:25 MK2 阅读(102) | 评论 (0)编辑

            呵呵,今天啊珍发了一个代码来,试了试,真的可以,看了一下代码,意思基本都能看懂,不懂的就是一些命令的意义....呵呵,不说那么多了,以下转发:

             

            要轻松流畅上网你是否注意到你的电脑系统磁盘的可用空间正在一天天在减少呢?是不是
            像老去的猴王一样动作一天比一天迟缓呢?

            没错!在Windows在安装和使用过程中都会产生相当多的垃圾文件,包括临时文件(如:*
            .tmp、*._mp)日志文件(*.log)、临时帮助文件(*.gid)、磁盘检查文件(*.chk)、
            临时备份文件(如:*.old、*.bak)以及其他临时文件。特别是如果一段时间不清理IE的
            临时文件夹“Temporary Internet Files”,其中的缓存文件有时会占用上百MB的磁盘空
            间。这些LJ文件不仅仅浪费了宝贵的磁盘空间,严重时还会使系统运行慢如蜗牛。这点相
            信你肯定忍受不了吧!所以应及时清理系统的LJ文件的淤塞,保持系统的“苗条”身材,
            轻松流畅上网!朋友来吧,现在就让我们一起来快速清除系统垃圾吧!!下面是步骤很简
            单就两步!

              在电脑屏幕的左下角按“开始→程序→附件→记事本”,把下面的文字复制进去,点“
            另存为”,路径选“桌面”,保存类型为“所有文件”,文件名为“清除系统LJ.bat”,
            就完成了。记住后缀名一定要是.bat,ok!你的垃圾清除器就这样制作成功了! 双击它就
            能很快地清理垃圾文件,大约一分钟不到。

            ======就是下面的文字(这行不用复制)=============================

            @echo off
            echo 正在清除系统垃圾文件,请稍等......
            del /f /s /q %systemdrive%\*.tmp
            del /f /s /q %systemdrive%\*._mp
            del /f /s /q %systemdrive%\*.log
            del /f /s /q %systemdrive%\*.gid
            del /f /s /q %systemdrive%\*.chk
            del /f /s /q %systemdrive%\*.old
            del /f /s /q %systemdrive%\recycled\*.*
            del /f /s /q %windir%\*.bak
            del /f /s /q %windir%\prefetch\*.*
            rd /s /q %windir%\temp & md %windir%\temp
            del /f /q %userprofile%\cookies\*.*
            del /f /q %userprofile%\recent\*.*
            del /f /s /q "%userprofile%\Local Settings\Temporary Internet Files\*.*"
            del /f /s /q "%userprofile%\Local Settings\Temp\*.*"
            del /f /s /q "%userprofile%\recent\*.*"
            echo 清除系统LJ完成!
            echo. & pause
             

             

            测试后,cookies是不能清除的,好险啊,差点就没了泡论坛的密码了.``````不知道别的机是不是也不会呢.....

            • @echo off    //这句是清屏????

               

              echo  //意思是屏幕输出

               

              del   //删除

               

              echo. & pause     //暂停

               

               

               

              以上都是乱猜的,呵呵


              ---- mk2 (Email) 评论于 2006-10-10 21:53:51

            文章来源:http://blog.163.com/fengmk2/blog/static/8913240200691095025755
            posted @ 2006-10-10 21:50 MK2 阅读(35) | 评论 (0)编辑

            一、超文本传输协议及HTTP包
                HTTP协议用于在Internet上发送和接收消息。HTTP协议是一种请求-应答式的协议——客户端发送一个请求,服务器返回该请求的应答,所有的请求与应答都是HTTP包。HTTP协议使用可靠的TCP连接,默认端口是80。HTTP的第一个版本是HTTP/0.9,后来发展到了HTTP/1.0,现在最新的版本是HTTP/1.1。HTTP/1.1由RFC 2616 定义。
                在HTTP中,Client/Server之间的会话总是由客户端通过建立连接和发送HTTP请求包初始化,服务器不会主动联系客户端或要求与客户端建立连接。浏览器和服务器都可以随时中断连接,例如,在浏览网页时你可以随时点击“停止”按钮中断当前的文件下载过程,关闭与Web服务器的HTTP连接。
              1 HTTP请求包
              HTTP请求包(GET、POST等请求方法)由三个部分构成,分别是:方法-URI-协议/版本,请求头,请求正文。下面是一个HTTP请求包(GET)的例子:
            GET /index.jsp HTTP/1.1
            Accept-Language: zh-cn
            Connection: Keep-Alive
            Host: 192.168.0.106
            Content-Length: 37

            userName=new_andy&password=new_andy
             
                请求包的第一行是方法-URI-协议/版本:
                GET就是请求方法,根据HTTP标准,HTTP请求可以使用多种请求方法。HTTP 1.1支持七种请求方法:GET、POST、HEAD、OPTIONS、PUT、DELETE和TRACE等,常用的为请求方法是GET和POST。
                /index.jsp表示URI。URI指定了要访问的网络资源。
                HTTP/1.1是协议和协议的版本。
                最后一行userName=new_andy&password=new_andy为正文,正文与HTTP头部有一个空行(\r\n)分隔。这里需要说明的一点,其中Content-Length说明正文的长度,有的正文长度没有在头部说明,只是标明Transfer-Encoding: chunked。关于chunked类型的长度计算方法,见RFC 1626。
                请求包的头部还会包含许多有关客户端环境和请求正文的有用信息,这里不再描述。
              2 HTTP应答包

              和HTTP请求包相似,由三个部分构成,分别是:协议-状态代码-描述,应答头,应答正文。下面是一个HTTP应答的例子:

            HTTP/1.1 200 OK
            Server: Microsoft-IIS/4.0
            Date: Mon, 3 Jan 2005 13:13:33 GMT
            Content-Type: text/html
            Last-Modified: Mon, 11 Jan 2004 13:23:42 GMT
            Content-Length: 90

            <html>
            <head>
            <title>解读HTTP包示例</title></head><body>
            Hello WORLD!
            </body>
            </html>

              HTTP应答包的第一行类似于HTTP请求的第一行,表示所用的协议是HTTP 1.1,服务器处理请求的状态码200。
              应答头也和请求头一样包含许多有用的信息,例如服务器类型、日期时间、内容类型和长度等。应答的正文就是服务器返回的HTML页面。应答头和正文之间也用CRLF分隔。
            二、Socket类与ServerSocket类
              在Java中,通信端点由java.net.Socket类(客户端)或java.net.ServerSocket类(服务器端)表示。应用程序通过端点向网络发送或从网络读取数据。位于两台不同机器上的应用软件通过网络连接发送和接收字节流,从而实现通信。要把HTTP包发送给另一个应用,首先要知道对方的IP地址以及其通信端点的端口号。
               Socket类代表的是客户端,它是一个连接远程服务器应用时临时创建的端点。
               ServerSocker类代表的是服务器端,它启动后等待来自客户端的连接请求;一旦接收到请求,ServerSocket创建一个Socket实例来处理与该客户端的通信。对于服务器应用,我们不知道客户端应用什么时候会试图连接服务器,服务器必须一直处于等待连接的状态。

              下面是ServerSocket提供了四个构造函数,常用的构造函数的的一种形式为:
              public ServerSocket(int port, int backLog, InetAddress bindingAddress);
              参数:port指定服务器端监听客户端的端口;
              backlog为连接请求的最大队列长度,一旦超越这个长度,服务器端点开始拒绝客户端的连接请求。
              bindingAddress是一个java.net.InetAddress的实例,指定绑定IP地址。
               创建好ServerSocket实例之后,调用它的accept方法,要求它等待传入的连接请求。只有出现了连接请求时,accept方法才会返回,它的返回值是一个Socket类的实例。随后,这个Socket对象就可以用来与客户端应用通信。
             
              Socket类有许多构造函数,常用的为:
              public Socket(String host, int port)。参数是主机名称(IP地址或域名)和端口号。
               参数host是远程机器的名字或IP地址,port是远程应用的端口号。
               成功创建了Socket类的实例之后,我们就可以用它来发送和接收字节流形式的数据,数据一般为HTTP包。
              
               要发送字节流,首先要调用Socket类的getOutputStream方法获得一个java.io.OutputStream对象;要从连接的另一端接收字节流,首先要调用Socket类的getInputStream方法获得一个java.io.InputStream对象。
               下面的代码片断创建一个与本地HTTP服务器(127.0.0.1代表本地主机的IP地址)通信的Socket,发送一个HTTP请求包,准备接收服务器的应答。
              Socket socket    = new Socket("127.0.0.1", "80");
              OutputStream os  = socket.getOutputStream();
              InputStream  ins = socket.getInputStream();
              StringBuffer sb=new StringBuffer();
              sb.append("GET /index.jsp HTTP/1.1\r\n");//注意\r\n为回车换行
              sb.append("Accept-Language: zh-cn\r\n");
              sb.append("Connection: Keep-Alive\r\n");
              sb.append("Host: 192.168.0.106\r\n");
              sb.append("Content-Length: 37\r\n");
              sb.append("\r\n");
              sb.append("userName=new_andy&password=new_andy\r\n");
              sb.append("\r\n");
             
              //向Web服务器发送一个HTTP请求包
              os.write(sb.toString().getBytes()); 
             
              服务器端的代码在大致结构为:
              while (!shutdown) {
                    Socket socket = null;
                    try {
                        socket = serverSocket.accept(); //等待客户以送HTTP请求包
                        // 创建HTTP请求包处理线程
                        RequestThread request = new RequestThread(socket);
                        request.start();
                        if(shutdown) System.exit(0);
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                    }
                }
              RequestThread线程分析HTTP请求包,跟根据请求包内容在服务端生成一个HTTP应答包。下一节说明怎样分析HTTP包。
              InputStream  input = socket.getInputStream();  //从此字节数据流获得HTTP请求包内容
                OutputStream output= socket.getOutputStream(); //向此字节流写入HTTP应答包内容
               
            三、读取HTTP包
              以下我自己设计的一个读取HTTP包的类SocketRequest。
              public class SocketRequest {  //从指定的Socket的InputStream中读取数据

              private InputStream  input;
              private String     uri;
              private StringBuffer  request=new StringBuffer();  //用于保存所有内容
              private int       CONTENT_LENGTH=0;  //实际包内容数据长
              private boolean    bePost = false;
              private boolean    beHttpResponse = false;
              private boolean    beChucked = false;
              private boolean    beGet = false;
              private byte       crlf13 = (byte)13; //'\r'
              private byte       crlf10 = (byte)10;  //'\n'

              public SocketRequest(InputStream input) {
                this.input = input;
              }
             public SocketRequest(Socket socket) {
                this.input = socket.getInputStream();
              }

              public void ReadData() {  //解析 获得InputStream的数据
             
              ReadHeader();  //头部

              if(beChucked) //为Chucked
              {
               int ChuckSize=0;
               while((ChuckSize=getChuckSize())>0) //多个Chucked
               {
                readLenData(ChuckSize+2);//读取定长数据
               }
               readLenData(2); //最后的2位 
              }
             
              if(CONTENT_LENGTH>0)
              {
               readLenData(CONTENT_LENGTH);//读取定长数据
              }
             
                uri = "";//parseUri(new String(request));
              }
             
              private void readLenData(int size)  //读取定长数据
              {
               int readed=0;  //已经读取数
               try{
                int available=0;//input.available(); //可读数
                if(available>(size-readed)) available=size-readed;
                while( readed<size )
                 {
                   while(available==0){  //等到有数据可读
                     available = input.available(); //可读数
                    }
                    if(available>(size-readed)) available= size-readed; //size-readed--剩余数
                    if(available>2048) available= 2048; //size-readed--剩余数
                   byte[] buffer = new byte[available];
                   int reading = input.read(buffer);
                   request=request.append(new String(buffer,0,reading));  //byte数组相加
                    readed+=reading;  //已读字符
               }
               }catch(IOException e){
                 System.out.println("Read readLenData Error!");
               }
             }
             
               private void  ReadHeader() //读取头部 并获得大小
               {
                byte[]  crlf   = new byte[1];
               int     crlfNum= 0;   //已经连接的回车换行数 crlfNum=4为头部结束
                try{
                 while( input.read(crlf)!=-1 )   //读取头部
                 {
                  if(crlf[0]==crlf13 || crlf[0]==crlf10)
                  {
                     crlfNum++;
                  }
                  else
                  {  crlfNum=0;  } //不是则清
                  request=request.append(new String(crlf,0,1));  //byte数组相加
                  if(crlfNum==4) break;
                 }
               }catch(IOException e){
                 System.out.println("Read Http Header Error!");
                 return;
                }
              
                String tempStr=(new String(request)).toUpperCase();
               
                //这里我只处理了GET与POST方法
                String  strMethod  = tempStr.substring(0,4);
                if(strMethod.equals("GET ")) //前
                {  beGet=true;   
                }
                else if(strMethod.equals("POST"))
                {
                 bePost=true;
                 getContentlen_Chucked(tempStr);
                }
                else {
                 System.out.println("不支持的HTTP包类型");
                
                } //其它的其它类型 暂不支持
              }

              private void getContentlen_Chucked(String tempStr)  //获得长度 CONTENT-LENGTH 或 是否为CHUNKED型
              {
               String ss1="CONTENT-LENGTH:";
               String ss2=new String("TRANSFER-ENCODING: CHUNKED");
              
               int clIndex   = tempStr.indexOf(ss1);
                int chuckIndex = tempStr.indexOf(ss2);  //为CHUNKED型
                byte requst[]= tempStr.getBytes();
                if(clIndex!=-1)
                { //从clIndex+1起至\r\n
                   StringBuffer sb=new StringBuffer();
                  
                   for(int i=(clIndex+16);;i++)
                   {
                    if(requst[i]!=(byte)13 && requst[i]!=(byte)10 )
                    {
                      sb.append((char)requst[i]);
                    }
                    else
                     break;
                   }
                  
                   CONTENT_LENGTH=Integer.parseInt(sb.toString());  //正式的HTML文件的大小
                   //System.out.println("CONTENT_LENGTH==  "+CONTENT_LENGTH);
               }
               if(chuckIndex!=-1) beChucked=true;
              }
              
              private int  getChuckSize() //Chuck大小
               {
                byte[]  crlf   = new byte[1];
                StringBuffer  sb1   = new StringBuffer();

                int     crlfNum= 0;   //已经连接的回车换行数 crlfNum=4为头部结束
               
                try{
                 while(input.read(crlf)!=-1)   //读取头部
                 {
                  if(crlf[0]==crlf13 || crlf[0]==crlf10)
                  {  crlfNum++; }
                  else
                  {  crlfNum=0;  } //不是则清
                  sb1.append((char)crlf[0]);
                  request=request.append(new String(crlf,0,1));  //byte数组相加
                  if(crlfNum==2) break;
                 }
               }catch(IOException e){
                 System.out.println("Read Http Package Error!");
                 return 0;
                }
              
               return Integer.parseInt((sb1.toString()).trim(),16); //16进控制
             }
              //通过此来进行过滤,是否为发至目标服务器的HTTP包
              private String parseUri(String requestString) {
                int index1, index2;
                index1 = requestString.indexOf(' ');
                if (index1 != -1) {
                  index2 = requestString.indexOf(' ', index1 + 1);
                  if (index2 > index1)
                    return requestString.substring(index1 + 1, index2);
                }
                return null;
              }

              public String getData() {
                return request.toString();
              }
            }

             使用此类:
             SocketRequest request = new SocketRequest(socket); //socket为ServerSocket.accept()返回的Socket实例
             request.ReadData();  //读取数据
             request.getData();
             为什么我要用这么大的力量去读取呢,尤其是在因为Socket连接在发送数据时,由于网络的原因经常会发生延迟现象,可能在服务器端开始接收数据时可能只有部分数据可以从InputStream中获得,在一些地方处理不当时,可能只能获得不完整的数据或是错误的数据。
             从InputStream读取字节时有多种办法:
             常用int read()与int read(byte[] b)。在用read(byte[])时,程序员经常会犯错误,因为在网络环境中,读取的数据量不一定等于参数的大小。
             
             希望我的这篇文章能给你带来一些帮助。

             


              文章来源:http://blog.163.com/fengmk2/blog/static/891324020069802933214
              posted @ 2006-10-08 00:30 MK2 阅读(108) | 评论 (0)编辑

              如果为没有 refout 的方法声明一个参数,则此参数可以具有关联的值。可以在方法中更改该值,但当控制传递回调用过程时,不会保留更改的值。通过使用方法参数关键字,可以更改这种行为。

              本节描述声明方法参数时可以使用的关键字:

              params 关键字可以指定在参数数目可变处采用参数的方法参数。
              在方法声明中的 params 关键字之后不允许任何其他参数,并且在方法声明中只允许一个 params 关键字。
              示例
              // cs_params.cs
              using System;
              public class MyClass
              {

                 public static void UseParams(params int[] list)
                 {
                    for ( int i = 0 ; i < list.Length ; i++ )
                       Console.WriteLine(list[i]);
                    Console.WriteLine();
                 }

                 public static void UseParams2(params object[] list)
                 {
                    for ( int i = 0 ; i < list.Length ; i++ )
                       Console.WriteLine(list[i]);
                    Console.WriteLine();
                 }

                 public static void Main()
                 {
                    UseParams(1, 2, 3);
                    UseParams2(1, 'a', "test");

                    int[] myarray = new int[3] {10,11,12};
                    UseParams(myarray);
                 }
              }
              输出
              1
              2
              3

              1
              a
              test

              10
              11
              12

               

              方法参数上的 ref 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时,在方法中对参数所做的任何更改都将反映在该变量中。
              若要使用 ref 参数,必须将参数作为 ref 参数显式传递到方法。ref 参数的值被传递到 ref 参数。
              传递到 ref 参数的参数必须最先初始化。将此方法与 out 参数相比,后者的参数在传递到 out 参数之前不必显式初始化。
              属性不是变量,不能作为 ref 参数传递。
              如果两种方法的声明仅在它们对 ref 的使用方面不同,则将出现重载。但是,无法定义仅在 ref 和 out 方面不同的重载。例如,以下重载声明是有效的:
              class MyClass
              {
                 public void MyMethod(int i) {i = 10;}
                 public void MyMethod(ref int i) {i = 10;}
              }
              但以下重载声明是无效的:
              class MyClass
              {
                 public void MyMethod(out int i) {i = 10;}
                 public void MyMethod(ref int i) {i = 10;}
              }
              有关传递数组的信息,请参见使用 ref 和 out 传递数组。
              示例
              // cs_ref.cs
              using System;
              public class MyClass
              {
                 public static void TestRef(ref char i)
                 {
                    // The value of i will be changed in the calling method
                    i = 'b';
                 }

                 public static void TestNoRef(char i)
                 {
                    // The value of i will be unchanged in the calling method
                    i = 'c';
                 }

                 // This method passes a variable as a ref parameter; the value of the
                 // variable is changed after control passes back to this method.
                 // The same variable is passed as a value parameter; the value of the
                 // variable is unchanged after control is passed back to this method.
                 public static void Main()
                 {
                
                    char i = 'a';    // variable must be initialized
                    TestRef(ref i);  // the arg must be passed as ref
                    Console.WriteLine(i);
                    TestNoRef(i);
                    Console.WriteLine(i);
                 }
              }
              输出
              b
              b

               

              方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时,在方法中对参数所做的任何更改都将反映在该变量中。
              当希望方法返回多个值时,声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。
              若要使用 out 参数,必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
              不必初始化作为 out 参数传递的变量。然而,必须在方法返回之前为 out 参数赋值。
              属性不是变量,不能作为 out 参数传递。
              如果两个方法的声明仅在 out 的使用方面不同,则会发生重载。不过,无法定义仅在 ref 和 out 方面不同的重载。例如,以下重载声明是有效的:
              class MyClass
              {
                 public void MyMethod(int i) {i = 10;}
                 public void MyMethod(out int i) {i = 10;}
              }
              而以下重载声明是无效的:
              class MyClass
              {
                 public void MyMethod(out int i) {i = 10;}
                 public void MyMethod(ref int i) {i = 10;}
              }
              有关传递数组的信息,请参见使用 ref 和 out 传递数组。
              示例
              // cs_out.cs
              using System;
              public class MyClass
              {
                 public static int TestOut(out char i)
                 {
                    i = 'b';
                    return -1;
                 }

                 public static void Main()
                 {
                    char i;   // variable need not be initialized
                    Console.WriteLine(TestOut(out i));
                    Console.WriteLine(i);
                 }
              }
              输出
              -1
              b

               

              使用 ref 和 out 传递数组

               

              与所有的 out 参数一样,在使用数组类型的 out 参数前必须先为其赋值,即必须由接受方为其赋值。例如:
              public static void MyMethod(out int[] arr)
              {
                 arr = new int[10];   // definite assignment of arr
              }
              与所有的 ref 参数一样,数组类型的 ref 参数必须由调用方明确赋值。因此不需要由接受方明确赋值。可以将数组类型的 ref 参数更改为调用的结果。例如,可以为数组赋以 null 值,或将其初始化为另一个数组。例如:
              public static void MyMethod(ref int[] arr)
              {
                 arr = new int[10];   // arr initialized to a different array
              }
              下面的两个示例说明 out 和 ref 在将数组传递给方法上的用法差异。
              示例 1
              在此例中,在调用方(Main 方法)中声明数组 myArray,并在 FillArray 方法中初始化此数组。然后将数组元素返回调用方并显示。
              // cs_array_ref_and_out.cs
              using System;
              class TestOut
              {
                 static public void FillArray(out int[] myArray)
                 {
                    // Initialize the array:
                    myArray = new int[5] {1, 2, 3, 4, 5};
                 }

                 static public void Main()
                 {
                    int[] myArray; // Initialization is not required

                    // Pass the array to the callee using out:
                    FillArray(out myArray);

                    // Display the array elements:
                    Console.WriteLine("Array elements are:");
                    for (int i=0; i < myArray.Length; i++)
                       Console.WriteLine(myArray[i]);
                 }
              }
              输出
              Array elements are:
              1
              2
              3
              4
              5
              示例 2
              在此例中,在调用方(Main 方法)中初始化数组 myArray,并通过使用 ref 参数将其传递给 FillArray 方法。在 FillArray 方法中更新某些数组元素。然后将数组元素返回调用方并显示。
              // cs_array_ref_and_out2.cs
              using System;
              class TestRef
              {
                 public static void FillArray(ref int[] arr)
                 {
                    // Create the array on demand:
                    if (arr == null)
                       arr = new int[10];
                    // Otherwise fill the array:
                    arr[0] = 123;
                    arr[4] = 1024;
                 }

                 static public void Main ()
                 {
                    // Initialize the array:
                    int[] myArray = {1,2,3,4,5}; 

                    // Pass the array using ref:
                    FillArray(ref myArray);

                    // Display the updated array:
                    Console.WriteLine("Array elements are:");
                    for (int i = 0; i < myArray.Length; i++)
                       Console.WriteLine(myArray[i]);
                 }
              }
              输出
              Array elements are:
              123
              2
              3
              4
              1024


                文章来源:http://blog.163.com/fengmk2/blog/static/891324020069524730717
                posted @ 2006-10-05 14:48 MK2 阅读(47) | 评论 (0)编辑