<![CDATA[H31Home家园]]> http://h31home.com/ H31Home 2010-3-11 14:12:06 <![CDATA[分布式基础学习]]> admin http://h31home.com/h312005/blogview.asp?ID=998 2009-2-23 15:14:31 2009-2-23 15:14:31
所谓分布式，在这里，很狭义的指代以Google的三驾马车，GFS、Map/Reduce、BigTable为框架核心的分布式存储和计算系统。通常如我一样初学的人，会以Google这几份经典的论文作为开端的。它们勾勒出了分布式存储和计算的一个基本蓝图，已可窥见其几分风韵，但终究还是由于缺少一些实现的代码和示例，色彩有些斑驳，缺少了点感性。幸好我们还有Open Source，还有Hadoop。Hadoop是一个基于Java实现的，开源的，分布式存储和计算的项目。作为这个领域最富盛名的开源项目之一，它的使用者也是大牌如云，包括了Yahoo，Amazon，Facebook等等（好吧，还可能有校内，不过这真的没啥分量...）。Hadoop本身，实现的是分布式的文件系统HDFS，和分布式的计算（Map/Reduce）框架，此外，它还不是一个人在战斗，Hadoop包含一系列扩展项目，包括了分布式文件数据库HBase（对应Google的BigTable），分布式协同服务ZooKeeper（对应Google的Chubby），等等。。。
如此，一个看上去不错的黄金搭档浮出水面，Google的论文 + Hadoop的实现，顺着论文的框架看具体的实现，用实现来进一步理解论文的逻辑，看上去至少很美。网上有很多前辈们，做过Hadoop相关的源码剖析工作，我关注最多的是这里，目前博主已经完成了HDFS的剖析工作，Map/Reduce的剖析正火热进行中，更新频率之高，剖析之详尽，都是难得一见的，所以，走过路过一定不要错过了。此外，还有很多Hadoop的关注者和使用者贴过相关的文章，比如：这里，这里。也可以去Hadoop的中文站点（不知是民间还是官方...），搜罗一些学习资料。。。
我个人从上述资料中受益匪浅，而我自己要做的整理，与原始的源码剖析有些不同，不是依照实现的模块，而是基于论文的脉络和实现这样系统的基本脉络来进行的，也算，从另一个角度给出一些东西吧。鉴于个人对于分布式系统的理解非常的浅薄，缺少足够的实践经验，深入的问题就不班门弄斧了，仅做梳理和解析，大牛至此，可绕路而行了。。。
一. 分布式文件系统

分布式文件系统，在整个分布式系统体系中处于最低层最基础的地位，存储嘛，没了数据，再好的计算平台，再完善的数据库系统，都成了无水之舟了。那么，什么是分布式文件系统，顾名思义，就是分布式+文件系统。它包含这两个方面的内涵，从文件系统的客户使用的角度来看，它就是一个标准的文件系统，提供了一系列API，由此进行文件或目录的创建、移动、删除，以及对文件的读写等操作。从内部实现来看，分布式的系统则不再和普通文件系统一样负责管理本地磁盘，它的文件内容和目录结构都不是存储在本地磁盘上，而是通过网络传输到远端系统上。并且，同一个文件存储不只是在一台机器上，而是在一簇机器上分布式存储，协同提供服务，正所谓分布式。。。
因此，考量一个分布式文件系统的实现，其实不妨可以从这两方面来分别剖析，而后合二为一。首先，看它如何去实现文件系统所需的基本增删改查的功能。然后，看它如何考虑分布式系统的特点，提供更好的容错性，负载平衡，等等之类的。这二者合二为一，就明白了一个分布式文件系统，整体的实现模式。。。
I. 术语对照
说任何东西，都需要统一一下语言先，不然明明说的一个意思，却容易被理解到另一个地方去。Hadoop的分布式文件系统HDFS，基本是按照Google论文中的GFS的架构来实现的。但是，HDFS为了彰显其不走寻常路的本性，其中的大量术语，都与GFS截然不同。明明都是一个枝上长的土豆，它偏偏就要叫山药蛋，弄得水火不容的，苦了我们看客。秉承老好人，谁也不得罪的方针，文中，既不采用GFS的叫法，也不采用Hadoop的称谓，而是另辟蹊径，自立门户，搞一套自己的中文翻译，为了避免不必要的痛楚，特此先来一帖术语对照表，要不懂查一查，包治百病。。。

文中所用翻译 HDFS中的术语 GFS中的术语 术语解释 
主控服务器 NameNode Master 整个文件系统的大脑，它提供整个文件系统的目录信息，并且管理各个数据服务器。 
数据服务器 DataNode Chunk Server 分布式文件系统中的每一个文件，都被切分成若干个数据块，每一个数据块都被存储在不同的服务器上，此服务器称之为数据服务器。 
数据块 Block Chunk 每个文件都会被切分成若干个块，每一块都有连续的一段文件内容，是存储的基恩单位，在这里统一称做数据块。 
数据包 Packet 无 客户端写文件的时候，不是一个字节一个字节写入文件系统的，而是累计到一定数量后，往文件系统中写入一次，每发送一次的数据，都称为一个数据包。 
传输块 Chunk 无 在每一个数据包中，都会将数据切成更小的块，每一个块配上一个奇偶校验码，这样的块，就是传输块。 
备份主控服务器 SecondaryNameNode 无 备用的主控服务器，在身后默默的拉取着主控服务器 的日志，等待主控服务器牺牲后被扶正。 


*注：本文采用的Hadoop是0.19.0版本。
II. 基本架构
1. 服务器介绍
与单机的文件系统不同，分布式文件系统不是将这些数据放在一块磁盘上，由上层操作系统来管理。而是存放在一个服务器集群上，由集群中的服务器，各尽其责，通力合作，提供整个文件系统的服务。其中重要的服务器包括：主控服务器（Master/NameNode），数据服务器（ChunkServer/DataNode），和客户服务器。HDFS和GFS都是按照这个架构模式搭建的。个人觉得，其中设计的最核心内容是：文件的目录结构独立存储在一个主控服务器上，而具体文件数据，拆分成若干块，冗余的存放在不同的数据服务器上。
存储目录结构的主控服务器，在GFS中称为Master，在HDFS中称为NameNode。这两个名字，叫得都有各自的理由，是瞎子摸象各表一面。Master是之于数据服务器来叫的，它做为数据服务器的领导同志存在，管理各个数据服务器，收集它们的信息，了解所有数据服务器的生存现状，然后给它们分配任务，指挥它们齐心协力为系统服务；而NameNode是针对客户端来叫的，对于客户端而言，主控服务器上放着所有的文件目录信息，要找一个文件，必须问问它，由此而的此名。。。
主控服务器在整个集群中，同时提供服务的只存在一个，如果它不幸牺牲的话，会有后备军立刻前赴后继的跟上，但，同一时刻，需要保持一山不容二虎的态势。这种设计策略，避免了多台服务器间即时同步数据的代价，而同时，它也使得主控服务器很可能成为整个架构的瓶颈所在。因此，尽量为主控服务器减负，不然它做太多的事情，就自然而然的晋升成了一个分布式文件系统的设计要求。。。
每一个文件的具体数据，被切分成若干个数据块，冗余的存放在数据服务器。通常的配置，每一个数据块的大小为64M，在三个数据服务器上冗余存放（这个64M，不是随便得来的，而是经过反复实践得到的。因为如果太大，容易造成热点的堆叠，大量的操作集中在一台数据服务器上，而如果太小的话，附加的控制信息传输成本，又太高了。因此没有比较特定的业务需求，可以考虑维持此配置...）。数据服务器是典型的四肢发达头脑简单的苦力，其主要的工作模式就是定期向主控服务器汇报其状况，然后等待并处理命令，更快更安全的存放好数据。。。
此外，整个分布式文件系统还有一个重要角色是客户端。它不和主控服务和数据服务一样，在一个独立的进程中提供服务，它只是以一个类库（包）的模式存在，为用户提供了文件读写、目录操作等APIs。当用户需要使用分布式文件系统进行文件读写的时候，把客户端相关包给配置上，就可以通过它来享受分布式文件系统提供的服务了。。。
2. 数据分布
一个文件系统中，最重要的数据，其实就是整个文件系统的目录结构和具体每个文件的数据。具体的文件数据被切分成数据块，存放在数据服务器上。每一个文件数据块，在数据服务器上都表征为出双入队的一对文件（这是普通的Linux文件），一个是数据文件，一个是附加信息的元文件，在这里，不妨把这对文件简称为数据块文件。数据块文件存放在数据目录下，它有一个名为current的根目录，然后里面有若干个数据块文件和从dir0-dir63的最多64个的子目录，子目录内部结构等同于current目录，依次类推（更详细的描述，参见这里）。个人觉得，这样的架构，有利于控制同一目录下文件的数量，加快检索速度。。。
这是磁盘上的物理结构，与之对应的，是内存中的数据结构，用以表征这样的磁盘结构，方便读写操作的进行。Block类用于表示数据块，而FSDataset类是数据服务器管理文件块的数据结构，其中，FSDataset.FSDir对应着数据块文件和目录，FSDataset.FSVolume对应着一个数据目录，FSDataset.FSVolumeSet是FSVolume的集合，每一个FSDataset有一个FSVolumeSet。多个数据目录，可以放在不同的磁盘上，这样有利于加快磁盘操作的速度。相关的类图，可以参看这里 。。。
此外，与FSVolume对应的，还有一个数据结构，就是DataStorage，它是Storage的子类，提供了升级、回滚等支持。但与FSVolume不一样，它不需要了解数据块文件的具体内容，它只知道有这么一堆文件放这里，会有不同版本的升级需求，它会处理怎么把它们升级回滚之类的业务（关于Storage，可以参见这里）。而FSVolume提供的接口，都基本上是和Block相关的。。。
相比数据服务器，主控服务器的数据量不大，但逻辑更为复杂。主控服务器主要有三类数据：文件系统的目录结构数据，各个文件的分块信息，数据块的位置信息（就数据块放置在哪些数据服务器上...）。在GFS和HDFS的架构中，只有文件的目录结构和分块信息才会被持久化到本地磁盘上，而数据块的位置信息则是通过动态汇总过来的，仅仅存活在内存数据结构中，机器挂了，就灰飞烟灭了。每一个数据服务器启动后，都会向主控服务器发送注册消息，将其上数据块的状况都告知于主控服务器。俗话说，简单就是美，根据DRY原则，保存的冗余信息越少，出现不一致的可能性越低，付出一点点时间的代价，换取了一大把逻辑上的简单性，绝对应该是一个包赚不赔的买卖。。。
在HDFS中，FSNamespacesystem类就负责保管文件系统的目录结构以及每个文件的分块状况的，其中，前者是由FSDirectory类来负责，后者是各个INodeFile本身维护。在INodeFile里面，有一个BlockInfo的数组，保存着与该文件相关的所有数据块信息，BlockInfo中包含了从数据块到数据服务器的映射，INodeFile只需要知道一个偏移量，就可以提供相关的数据块，和数据块存放的数据服务器信息。。。
3、服务器间协议
在Hadoop的实现中，部署了一套RPC机制，以此来实现各服务间的通信协议。在Hadoop中，每一对服务器间的通信协议，都定义成为一个接口。服务端的类实现该接口，并且建立RPC服务，监听相关的接口，在独立的线程处理RPC请求。客户端则可以实例化一个该接口的代理对象，调用该接口的相应方法，执行一次同步的通信，传入相应参数，接收相应的返回值。基于此RPC的通信模式，是一个消息拉取的流程，RPC服务器等待RPC客户端的调用，而不会先发制人主动把相关信息推送到RPC客户端去。。。
其实RPC的模式和原理，实在是没啥好说的，之所以说，是因为可以通过把握好这个，彻底理顺Hadoop各服务器间的通信模式。Hadoop会定义一些列的RPC接口，只需要看谁实现，谁调用，就可以知道谁和谁通信，都做些啥事情，图中服务器的基本架构、各服务所使用的协议、调用方向、以及协议中的基本内容。。。

III. 基本的文件操作

基本的文件操作，可以分成两类，一个是对文件目录结构的操作，比如文件和目录的创建、删除、移动、更名等等；另一个是对文件数据流的操作，包括读取和写入文件数据。当然，文件读和写，是有本质区别的，尤其是在数据冗余的情况下，因此，当成两类操作也不足为过。此外，要具体到读写的类别，也是可以再继续分类下去的。在GFS的论文中，对于分布式文件系统的读写场景有一个重要的假定（其实是从实际业务角度得来的...）：就是文件的读取是由大数据量的连续读取和小数据量的随机读取组成，文件的写入则基本上都是批量的追加写，和偶尔的插入写（GFS中还有大量的假设，它们构成了分布式文件系统架构设计的基石。每一个系统架构都是搭建在一定假设上的，这些假设有些来自于实际业务的状况，有些是因为天生的条件约束，不基于假设理解设计，肯定会有失偏颇...）。在GFS中，对文件的写入分成追加写和插入写都有所支持，但是，在HDFS中仅仅支持追加写，这大大降低了复杂性。关于HDFS与GFS的一些不同，可以参看这里。。。
1. 文件和目录的操作
文件目录的信息，全部囤积在主控服务器上，因此，所有对文件目录的操作，只会直接涉及到客户端和主控服务器。整个目录相关的操作流程基本都是这样的：客户端DFSClient调用ClientProtocol定义的相关函数，该操作通过RPC传送到其实现者主控服务器NameNode那里，NameNode做相关的处理后（很少...），调用FSNamesystem的相关函数。在FSNamesystem中，往往是做一些验证和租约操作，具体的目录结构操作交由FSDirectory的相应函数来操作。最后，依次返回，经由RPC传送回客户端。具体各操作涉及到的函数和具体步骤，参见下表：


相关操作 ClientProtocol / NameNode FSNamesystem FSDirectory 关键步骤 
创建文件 create startFile addFile 1. 检查是否有写权限；
2. 检查是否已经存在此文件，如果是覆写，则先进行删除操作；
3. 在指定路径下添加INodeFileUnderConstruction的文件实例；
4. 写日志；
5. 签订租约。 
创建目录 mkdirs mkdirs mkdirs 1. 检查指定目录是否是目录；
2. 检查是否有相关权限；
3. 在指定路径的INode下，添加子节点；
4. 写日志。 
改名操作 rename renameTo renameTo 1. 检查相关路径的权限；
2. 从老路径下移除，在新路径下添加；
3. 修改相关父路径的修改时间；
4. 写日志；
5. 将租约从老路径移动到新路径下。 
删除操作 delete delete delete 1. 如果不是递归删除，确认指定路径是否是空目录；
2. 检查相关权限；
3. 在目录结构上移除相关INode；
4. 修改父路径的修改时间；
5. 将相关的数据块，放入到废弃队列中去，等待处理；
6. 写日志；
7. 废弃相关路径的租约。 
设置权限 setPermission setPermission setPermission 1. 检查owner判断是否有操作权限；
2. 修改指定路径下INode的权限；
3. 写日志。 
设置用户 setOwner setOwner setOwner 1. 检查是否有操作权限；
2. 修改指定路径下INode的权限；
3. 写日志。 
设置时间 setTimes setTimes setTimes 1. 检查是否有写权限；
2. 修改指定路径INode的时间信息；
3. 写日志。 



从上表可以看到，其实有的操作本质上还是涉及到了数据服务器，比如文件创建和删除操作。但是，之前提到，主控服务器只于数据服务器是一个等待拉取的地位，它们不会主动联系数据服务器，将指令传输给它们，而是放到相应的数据结构中，等待数据服务器来取。这样的设计，可以减少通信的次数，加快操作的执行速度。。。
另，上述步骤中，有些日志和租约相关的操作，从概念上来说，和目录操作其实没有任何联系，但是，为了满足分布式系统的需求，这些操作是非常有必要的，在此，按下不表。。。
2、文件的读取
不论是文件读取，还是文件的写入，主控服务器扮演的都是中介的角色。客户端把自己的需求提交给主控服务器，主控服务器挑选合适的数据服务器，介绍给客户端，让客户端和数据服务器单聊，要读要写随你们便。这种策略类似于DMA，降低了主控服务器的负载，提高了效率。。。
因此，在文件读写操作中，最主要的通信，发生在客户端与数据服务器之间。它们之间跑的协议是ClientDatanodeProtocol。从这个协议中间，你无法看到和读写相关的接口，因为，在Hadoop中，读写操作是不走RPC机制的，而是另立门户，独立搭了一套通信框架。在数据服务器一端，DataNode类中有一个DataXceiverServer类的实例，它在一个单独的线程等待请求，一旦接到，就启动一个DataXceiver的线程，处理此次请求。一个请求一个线程，对于数据服务器来说，逻辑上很简单。当下，DataXceiver支持的请求类型有六种，具体的请求包和回复包格式，请参见这里，这里，这里。在Hadoop的实现中，并没有用类来封装这些请求，而是按流的次序写下来，这给代码阅读带来挺多的麻烦，也对代码的维护带来一定的困难，不知道是出于何种考虑。。。
相比于写，文件的读取实在是一个简单的过程。在客户端DFSClient中，有一个DFSClient.DFSInputStream类。当需要读取一个文件的时候，会生成一个DFSInputStream的实例。它会先调用ClientProtocol定义getBlockLocations接口，提供给NameNode文件路径、读取位置、读取长度信息，从中取得一个LocatedBlocks类的对象，这个对象包含一组LocatedBlock，那里面有所规定位置中包含的所有数据块信息，以及数据块对应的所有数据服务器的位置信息。当读取开始后，DFSInputStream会先尝试从某个数据块对应的一组数据服务器中选出一个，进行连接。这个选取算法，在当下的实现中，非常简单，就是选出第一个未挂的数据服务器，并没有加入客户端与数据服务器相对位置的考量。读取的请求，发送到数据服务器后，自然会有DataXceiver来处理，数据被一个包一个包发送回客户端，等到整个数据块的数据都被读取完了，就会断开此链接，尝试连接下一个数据块对应的数据服务器，整个流程，依次如此反复，直到所有想读的都读取完了为止。。。
3、文件的写入
文件读取是一个一对一的过程，一个客户端，只需要与一个数据服务器联系，就可以获得所需的内容。但是，写入操作，则是一个一对多的流程。一次写入，需要在所有存放相关数据块的数据服务器都保持同步的更新，有任何的差池，整个流程就告失败。。。
在分布式系统中，一旦涉及到写入操作，并发处理难免都会沦落成为一个变了相的串行操作。因为，如果不同的客户端如果是任意时序并发写入的话，整个写入的次序无法保证，可能你写半条记录我写半条记录，最后出来的结果乱七八糟不可估量。在HDFS中，并发写入的次序控制，是由主控服务器来把握的。当创建、续写一个文件的时候，该文件的节点类，由INodeFile升级成为INodeFileUnderConstruction，INodeFileUnderConstruction是INodeFile的子类，它起到一个锁的作用。如果当一个客户端想创建或续写的文件是INodeFileUnderConstruction，会引发异常，因为这说明这个此处有爷，请另寻高就，从而保持了并发写入的次序性。同时，INodeFileUnderConstruction有包含了此时正在操作它的客户端的信息以及最后一个数据块的数据服务器信息，当追加写的时候可以更快速的响应。。。
与读取类似，DFSClient也有一个DFSClient.DFSOutputStream类，写入开始，会创建此类的实例。DFSOutputStream会从NameNode上拿一个LocatedBlock，这里面有最后一个数据块的所有数据服务器的信息。这些数据服务器每一个都需要能够正常工作（对于读取，只要还有一个能工作的就可以实现...），它们会依照客户端的位置被排列成一个有着最近物理距离和最小的序列（物理距离，是根据机器的位置定下来的...），这个排序问题类似于著名旅行商问题，属于NP复杂度，但是由于服务器数量不多，所以用最粗暴的算法，也并不会看上去不美。。。
文件写入，就是在这一组数据服务器上构造成数据流的双向流水线。DFSOutputStream，会与序列的第一个数据服务器建立Socket连接，发送请求头，然后等待回应。DataNode同样是建立DataXceiver来处理写消息，DataXceiver会依照包中传过来的其他服务器的信息，建立与下一个服务器的连接，并生成类似的头，发送给它，并等待回包。此流程依次延续，直到最后一级，它发送回包，反向着逐级传递，再次回到客户端。如果一切顺利，那么此时，流水线建立成功，开始正式发送数据。数据是分成一个个数据包发送的，所有写入的内容，被缓存在客户端，当写满64K，会被封装成DFSOutputStream.Packet类实例，放入DFSOutputStream的dataQueue队列。DFSOutputStream.DataStreamer会时刻监听这个队列，一旦不为空，则开始发送，将位于dataQueue队首的包移动到ackQueue队列的队尾，表示已发送但尚未接受回复的包队列。同时启动ResponseProcessor线程监听回包，直到收到相应回包，才将发送包从ackQueue中移除，表示成功。每一个数据服务器的DataXceiver收到了数据包，一边写入到本地文件中去，一边转发给下一级的数据服务器，等待回包，同前面建立流水线的流程。。。
当一个数据块写满了之后，客户端需要向主控服务器申请追加新的数据块。这个会引起一次数据块的分配，成功后，会将新的数据服务器组返还给客户端。然后重新回到上述流程，继续前行。。。
关于写入的流程，还可以参见这里。此外，写入涉及到租约问题，后续会仔细的来说。。。
IV. 分布式支持

如果单机的文件系统是田里勤恳的放牛娃，那么分布式文件系统就是刀尖上讨饭吃的马贼了。在分布式环境中，有太多的意外，数据随时传输错误，服务器时刻准备牺牲，很多平常称为异常的现象，在这里都需要按照平常事来对待。因此，对于分布式文件系统而言，仅仅是满足了正常状况下文件系统各项服务还不够，还需要保证分布式各种意外场景下健康持续的服务，否则，将一无是处。。。
1、服务器的错误恢复
在分布式环境中，哪台服务器牺牲都是常见的事情，牺牲不可怕，可怕的是你都没有时刻准备好它们会牺牲。作为一个合格的分布式系统，HDFS当然时刻准备好了前赴后继奋勇向前。HDFS有三类服务器，每一类服务器出错了，都有相应的应急策略。。。
a. 客户端

生命最轻如鸿毛的童鞋，应该就是客户端了。毕竟，做为一个文件系统的使用者，在整个文件系统中的地位，难免有些归于三流。而作为客户端，大部分时候，牺牲了就牺牲了，没人哀悼，无人同情，只有在在辛勤写入的时候，不幸辞世（机器挂了，或者网络断了，诸如此类...），才会引起些恐慌。因为，此时此刻，在主控服务器上对应的文件，正作为INodeFileUnderConstruction活着，仅仅为占有它的那个客户端服务者，做为一个专一的文件，它不允许别的客户端染指。这样的话，一旦占有它的客户端服务者牺牲了，此客户端会依然占着茅坑不拉屎，让如花似玉INodeFileUnderConstruction孤孤单单守寡终身。这种事情当然无法容忍，因此，必须有办法解决这个问题，办法就是：租约。。。
租约，顾名思义，就是当客户端需要占用某文件的时候，与主控服务器签订的一个短期合同。这个合同有一个期限，在这个期限内，客户端可以延长合同期限，一旦超过期限，主控服务器会强行终止此租约，将这个文件的享用权，分配给他人。。。
在打开或创建一个文件，准备追加写之前，会调用LeaseManager的addLease方法，在指定的路径下与此客户端签订一份租约。客户端会启动DFSClient.LeaseChecker线程，定时轮询调用ClientProtocol的renewLease方法，续签租约。在主控服务器一端，有一个LeaseManager.Monitor线程，始终在轮询检查所有租约，查看是否有到期未续的租约。如果一切正常，该客户端完成写操作，会关闭文件，停止租约，一旦有所意外，比如文件被删除了，客户端牺牲了，主控服务器都会剥夺此租约，如此，来避免由于客户端停机带来的资源被长期霸占的问题。。。
b. 数据服务器

当然，会挂的不只是客户端，海量的数据服务器是一个更不稳定的因素。一旦某数据服务器牺牲了，并且主控服务器被蒙在鼓中，主控服务器就会变相的欺骗客户端，给它们无法连接的读写服务器列表，导致它们处处碰壁无法工作。因此，为了整个系统的稳定，数据服务器必须时刻向主控服务器汇报，保持主控服务器对其的完全了解，这个机制，就是心跳消息。在HDFS中，主控服务器NameNode实现了DatanodeProtocol接口，数据服务器DataNode会在主循环中，不停的调用该协议中的sendHeartbeat方法，向NameNode汇报状况。在此调用中，DataNode会将其整体运行状况告知NameNode，比如：有多少可用空间、用了多大的空间，等等之类。NameNode会记住此DataNode的运行状况，作为新的数据块分配或是负载均衡的依据。当NameNode处理完成此消息后，会将相关的指令封装成一个DatanodeCommand对象，交还给DataNode，告诉数据服务器什么数据块要删除什么数据块要新增等等之类，数据服务器以此为自己的行动依据。。。
但是，sendHeartbeat并没有提供本地的数据块信息给NameNode，那么主控服务器就无法知道此数据服务器应该分配什么数据块应该删除什么数据块，那么它是如何决定的呢？答案就是DatanodeProtocol定义的另一个方法，blockReport。DataNode也是在主循环中定时调用此方法，只是，其周期通常比调用sendHeartbeat的更长。它会提交本地的所有数据块状况给NameNode，NameNode会和本地保存的数据块信息比较，决定什么该删除什么该新增，并将相关结果缓存在本地对应的数据结构中，等待此服务器再发送sendHeartbeat消息过来的时候，依照这些数据结构中的内容，做出相应的DatanodeCommand指令。blockReport方法同样也会返回一个DatanodeCommand给DataNode，但通常，只是为空（只有出错的时候不为空），我想，增加缓存，也许是为了确保每个指令都可以重复发送并确定被执行。。。
c. 主控服务器

当然，作为整个系统的核心和单点，含辛茹苦的主控服务器含泪西去，整个分布式文件服务集群将彻底瘫痪罢工。如何在主控服务器牺牲后，提拔新的主控服务器并迅速使其进入工作角色，就成了系统必须考虑的问题。解决策略就是：日志。。。
其实这并不是啥新鲜东西，一看就知道是从数据库那儿偷师而来的。在主控服务器上，所有对文件目录操作的关键步骤（具体文件内容所处的数据服务器，是不会被写入日志的，因为这些内容是动态建立的...），都会被写入日志。另外，主控服务器会在某些时刻，将当下的文件目录完整的序列化到本地，这称为镜像。一旦存有镜像，镜像前期所写的日志和其他镜像，都纯属冗余，其历史使命已经完成，可以报废删除了。在主控服务器不幸牺牲，或者是战略性的停机修整结束，并重新启动后，主控服务器会根据最近的镜像 + 镜像之后的所有日志，重建整个文件目录，迅速将服务能力恢复到牺牲前的水准。。。
对于数据服务器而言，它们会通过一些手段，迅速得知顶头上司的更迭消息。它们会立刻转投新东家的名下，在新东家旗下注册，并开始向其发送心跳消息，这个机制，可能用分布式协同服务来实现，这里不说也罢。。。
在HDFS的实现中，FSEditLog类是整个日志体系的核心，提供了一大堆方便的日志写入API，以及日志的恢复存储等功能。目前，它支持若干种日志类型，都冠以OP_XXX，并提供相关API，具体可以参见这里。为了保证日志的安全性，FSEditLog提供了EditLogFileOutputStream类作为写入的承载类，它会同时开若干个本地文件，然后依次写入，防止日志的损坏导致不可估量的后果。在FSEditLog上面，有一个FSImage类，存储文件镜像并调用FSEditLog对外提供相关的日志功能。FSImage是Storage类的子类，如果对数据块的讲述有所印象的话，你可以回忆起来，凡事从此类派生出来的东西，都具有版本性质，可以进行升级和回滚等等，以此，来实现产生镜像是对原有日志和镜像处理的复杂逻辑。。。
目前，在HDFS的日志系统中，有些地方与GFS的描述有所不同。在HDFS中，所有日志文件和镜像文件都是本地文件，这就相当于，把日志放在自家的保险箱中，一旦主控服务器挂了，别的后继而上的服务器也无法拿到这些日志和镜像，用于重振雄风。因此，在HDFS中，运行着一个SecondaryNameNode服务器，它做为主控服务器的替补，隐忍厚积薄发为篡位做好准备，其中，核心内容就是：定期下载并处理日志和镜像。SecondaryNameNode看上去像客户端一样，与NameNode之间，走着NamenodeProtocol协议。它会不停的查看主控服务器上面累计日志的大小，当达到阈值后，调用doCheckpoint函数，此函数的主要步骤包括：
首先是调用startCheckpoint做一些本地的初始化工作；

然后调用rollEditLog，将NameNode上此时操作的日志文件从edit切到edit.new上来，这个操作瞬间完成，上层写日志的函数完全感觉不到差别；

接着，调用downloadCheckpointFiles，将主控服务器上的镜像文件和日志文件都下载到此候补主控服务器上来；

并调用doMerge，打开镜像和日志，将日志生成新的镜像，保存覆盖；

下一步，调用putFSImage把新的镜像上传回NameNode；

再调用rollFsImage，将镜像换成新的，在日志从edit.new改名为edit；

最后，调用endCheckpoint做收尾工作。

整个算法涉及到NameNode和SecondaryNameNode两个服务器，最终结果是NameNode和SecondaryNameNode都依照算法进行前的日志生成了镜像。而两个服务器上日志文件的内容，前者是整个算法进行期间所写的日志，后者始终不会有任何日志。当主控服务器牺牲的时候，运行SecondaryNameNode的服务器立刻被扶正，在其上启动主控服务，利用其日志和镜像，恢复文件目录，并逐步接受各数据服务器的注册，最终向外提供稳定的文件服务。。。
同样的事情，GFS采用的可能是另外一个策略，就是在写日志的时候，并不局限在本地，而是同时书写网络日志，即在若干个远程服务器上生成同样的日志。然后，在某些时机，主控服务器自己，生成镜像，降低日志规模。当主控服务器牺牲，可以在拥有网络日志的服务器上启动主控服务，升级成为主控服务器。。。
GFS与HDFS的策略相比较，前者是化整为零，后者则是批量处理，通常我们认为，批量处理的平均效率更高一些，且相对而言，可能实现起来容易一些，但是，由于有间歇期，会导致日志的丢失，从而无法100%的将备份主控服务器的状态与主控服务器完全同步。。。
2、数据的正确性保证

在复杂纷繁的分布式环境中，我们坚定的相信，万事皆有可能。哪怕各个服务器都舒舒服服的活着，也可能有各种各样的情况导致网络传输中的数据丢失或者错误。并且在分布式文件系统中，同一份文件的数据，是存在大量冗余备份的，系统必须要维护所有的数据块内容完全同步，否则，一人一言，不同客户端读同一个文件读出不同数据，用户非得疯了不可。。。
在HDFS中，为了保证数据的正确性和同一份数据的一致性，做了大量的工作。首先，每一个数据块，都有一个版本标识，在Block类中，用一个长整型的数generationStamp来表示版本信息（Block类是所有表示数据块的数据结构的基类），一旦数据块上的数据有所变化，此版本号将向前增加。在主控服务器上，保存有此时每个数据块的版本，一旦出现数据服务器上相关数据块版本与其不一致，将会触发相关的恢复流程。这样的机制保证了各个数据服务器器上的数据块，在基本大方向上都是一致的。但是，由于网络的复杂性，简单的版本信息无法保证具体内容的一致性（因为此版本信息与内容无关，可能会出现版本相同，但内容不同的状况）。因此，为了保证数据内容上的一致，必须要依照内容，作出签名。。。
当客户端向数据服务器追加写入数据包时，每一个数据包的数据，都会切分成512字节大小的段，作为签名验证的基本单位，在HDFS中，把这个数据段称为Chunk，即传输块（注意，在GFS中，Chunk表达的是数据块...）。在每一个数据包中，都包含若干个传输块以及每一个传输块的签名，当下，这个签名是根据Java SDK提供的CRC算法算得的，其实就是一个奇偶校验。当数据包传输到流水线的最后一级，数据服务器会对其进行验证（想一想，为什么只在最后一级做验证，而不是每级都做...），一旦发现当前的传输块签名与在客户端中的签名不一致，整个数据包的写入被视为无效，Lease Recover（租约恢复）算法被触发。。。
从基本原理上看，这个算法很简单，就是取所有数据服务器上此数据块的最小长度当作正确内容的长度，将其他数据服务器上此数据块超出此长度的部分切除。从正确性上看，此算法无疑是正确的，因为至少有一个数据服务器会发现此错误，并拒绝写入，那么，如果写入了的，都是正确的；从效率上看，此算法也是高效的，因为它避免了重复的传输和复杂的验证，仅仅是各自删除尾部的一些内容即可。但从具体实现上来看，此算法稍微有些绕，因为，为了降低本已不堪重负的主控服务器的负担，此算法不是由主控服务器这个大脑发起的，而是通过选举一个数据服务器作为Primary，由Primary发起，通过调用与其他各数据服务器间的InterDatanodeProtocol协议，最终完成的。具体的算法流程，参见LeaseManager类上面的注释。需要说明的是此算法的触发时机和发起者。此算法可以由客户端或者是主控服务器发起，当客户端在写入一个数据包失败后，会发起租约恢复。因为，一次写入失败，不论是何种原因，很有可能就会导致流水线上有的服务器写了，有的没写，从而造成不统一。而主控服务器发起的时机，则是在占有租约的客户端超出一定时限没有续签，这说明客户端可能挂了，在临死前可能干过不利于数据块统一的事情，作为监督者，主控服务器需要发起一场恢复运动，确保一切正确。。。
3、负载均衡

负载的均衡，是分布式系统中一个永恒的话题，要让大家各尽其力齐心干活，发挥各自独特的优势，不能忙得忙死闲得闲死，影响战斗力。而且，负载均衡也是一个复杂的问题，什么是均衡，是一个很模糊的概念。比如，在分布式文件系统中，总共三百个数据块，平均分配到十个数据服务器上，就算均衡了么？其实不一定，因为每一个数据块需要若干个备份，各个备份的分布应该充分考虑到机架的位置，同一个机架的服务器间通信速度更快，而分布在不同机架则更具有安全性，不会在一棵树上吊死。。。
在这里说的负载均衡，是宽泛意义上的均衡过程，主要涵盖两个阶段的事务，一个是在任务初始分配的时候尽可能合理分配，另一个是在事后时刻监督及时调整。。。
在HDFS中，ReplicationTargetChooser类，是负责实现为新分配的数据块寻找婆家的。基本上来说，数据块的分配工作和备份的数量、申请的客户端地址（也就是写入者）、已注册的数据服务器位置，密切相关。其算法基本思路是只考量静态位置信息，优先照顾写入者的速度，让多份备份分配到不同的机架去。具体算法，自行参见源码。此外，HDFS的Balancer类，是为了实现动态的负载调整而存在的。Balancer类派生于Tool类，这说明，它是以一个独立的进程存在的，可以独立的运行和配置。它运行有NamenodeProtocol和ClientProtocol两个协议，与主控服务器进行通信，获取各个数据服务器的负载状况，从而进行调整。主要的调整其实就是一个操作，将一个数据块从一个服务器搬迁到另一个服务器上。Balancer会向相关的目标数据服务器发出一个DataTransferProtocol.OP_REPLACE_BLOCK消息，接收到这个消息的数据服务器，会将数据块写入本地，成功后，通知主控服务器，删除早先的那个数据服务器上的同一块数据块。具体的算法请自行参考源码。。。
4、垃圾回收
对于垃圾，大家应该耳熟能详了，在分布式文件系统而言，没有利用价值的数据块备份，就是垃圾。在现实生活中，我们提倡垃圾分类，为了更好的理解分布式文件系统的垃圾收集，搞个分类也是很有必要的。基本上，所有的垃圾都可以视为两类，一类是由系统正常逻辑产生的，比如某个文件被删除了，所有相关的数据块都沦为垃圾了，某个数据块被负载均衡器移动了，原始数据块也不幸成了垃圾了。此类垃圾最大的特点，就是主控服务器是生成垃圾的罪魁祸首，也就是说主控服务器完全了解有哪些垃圾需要处理。另外还有一类垃圾，是由于系统的一些异常症状产生的，比如某个数据服务器停机了一段，重启之后发现其上的某个数据块已经在其他服务器上重新增加了此数据块的备份，它上面的那个备份过期了失去价值了，需要被当作垃圾来处理了。此类垃圾的特点恰恰相反，主控服务器无法直接了解到垃圾状况，需要曲线救国。。。
在HDFS中，第一类垃圾的判定自然很容易，在一些正常的逻辑中产生的垃圾，全部被塞进了FSNamesystem的recentInvalidateSets这个Map中。而第二类垃圾的判定，则放在数据服务器发送其数据块信息来的过程中，经过与本地信息的比较，可以断定，此数据服务器上有哪些数据块已经不幸沦为垃圾。同样，这些垃圾也被塞到recentInvalidateSets中去。在与数据服务器进行心跳交流的过程中，主控服务器会将它上面有哪些数据块需要删除，数据服务器对这些数据块的态度是，直接物理删除。在GFS的论文中，对如何删除一个数据块有着不同的理解，它觉着应该先缓存起来，过几天没人想恢复它了再删除。在HDFS的文档中，则明确表示，在现行的应用场景中，没有需要这个需求的地方，因此，直接删除就完了。这说明，理念是一切分歧的根本：）。。。
V. 总结

整个分布式文件系统，计算系统，数据库系统的设计理念，基本是一脉相承的。三类服务器、作为单点存在的核心控制服务器、基于日志的恢复机制、基于租约的保持联系机制、等等，在后续分布式计算系统和分布式数据库中都可以看到类似的影子，在分布式文件系统这里，我详述了这些内容，可能在后续就会默认知道而说的比较简略了。而刨去这一些，分布式文件系统中最大特点，就是文件块的冗余存储，它直接导致了较为复杂的写入流程。当然，虽说分布式文件系统在分布式计算和数据库中都有用到，但如果对其机理没有兴趣，只要把它当成是一个可以在任何机器上使用的文件系统，就不会对其他上层建筑的理解产生障碍。。。]]> http://h31home.com/h312005/blogview.asp?ID=998 <![CDATA[VC进程间通信消息]]> admin http://h31home.com/h312005/blogview.asp?ID=997 2009-2-3 17:13:07 2009-2-3 17:13:07 void CH31Connect1Dlg::OnOK() 
{
CWnd *pCwnd； 
//用FindWindow函数找到想要关闭的应用程序的句柄的指针 
pCwnd=FindWindow(NULL,"H31CONNECT2")； 
//如果返回成功 
CString str="sendisok"；
COPYDATASTRUCT aa；
aa.dwData=1；
aa.cbData=str.GetLength()+1；
//memcpy(aa.lpData,str,aa.cbData)；
aa.lpData = (void*)str.GetBuffer(aa.cbData)；
if( pCwnd )
::SendMessage(pCwnd->m_hWnd,WM_COPYDATA,(WPARAM)this->m_hWnd,(LPARAM)&aa)；//给其发送关闭的消息 
}
程序2添加OnCopyData事件
BOOL CH31Connect2Dlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct) 
{
// TODO: Add your message handler code here and/or call default
CString aa = (LPCSTR)(pCopyDataStruct->lpData)； 
AfxMessageBox(aa)；
//return CDialog::OnCopyData(pWnd, pCopyDataStruct)；
return true；
}]]> http://h31home.com/h312005/blogview.asp?ID=997 <![CDATA[C#测试委托+观察者模式]]> admin http://h31home.com/h312005/blogview.asp?ID=996 2008-12-5 11:22:43 2008-12-5 11:22:43 using System.Collections.Generic；
using System.Text；
namespace ConsoleApplication1
{
      class Program
    {
        
        static void Main(string[] args)
        {
    //测试委托+观察者模式
            HBoss aa = new HBoss()；
            HObserver bb = new HObserver("XXXX", aa)；
            aa.Update += new EventHandler(bb.CloseStock)；
            aa.SubjectState = "Boss comeback.."；
            aa.Notify()；
        }
    }
    interface Subject
    {
        void Notify()；
        string SubjectState
        {
            get；
            set；
        }
    }
    class HObserver
    {
        private string name；
        private Subject sub；
        public HObserver(string name,Subject sub)
        {
            this.name = name；
            this.sub = sub；
        }
        public void CloseStock()
        {
            Console.WriteLine("{0},{1}关闭股票行情，继续工作", sub.SubjectState,name)；
        }
    }
    delegate void EventHandler()；
    class HBoss:Subject
    {
        public event EventHandler Update；
        private string action；
        public void Notify()
        {
            Update()；
        }
        public string SubjectState
        {
            get { return action； }
            set { action = value； }
        }
    }；
}
--------------------------------------------
using System；
using System.Collections.Generic；
using System.Text；
namespace ConsoleApplication1
{
     public class A   
    {   
        public A()   
        {   
        Console.WriteLine('A')；   
        }   
        public virtual void Fun()   
        {   
        Console.WriteLine("A.Fun()")；   
        }   
    }
    public class B : A
    {
        public B()
        {
            Console.WriteLine('B')；
        }
        public new void Fun()
        {
            Console.WriteLine("B.Fun()")；
        }
    }
    class Class1 
    { 
        public static int Count = 0； 
        static Class1() 
        { 
        Count++； 
        } 
        public Class1() 
        { 
        Count++； 
        } 
    } 
    class Program
    {
        
        static void Main(string[] args)
        {
            //A a = new B()；   
            //a.Fun()；
            //Class1 o1 = new Class1()；
            //Class1 o2 = new Class1()； 
   //输出A         B           A.Fun()

        }
    }
 
}]]> http://h31home.com/h312005/blogview.asp?ID=996 <![CDATA[DataTable使用技巧总结 ]]> admin http://h31home.com/h312005/blogview.asp?ID=995 2008-9-25 9:32:23 2008-9-25 9:32:23

        一、DataTable简介     

          (1)构造函数 
          DataTable()   不带参数初始化DataTable 类的新实例。 
          DataTable(string tableName)  用指定的表名初始化DataTable 类的新实例。 
          DataTable(string tableName, string tableNamespace) 用指定的表名和命名空间初始化DataTable 类的新实例。 
          (2) 常用属性 
          CaseSensitive    指示表中的字符串比较是否区分大小写。 
          ChildRelations   获取此DataTable 的子关系的集合。 
          Columns             获取属于该表的列的集合。 
          Constraints        获取由该表维护的约束的集合。 
          DataSet               获取此表所属的DataSet。DataSet相关信息，可见我以前的一篇文章《数据访问(2)－DataSet》 
          DefaultView       获取可能包括筛选视图或游标位置的表的自定义视图。 
          HasErrors          获取一个值，该值指示该表所属的DataSet 的任何表的任何行中是否有错误。 
          MinimumCapacity  获取或设置该表最初的起始大小。该表中行的最初起始大小。默认值为 50。 
          Rows                  获取属于该表的行的集合。 
          TableName       获取或设置DataTable 的名称。 


          (3)常用方法 
          AcceptChanges()   提交自上次调用AcceptChanges() 以来对该表进行的所有更改。 
          BeginInit()         开始初始化在窗体上使用或由另一个组件使用的DataTable。初始化发生在运行时。 

          Clear()               清除所有数据的DataTable。 
          Clone()              克隆DataTable 的结构，包括所有DataTable 架构和约束。 
          EndInit()            结束在窗体上使用或由另一个组件使用的DataTable 的初始化。初始化发生在运行时。 
          ImportRow(DataRow row)    将DataRow 复制到DataTable 中，保留任何属性设置以及初始值和当前值。 
          Merge(DataTable table)  将指定的DataTable 与当前的DataTable 合并。 
          NewRow()         创建与该表具有相同架构的新DataRow。
 
        二、DataTable使用技巧

      （1）Create a DataTable
         DataTable dt = new DataTable("Table_AX")； 


      （2）Add columns for DataTable
        //Method 1
        dt.Columns.Add("column0", System.Type.GetType("System.String"))；
        //Method 2
        DataColumn dc = new DataColumn("column1", System.Type.GetType("System.Boolean"))；
        dt.Columns.Add(dc)； 

       （3）Add rows for DataTable
         //Initialize the row
         DataRow dr = dt.NewRow()；
         dr["column0"] = "AX"；
         dr["column1"] = true；
         dt.Rows.Add(dr)；
         //Doesn't initialize the row
         DataRow dr1 = dt.NewRow()；
         dt.Rows.Add(dr1)；  


        （4）Ｓelect row
         //Search the second row 如果没有赋值,则用is null来Ｓelect
         DataRow[] drs = dt.Ｓelect("column1 is null")；
         DataRow[] drss = dt.Ｓelect("column0 = 'AX'")； 


        （5）Copy DataTable include data
         DataTable dtNew = dt.Copy()； 

        （6）Copy DataTable only scheme
         DataTable dtOnlyScheme = dt.Clone()； 

        （7）Operate one row
         //对dt的操作
         //Method 1
         DataRow drOperate = dt.Rows[0]；
         drOperate["column0"] = "AXzhz"；
         drOperate["column1"] = false；
         //Method 2
         drOperate[0] = "AXzhz"；
         drOperate[1] = false；
         //Method 3
         dt.Rows[0]["column0"] = "AXzhz"；
         dt.Rows[0]["column1"] = false；
         //Method 4
         dt.Rows[0][0] = "AXzhz"；
         dt.Rows[0][1] = false； 

       （8）Evaluate another DataTable's row to current Datatable
         dtOnlyScheme.Rows.Add(dt.Rows[0].ItemArray)； 

       （9）Convert to string
         System.IO.StringWriter sw = new System.IO.StringWriter()；
         System.Xml.XmlTextWriter xw = new System.Xml.XmlTextWriter(sw)；
         dt.WriteXml(xw)；
         string s = sw.ToString()；

        （10）Filter DataTable
         dt.DefaultView.RowFilter = "column1 <> true"；
         dt.DefaultView.RowFilter = "column1 = true"；

        （11）Sort row
          dt.DefaultView.Sort = "ID ,Name ASC"；
          dt=dt.DefaultView.ToTable()；

         （12）Bind DataTable
           //绑定的其实是DefaultView
          gvTestDataTable.DataSource = dt；
          gvTestDataTable.DataBind()；

         （13）judge the DataTable’s Column name is a string
          //判断一个字符串是否为DataTable的列名
         dtInfo.Columns.Contains("AX")；

         （14）DataTable convert to XML and XML convert to DataTable
          protected void Page_Load(object sender, EventArgs e)
          {
             DataTable dt_AX = new DataTable()； 
             //dt_AX.Columns.Add("Sex", typeof(System.Boolean))；
             //DataRow dr = dt_AX.NewRow()；
             //dr["Sex"] = true；
             //dt_AX.Rows.Add(dr)； 
             string xml=ConvertBetweenDataTableAndXML_AX(dt_AX)；
             DataTable dt = ConvertBetweenDataTableAndXML_AX(xml)；
         } 
         public string ConvertBetweenDataTableAndXML_AX(DataTable dtNeedCoveret)
        {
             System.IO.TextWriter tw = new System.IO.StringWriter()；
             //if TableName is empty, WriteXml() will throw Exception.                  

dtNeedCoveret.TableName=dtNeedCoveret.TableName.Length==0?"Table_AX":dtNeedCoveret.TableName；
             dtNeedCoveret.WriteXml(tw)；
             dtNeedCoveret.WriteXmlSchema(tw)；
             return tw.ToString()；
        } 
         public DataTable ConvertBetweenDataTableAndXML_AX(string xml)
        {
             System.IO.TextReader trDataTable = new System.IO.StringReader(xml.Substring(0, xml.IndexOf("<?xml")))；
             System.IO.TextReader trSchema = new System.IO.StringReader(xml.Substring(xml.IndexOf("<?xml")))；
             DataTable dtReturn = new DataTable()；
             dtReturn.ReadXmlSchema(trSchema)；
             dtReturn.ReadXml(trDataTable)；
             return dtReturn；
        }

]]> http://h31home.com/h312005/blogview.asp?ID=995 <![CDATA[SqlServer存储过程之简单入门 ]]> admin http://h31home.com/h312005/blogview.asp?ID=994 2008-9-25 9:30:30 2008-9-25 9:30:30
1.首先来一个最简单的存储过程吧
CREATE PROCEDURE dbo.testProcedure_AX
AS
Ｓelect userID from USERS order by userid desc
注:dbo.testProcedure_AX是你创建的存储过程名,可以改为:AXzhz等,别跟关键字冲突就行了,AS下面就是一条SQL语句.


2.如何在ASP.NET中调用这个存储过程?
        public static string GetCustomerCName(ref ArrayList arrayCName,ref ArrayList arrayID)
        {
            SqlConnection con=ADConnection.createConnection()；
            SqlCommand cmd=new SqlCommand("testProcedure_AX",con)；
            cmd.CommandType=CommandType.StoredProcedure；
            con.Open()；
            try
            {
                SqlDataReader dr=cmd.ExecuteReader()；
                while(dr.Read())
                {
                    if(dr[0].ToString()=="")
                    {
                        arrayCName.Add(dr[1].ToString())；
                    }
                }
                con.Close()； 
                return "OK!"；
            }
            catch(Exception ex)
            {
                con.Close()；
                return ex.ToString()；
            }
        }
注:其实就是把以前
SqlCommand cmd=new SqlCommand("Ｓelect userID from USERS order by userid desc",con)；
中的SQL语句替换为存储过程名,再把cmd的类型标注为CommandType.StoredProcedure(存储过程)


3.再来个带参数的存储过程吧.
CREATE PROCEDURE dbo.AXzhz
/*
这里写注释
*/
@startDate varchar(16),
@endDate varchar(16) 
AS
 Ｓelect id  from table_AX where commentDateTime>@startDate and commentDateTime<@endDate order by contentownerid DESC

注:@startDate varchar(16)是声明@startDate 这个变量,多个变量名间用【,】隔开.后面的SQL就可以使用这个变量了.


4.如何在ASP.NET中调用这个带参数的存储过程?
 public static string GetCustomerCNameCount(string startDate,string endDate,ref DataSet ds)
{
            SqlConnection con=ADConnection.createConnection()；
//-----------------------注意这一段--------------------------------------------------------------------------
            SqlDataAdapter da=new SqlDataAdapter("AXzhz",con)；

            para0=new SqlParameter("@startDate",startDate)；
            para1=new SqlParameter("@endDate",endDate)；
            da.ＳelectCommand.Parameters.Add(para0)；
            da.ＳelectCommand.Parameters.Add(para1)；
            da.ＳelectCommand.CommandType=CommandType.StoredProcedure；
//-----------------------------------------------------------------------------------------------------------
            try
            {
                con.Open()；
                da.Fill(ds)；
                con.Close()；
                return "OK"；
            }
            catch(Exception ex)
            {
                return ex.ToString()；
            }            
        }

注:把命令的参数添加进去,就OK了.

5.如何查看SQL命令执行成功了没有.
CREATE PROCEDURE dbo.AXzhz
/*
  @parameter1 用户名
  @parameter2 新密码
*/
@password nvarchar(20),
@userName nvarchar(20)
AS
declare @err0 int
update WL_user set password=@password where UserName=@userName
set @err0=@@error 
Ｓelect  @err0 as err0

注:先声明一个整型变量@err0,再给其赋值为@@error(这个是系统自动给出的语句是否执行成功,0为成功,其它为失败),最后通过Ｓelect把它选择出来.


6.如何从后台获得这个执行成功与否的值?
下面这段代码可以告诉你答案:
    public static string GetCustomerCName()
        {
            SqlConnection con=ADConnection.createConnection()；            
            SqlCommand cmd=new SqlCommand("AXzhz",con)；
            cmd.CommandType=CommandType.StoredProcedure；
            para0=new SqlParameter("@startDate","2006-9-10")；
            para1=new SqlParameter("@endDate","2006-9-20")；
            da.ＳelectCommand.Parameters.Add(para0)；
            da.ＳelectCommand.Parameters.Add(para1)； 
            con.Open()；
            try
            {
               Int32 re=(int32)cmd.ExecuteScalar()； 
                con.Close()； 
                if (re==0)
                 return "OK!"；
                else
                 return "false"；
            }
            catch(Exception ex)
            {
                con.Close()；
                return ex.ToString()；
            }
        }

7.如何根据传入的参数判断执行哪条SQL语句?
ALTER PROCEDURE dbo.ＳelectCustomerCNameCount
@customerID int
AS
if @customerID=-1
 begin
 Ｓelect contentownerid ,userCName,count(*) as countAll from view_usercomment group by contentownerid,userCName order by contentownerid DESC
 end
else
 begin
 Ｓelect contentownerid ,userCName,count(*) as countAll from view_usercomment where contentownerid=@customerID group by contentownerid,userCName order by contentownerid DESC
 end

二、C＃中使用带返回值的存储过程

例如在向数据库添加新数据时，需要检测是否有重复
本例介绍如何把这个检测的过程放在存储过程中，并用程序调用检测的结果做出反应。
存储过程如下：
CREATE PROCEDURE DInstitute_Insert
@InstituteNO nvarchar(6),@InstituteName nvarchar(40)
 AS
declare @return int,@count int
if(ltrim(rtrim(@InstituteName))='' or ltrim(rtrim(@InstituteNO))='')
 Ｓelect @return=3--返回3表示提交的数据有空值
else
begin
 Ｓelect @count=count(1) from DInstitute where InstituteNO=@InstituteNO
 if(@count>0)
  Ｓelect @return=1--返回1表示编号有重复
 else
 begin 
  insert into DInstitute (InstituteNO,InstituteName) values  (@InstituteNO,@InstituteName) 
  if(@@error>0)
   Ｓelect @return=2--返回2表示数据操作错误
  else
   Ｓelect @return=0--返回0表示数据操作成功
 end
end
return @return
GO 

其中DInstitute 是一个学院信息表。只有InstituteNO（学院编号）、InstituteName（学院名称）两个字段。

在C＃中调用本存储过程的代码如下：
//执行插入操作
            SqlCommand com1 = new SqlCommand("DInstitute_Insert", DBcon)；
            if (com1.Connection.State == ConnectionState.Closed)
                com1.Connection.Open()；
            com1.CommandType = CommandType.StoredProcedure；
            com1.Parameters.Add(new SqlParameter("@InstituteNO",SqlDbType.NVarChar,6))；
            com1.Parameters.Add(new SqlParameter("@InstituteName", SqlDbType.NVarChar, 40))；
            com1.Parameters.Add(new SqlParameter("@return", SqlDbType.Int))；
            com1.Parameters["@return"].Direction = ParameterDirection.Returnvalue；
            com1.Parameters["@InstituteNO"].value = t_NO.Text；
            com1.Parameters["@InstituteName"].value = t_name.Text；
            try
            {
                com1.ExecuteScalar()；
            }
            catch(SqlException ee)
            {
                DB.msgbox("操作失败！"+ee.Message.ToString())；
                return；
            }
            finally
            {
                com1.Connection.Close()；
            }
            string temp = com1.Parameters["@return"].value.ToString()；
            //返回0表示数据操作成功
            //返回1表示编号有重复   
            //返回2表示数据操作错误 
            //返回3表示提交的数据有空值
            switch (temp)
            {
                case "0":
                    DB.msgbox("添加成功！")；
                    break；
                case "1":
                    DB.msgbox("编号有重复！")；
                    break；
                case "2":
                    DB.msgbox("数据操作错误！")；
                    break；
                case "3":
                    DB.msgbox("提交的数据有空值！")；
                    break；
            }
            Binding()； //刷新datagrid 

三、SqlServer存储过程的事务处理

方法一：
--测试的表   
  create   table   tb(  id   int     not   null     constraint   PK_sys_zj_fielddict   primary   key   ,aa   int)   
  --事务处理   
  begin   tran   
  insert   into   tb   values(1,1)   
  if   @@error<>0   goto   lb_rollback   
  insert   into   tb   values(1,1)   
  if   @@error<>0   goto   lb_rollback   
  insert   into   tb   values(2,1)   
  if   @@error<>0   goto   lb_rollback   
  insert   into   tb   values(2,1)   
  if   @@error<>0   goto   lb_rollback   
  insert   into   tb   values(3,1)   
  if   @@error<>0   goto   lb_rollback   
  lb_commit:   
  commit   tran   
  goto   lb_ok   
  lb_rollback:   
  rollback   tran       
  --显示结果   
  lb_ok:   
  Ｓelect   *   from   tb   
  drop   table   tb


方法二：
--创建测试表   
  create   table   tb(id   int     not   null     constraint   PK_sys_zj_fielddict   primary   key  ,aa   int)       
  --设置选项   
  SET   XACT_ABORT   on       
  --事务处理   
  begin   tran   
  insert   into   tb   values(1,1)   
  insert   into   tb   values(1,1)   
  insert   into   tb   values(2,1)   
  commit   tran       
  --显示结果   
  /*--------注意   
          如果这样写的话,后面的语句不会被执行,如果要执行后面的语句,要在这句后面加上GO,仅查询分析分析器支持,所以如果是在存储过程中,要保证commit   tran后面没有其他语句,否则出错时,其他语句不会被执行   
  -----------*/   
  Ｓelect   *   from   tb   
  drop   table   tb   

四、.Net中使用事务处理


SqlConnection myConnection = new SqlConnection("Data Source=localhost；Initial Catalog=Northwind；Integrated Security=SSPI；")； 
myConnection.Open()； 

SqlTransaction myTrans = myConnection.BeginTransaction()； //使用New新生成一个事务 
SqlCommand myCommand = new SqlCommand()； 
myCommand.Transaction = myTrans； 

try 
{ 
myCommand.CommandText = "Update Address set location='23 rain street' where userid='0001'"； 
myCommand.ExecuteNonQuery()； 

myCommand.CommandText = "Update table2 set dd='23 rain street' where userid='0001'"； 
myCommand.ExecuteNonQuery()； 

myTrans.Commit()； 
Console.WriteLine("Record is udated.")； 
} 
catch(Exception e) 
{ 
myTrans.Rollback()； 
Console.WriteLine(e.ToString())； 
Console.WriteLine("Sorry, Record can not be updated.")； 
} 
finally 
{ 
myConnection.Close()； 
}

说明：在SqlServer中，每条Sql语句都作为一个事务来执行，所以无论在存储过程，还是在.net代码中使用，执行单条Sql语句没有必要使用事务处理。

信息来源：http://www.cnblogs.com/tuyile006/

]]> http://h31home.com/h312005/blogview.asp?ID=994 <![CDATA[C#中取得程序當前工作目錄和執行目錄的一些方法 ]]> admin http://h31home.com/h312005/blogview.asp?ID=993 2008-9-20 8:44:26 2008-9-20 8:44:26
1.   System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName
     获取模块的完整路径。
2.   System.Environment.CurrentDirectory
     获取和设置当前目录(该进程从中启动的目录)的完全限定目录。
3.   System.IO.Directory.GetCurrentDirectory() 
     获取应用程序的当前工作目录。这个不一定是程序从中启动的目录啊，有可能程序放在C:\www里,这个函数有可能返回C:\Documents and Settings\ZYB\,或者C:\Program Files\Adobe\,有时不一定返回什么东东，我也搞不懂了。
4.  System.AppDomain.CurrentDomain.BaseDirectory
     获取程序的基目录。
5.  System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase
     获取和设置包括该应用程序的目录的名称。
6.  System.Windows.Forms.Application.StartupPath 
     获取启动了应用程序的可执行文件的路径。效果和2、5一样。只是5返回的字符串后面多了一个"\"而已
7.  System.Windows.Forms.Application.ExecutablePath
     获取启动了应用程序的可执行文件的路径及文件名，效果和1一样。

8.进程对象在.NET中表现为System.Diagnostics.Process类，通过调用Process.GetCurrentProcess().MainModule.FileName可获得当前执行的exe的文件名。


//正在运行的程序路径和文件名 
string _file = Application.ExecutablePath；
//正在运行的程序路径 
string _path = Application.StartupPath；
//正在运行的程序名称 
string _name = _file.Replace(string.Format("{0}\\", _path), string.Empty)； 
]]> http://h31home.com/h312005/blogview.asp?ID=993 <![CDATA[如何將程序的Access数据库嵌入到资源中发布 ]]> admin http://h31home.com/h312005/blogview.asp?ID=992 2008-9-20 8:42:19 2008-9-20 8:42:19  2        private string ResourcesPath = Application.StartupPath.ToString() + "\\" + "Resources.dll"；
 3
 4       調用 WriteEmbeddedFile("SAP_Words.dll", AccessPath)；
 5        private Stream GetStream(string name)
 6        {
 7            return GetResourceAssembly().GetManifestResourceStream("資源類的命名空間."+name)；
 8        }
 9
10        private Assembly GetResourceAssembly()
11        {
12            return Assembly.LoadFrom(ResourcesPath)；
13        }
14
15        private void WriteEmbeddedFile(string name, string fileName)
16        {
17            using (Stream stream = GetStream(name))
18            {
19                FileInfo file = new FileInfo(fileName)；
20                using (FileStream fileStream = file.Create())
21                {
22                    byte[] buf = new byte[1024]；
23                    int size；
24                    while ((size = stream.Read(buf, 0, 1024)) > 0)
25                    {
26                        fileStream.Write(buf, 0, size)；
27                    }
28                }
29            }
30        }
]]> http://h31home.com/h312005/blogview.asp?ID=992 <![CDATA[用反射方法使用户控件动态调用父页面的方法 ]]> admin http://h31home.com/h312005/blogview.asp?ID=991 2008-9-20 8:41:32 2008-9-20 8:41:32 父页面类型用反射的方法获取，这避免了不同页面调用同样时，需要类型转换的问题（不用写很多case了:)）。

当然还有一种方法是父页面去实现一个接口，即去实现SetLabel方法，uc把this.Page转成这个接口就可以了。


用户控件:

using System.Reflection；
private void Button1_Click(object sender, System.EventArgs e)
        {
            //用反射方法动态调用父页面的方法
            System.Web.UI.Page p = this.Page；
            Type pageType = p.GetType()；
            MethodInfo mi = pageType.GetMethod("SetLabel")；
            mi.Invoke(p,new object[]{"你这个大猪猪!"})；
            
        } 

父页面： 

public void SetLabel(string str)
        {
            this.Label1.Text = str；
        } 
]]> http://h31home.com/h312005/blogview.asp?ID=991 <![CDATA[用C#代码生成一个简单的PDF文件 ]]> admin http://h31home.com/h312005/blogview.asp?ID=990 2008-9-20 8:33:00 2008-9-20 8:33:00 using System.IO；
using System.Text；
using System.Collections；

namespace PDFGenerator
{
     /// <summary>
     /// Application : Generation of PDF file from text
     /// Author         : Pramod Kumar Singh 
     /// Date         : 25th July 2001
     ///</summary>
        
     public class PDFGenerator
     {
         static float pageWidth = 594.0f；
         static float pageDepth = 828.0f；
         static float pageMargin = 30.0f；
         static float fontSize = 10.0f；
         static float leadSize = 10.0f；
        
         //Create a PDF file.
         //PDF on Disk
         static StreamWriter pPDF=new StreamWriter("F:\\Temp\\myPDF.pdf")；
         //PDF in Memory
         static MemoryStream mPDF= new MemoryStream()；
        
         //Convert the Text Data to PDF format and write back to
         //Memory Stream
         static void ConvertToByteAndAddtoStream(string strMsg)
         {
             Byte[] buffer=null；
             buffer=ASCIIEncoding.ASCII.GetBytes(strMsg)；
             mPDF.Write(buffer,0,buffer.Length)；  
             buffer=null；
         }
        
         //Format the data length in xRef Format
         static string xRefFormatting(long xvalue)
         {
             string strMsg =xvalue.ToString()；
             int iLen=strMsg.Length；
             if (iLen<10)
             {
                 StringBuilder s=new StringBuilder()；
                 //string s=null；
                 int i=10-iLen；
                 s.Append('0',i)；
                 strMsg=s.ToString() + strMsg；
             }
             return strMsg；
         }

         //Entry Point
         static void Main(string[] args)
         {
             //Create a ArrayList for xRefs of PDF Document
             ArrayList xRefs=new ArrayList()；
             Byte[] buffer=null；
             float yPos =0f；
             long streamStart=0；
             long streamEnd=0；
             long streamLen =0；
             string strPDFMessage=null；
             //PDF Header Message
             strPDFMessage="%PDF-1.1\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
            
             //ID 1 For Containt
             //ID 2 For Length of the Stream
             //write the Text
            
             //1> Start a new Page
             xRefs.Add(mPDF.Length)；
             strPDFMessage="1 0 obj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage="<< /Length 2 0 R >>\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage="stream\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
            
             //Get the start of the stream
             streamStart=mPDF.Length；
             strPDFMessage="BT\n/F0 " + fontSize +" Tf\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             yPos = pageDepth - pageMargin；
             strPDFMessage=pageMargin + " " + yPos +" Td\n" ；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage= leadSize+" TL\n" ；
             ConvertToByteAndAddtoStream(strPDFMessage)；
            
             //Add the text data to the PDF memory stream
             strPDFMessage= "(Pramod Kumar Singh)Tj\n" ；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage= "ET\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             //Get the End of the stream
             streamEnd=mPDF.Length；
             //Get the Length of the stream
             streamLen=streamEnd-streamStart；
             strPDFMessage= "endstream\nendobj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
                    
             //Add 2 object to xRef
             xRefs.Add(mPDF.Length)；
             strPDFMessage="2 0 obj\n"+ streamLen + "\nendobj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
                        
             //Add Page to xRefs
             xRefs.Add(mPDF.Length)；
             strPDFMessage="3 0 obj\n<</Type/Page/Parent 4 0 R/Contents 1 0 R>>\nendobj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
            
             //Build the Pages
             xRefs.Add(mPDF.Length)；
             strPDFMessage="4 0 obj\n<</Type /Pages /Count 1\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage="/Kids[\n3 0 R\n]\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage="/Resources<</ProcSet[/PDF/Text]/Font<</F0 5 0 R>> >>\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             strPDFMessage="/MediaBox [ 0 0 "+ pageWidth + " " + pageDepth + " ]\n>>\nendobj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
            
             //Add font to xRefs
             xRefs.Add(mPDF.Length)；
             strPDFMessage="5 0 obj\n<</Type/Font/Subtype/Type1/BaseFont/Courier/Encoding/WinAnsiEncoding>>\nendobj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
                    
             //Add the catalog to xRefs
             xRefs.Add(mPDF.Length)；
             strPDFMessage="6 0 obj\n<</Type/Catalog/Pages 4 0 R>>\nendobj\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
                        
             //xRefs Entry 
             streamStart=mPDF.Length；
             strPDFMessage="xref\n0 7\n0000000000 65535 f \n"；
             for(int i=0；i<xRefs.Count；i++)
             {
                 strPDFMessage+=xRefFormatting((long) xRefs[i])+" 00000 n \n"；
             }
             ConvertToByteAndAddtoStream(strPDFMessage)；
             //Trailer for the PDF
             strPDFMessage="trailer\n<<\n/Size "+ (xRefs.Count+1)+"\n/Root 6 0 R\n>>\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             //xRef location entry
             strPDFMessage="startxref\n" + streamStart+"\n%%EOF\n"；
             ConvertToByteAndAddtoStream(strPDFMessage)；
             //Write the PDF from Memory Stream to File Stream
             mPDF.WriteTo(pPDF.BaseStream)；
             //Close the Stream
             mPDF.Close()；
             pPDF.Close()；
         }
     }
} ]]> http://h31home.com/h312005/blogview.asp?ID=990 <![CDATA[SQL 中 Ｓelect 语句的执行顺序 ]]> admin http://h31home.com/h312005/blogview.asp?ID=989 2008-9-20 8:31:02 2008-9-20 8:31:02    因此, 建议大家在平时工作中 SQL 语句按标准顺序写, 一是专业, 二是实用, 呵呵, 不过我觉得最主要的是心里感觉舒服.
   标准的 SQL 的解析顺序为:
   (1).FROM 子句, 组装来自不同数据源的数据
   (2).WHERE 子句, 基于指定的条件对记录进行筛选
   (3).GROUP BY 子句, 将数据划分为多个分组
   (4).使用聚合函数进行计算
   (5).使用 HAVING 子句筛选分组
   (6).计算所有的表达式
   (7).使用 ORDER BY 对结果集进行排序

   举例说明: 在学生成绩表中 (暂记为 tb_Grade), 把 "考生姓名"内容不为空的记录按照 "考生姓名" 分组, 并且筛选分组结果, 选出 "总成绩" 大于 600 分的.
   标准顺序的 SQL 语句为: 
   Ｓelect 考生姓名, max(总成绩) as max总成绩
   from tb_Grade
   where 考生姓名 is not null
   group by 考生姓名
   having max(总成绩) > 600
   order by max总成绩
   
   在上面的示例中 SQL 语句的执行顺序如下:
   (1). 首先执行 FROM 子句, 从 tb_Grade 表组装数据源的数据
   (2). 执行 WHERE 子句, 筛选 tb_Grade 表中所有数据不为 NULL 的数据
   (3). 执行 GROUP BY 子句, 把 tb_Grade 表按 "学生姓名" 列进行分组
   (4). 计算 max() 聚集函数, 按 "总成绩" 求出总成绩中最大的一些数值
   (5). 执行 HAVING 子句, 筛选课程的总成绩大于 600 分的.
   (7). 执行 ORDER BY 子句, 把最后的结果按 "Max 成绩" 进行排序.
]]> http://h31home.com/h312005/blogview.asp?ID=989 <![CDATA[挂上这家伙，猛车狂飙70码无人敢挡]]> uygnaf http://h31home.com/rss/ 2010-3-11 10:43:39 2010-3-11 10:43:39


在自家车屁股上挂上这家伙，狂飙70码无人敢挡，上班不再迟到

原始链接:http://xiabuy.com/2010/03/ballon-car.html
diglog链接:http://www.diglog.com/story/entertainment_other_332364.html ]]> http://h31home.com/rss/blogto.asp?ID=47330 <![CDATA[10个愚蠢的小配件]]> yleo http://h31home.com/rss/ 2010-3-11 9:46:31 2010-3-11 9:46:31


10个愚蠢的小配件(厕所高尔夫—— 拉shi的时候也可以运动哦)

原始链接:http://hi.baidu.com/yleo550/blog/item/4e3af2ff9eb28f1d08244da7.html
diglog链接:http://www.diglog.com/story/technology_gadgets_332352.html ]]> http://h31home.com/rss/blogto.asp?ID=47331 <![CDATA[CLR 与 C++的常用类型转换笔记]]> Davy.xu http://h31home.com/rss/ 2010-3-11 9:37:00 2010-3-11 9:37:00

1. System::String 转换到 const wchar_t*

 
   1:  const wchar_t* ToUnmanagedUnicode( System::String^ str )
   2:  {
   3:      pin_ptr<const WCHAR> nativeString1  = PtrToStringChars( str );
   4:      return (const wchar_t*)nativeString1;
   5:  }

 

2.  const wchar_t* / const char* 转换到 System::String

   1:  const wchar_t* p= L"hello";
   2:   
   3:  System::String( p ).ToString();

 

3.  C++数值类型转CLR数值类型

   1:  int a;
   2:   
   3:  System::Int32 b = System::Int32( a );

 

4. HWND 转为IWin32Window

   1:  public ref class WindowWrapper : System::Windows::Forms::IWin32Window
   2:  {
   3:      public: WindowWrapper(IntPtr handle)
   4:      {
   5:          _hwnd = handle;
   6:      }
   7:   
   8:  public:
   9:      property IntPtr Handle
  10:      {
  11:          virtual IntPtr get(void){return _hwnd;};
  12:      };
  13:   
  14:      private: IntPtr _hwnd;
  15:  };
  16:   
  17:  HWND nativehwnd;
  18:  IWin32Window^ w = gcnew Managed::WindowWrapper( System::IntPtr( nativehwnd ) );


Davy.xu 2010-03-11 09:37 发表评论
]]> http://h31home.com/rss/blogto.asp?ID=47319 <![CDATA[控制台输出螺旋型数字]]> elite_lcf http://h31home.com/rss/ 2010-3-11 1:48:00 2010-3-11 1:48:00 阅读: 43 评论: 1 作者: elite_lcf 发表于 2010-03-11 01:48 原文链接

先上最终效果图

 

 

对输入的指定数组规模做一个螺旋型的数字输出：

假设输入3，输出如下：

1  2  3

8  9  4

7  6  5

 

 

按照这种顺序进行。

 

实现代码如下：

 1 #include <iostream>
 2 #include<iomanip>
 3 using namespace std;
 4 
 5 void inputGrid(int n,int *m)
 6 {//n表示规模，m为二维数组指针
 7     int row=0,line=0,flag=0;//row,line表示第几次行处理或列处理；
 8     int i=0,j=-1;
 9     for(int num=1;num<=n*n;)
10     {
11         if(!flag)
12         {
13             //行处理
14             int addnum;
15             if(row%2==0)addnum=1;//往前走
16             else addnum=-1;//往回走
17             int num_row=n-row;
18             while(num_row)
19             {//将本行剩余空白列全部填满
20                 num_row--;
21                 j+=addnum;
22                 *(m+n*i+j)=num;
23                 num++;
24             }
25             row++;
26             flag=1;
27 
28         }
29         else
30         {
31             //列处理
32             int addnum;
33             if(line%2==0)addnum=1;//往前走
34             else addnum=-1;//往回走
35             int num_line=n-line-1;
36             while(num_line)
37             {//将本列剩余空白项全部填满
38                 num_line--;
39                 i+=addnum;
40                 *(m+n*i+j)=num;
41                 num++;
42             }
43             line++;
44             flag=0;
45         }
46     }
47     /*for(int i=0;i<n*n;i++)
48     {
49         *(m+i)=i;
50     }*/
51 }
52 
53 int main()
54 {
55     int n=1;
56     int *m,*tm;
57     while(n!=-1)
58     {
59     cout<<"请输入回形数规模:(输入-1退出)";
60     cin>>n;
61     if(n==-1)
62         return 0;
63     m=(int *)malloc(n*n*sizeof(int));
64     inputGrid(n,m);
65     for(int i=0;i<n;i++)
66     {
67         tm=m+n*i;
68         for(int j=0;j<n;j++)
69         {
70             cout<<setw(3)<<*(tm+j)<<" ";
71         }
72         cout<<"\n";
73     }
74     }
75     //return 0;
76 }

 

 

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

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47312 <![CDATA[程序员你12点前睡觉了吗？]]> 吉日嘎拉&gt;不仅权限设计 http://h31home.com/rss/ 2010-3-10 22:46:00 2010-3-10 22:46:00 阅读: 637 评论: 16 作者: 吉日嘎拉&gt;不仅权限设计 发表于 2010-03-10 22:46 原文链接

    最近发现很多同事，在上班时有些打瞌睡，中午也在眯一会儿，当然我不是周扒皮，但是总的感觉来说，想提醒他们一下，平时还是需要注意一些的，虽然大家没有表面上说你什么，但是大家都看在眼里，谁在好好工作，谁在打瞌睡，其实每个人心里都有一杆秤的，只是我们都比较含蓄，有些话只能放在心里永远都不能说出来而已。

   我也是从20来岁一直走过来的，那时候晚上也睡不着，精力旺盛，经常弄到凌晨2-3点，我也很能理解大家，但是当时没多少人能提醒我，很中肯的把其中的利弊给我讲好，现在我想从我的心得体验给大家随便说几句。

   1：晚上熬呀，很容易早上迟到，早上起不来，那真的是更大的痛苦，早上又赶车、挤车，很容易出事情或被小偷啥的光顾，因为你精神不集中。

   2：不管是你的领导，同事，都看着你平时工作精力不集中、对你的评价、对你认识会比较糟糕，以后有好事情一般不会轮到你，影响你的前程。

   3：由于晚上没休息好，工作效率会很低，思路也会混乱，迷迷糊糊、稀里糊涂一天就过去，很容易代码没写好，测试没测好，该做的事情没仔细做好，从此个人、公司有了噩梦的开始。

   4：一个作息不规律、邋遢、稀里糊涂、抓不住主次的同事，我就是有妹妹也不会介绍给他。

   5：你的不按时休息、很可能会影响家人的休息，你的女朋友、你的父母、你的家人的休息还是多多少少被影响的。

   6：晚上加班了，没几个人能看到你加班了，但是早上迟到了，所有的同事都看到你迟到了。

   7：年轻时身体像铁一样，等过了30岁，通宵一晚上要痛苦3-4天才能缓过劲来，若年轻时不珍惜好，过了30多岁，啥病都找上门来了，赚的可能没给的药费多。

    【换个牙齿，比较实在的社区卫生所，1000元左右一个，当然你可以选择一个铁的，更便宜一些】

 

   一天天都过得很快，不要指望一天能干出天的事情，但是也不要不在乎人生过去的每一天，人生每天都是现场直播，需要你直播好每一天，一晃眼10多年过去了，最牛的人，都是最有目的最有计划的，做事情也很有条理，哪些事情是必须做的，哪些事情是可以靠别人做的，哪些是重点，哪些是关键，那些事情自己做不了？

   你每天的表现，就是你的未来的必然，生活好每天，别稀里糊涂、连个按时睡觉、按时起床也做不到，就不太好了。

 

   上班打瞌睡，会影响你的前程。。。。。。。。。。。。。。。。。。。。。。。。。虽然别人没直接说你。。。。。。今天我告诉你

 

    今天没做好的事情，好好休息，明天精神饱满的继续干，若一天计划的事情没做好，干到深夜、凌晨才做好，那是计划不好，规划不好，水平不好。

 

评论: 16　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47313 <![CDATA[D3D学习总结基础篇（二）--从古墓丽影的画面设置了解基础概念]]> 靁电 http://h31home.com/rss/ 2010-3-10 22:22:00 2010-3-10 22:22:00 阅读: 199 评论: 0 作者: 靁电 发表于 2010-03-10 22:22 原文链接

上一篇文章比较理论，讲的都是数学，这一篇呢。。。讲的还是基础理论-。-

虽然编程上，实践非常重要，但由于D3D编程有太多的理论知识沉淀，所以，在弄清楚这些概念之后，再开始coding也不迟。

相信很多玩家和我一样，当年曾因为电脑配置差而不能流畅运行一些大型3D游戏，不得已在画面设置上做出许多让步，通过不断的实验得到画面和流畅度的平衡点。这篇文章就从画面设置菜单开始，来介绍3D图形学中的基础概念。顺便再说下，本文中的理论大部分来自Introduction to 3D Game Programming with DirectX 10一书，越来越觉得自己像技术翻译了。。。

=========================================分割线==

首先看上面这张图，是古墓丽影的display setting（google上随便找的，不知道是哪个版本的古墓，反正不是地下世界就是传奇）。这里列出了几个典型的设置项，我们就从这些item中挑几个来分析吧：

 

1. Anti Aliasing 全屏抗锯齿：

这是非常常见的技术，在Direct X中，抗锯齿技术叫做multisampling，下面来具体讲下这个技术。

由于一个像素点在屏幕上并非是无限小的，因此，任意线条都不可能完美现实在屏幕上。举个简单的例子：

上图中，上面的那条线呈明显的阶梯状，也就是我们所说的"锯齿"，下图，通过对每个点和周围点进行取样，生成一些相似颜色的点，来实现抗锯齿的效果（不确认我这样说是否准确），这就是D3D用到的multisampling（多抽样）技术。当然，提高分辨率可以将锯齿现象减少，通常也会带来较大的性能损失，不过抗锯齿技术也是相当吃性能的。。。

在D3D中，通过改变下面这个结构的值来设抗锯齿效果：

 

typedef struct DXGI_SAMPLE_DESC { 

UINT Count;//对每一个像素生成几个取样 

UINT Quality; 

} DXGI_SAMPLE_DESC, *LPDXGI_SAMPLE_DESC;

 

 

如果要开发成熟的3D应用，要考虑到不同级别硬件的要求，可以通过以下代码来check硬件设备是否支持某个级别的抗锯齿： 

HRESULT ID3D10Device::CheckMultisampleQualityLevels(
  DXGI_FORMAT Format, UINT SampleCount, UINT *pNumQualityLevels);

 

 

如果硬件不支持，该函数返回0。（DXGI_FORMAT会在后面提到，如果没忘记的话。。。）

2. Texture 纹理

纹理质量对3D游戏的显示效果有着至关重要的作用，这里就具体讲一下D3D中的Textures。

我们通常认为，纹理就是一张2D图片，微观的说，就是一个矩阵，每个矩阵元素对应一个像素点的颜色，事实上，早期的游戏确实就是这么实现的。不过，到了3D时代，事情变的复杂了很多，纹理的用途很多，在矩阵中的每一个元素不仅对应着一个像素点的颜色，可还可能对应一个数字，一个向量，或者一个数组。有点抽象，具体的说，比如，有种技术叫"mipmap"（这里就不详细解释了，可以去google下），实现这种技术的某种方法就是在纹理中存放mipmap level。当然，同一个纹理文件不可能包含任意信息，同一种纹理类型里存放的数据是固定的。D3D中，通过枚举类型DXGI_FORMAT来设定纹理的类型，下随便举几种纹理类型：

DXGI_FORMAT_R32G32B32_FLOAT: 每个元素包含三个32位浮点数。

DXGI_FORMAT_R16G16B16A16_UNORM: 每个元素包含4个16位组件对应[0,1]，一般用来做阴影。

这里就不再往细的写了，因为这块具体的算法很多我也不理解，有兴趣的朋友参看http://msdn.microsoft.com/en-us/library/ee418116(VS.85).aspx。

对于类型中的R, G, B, A分别对应red, green, blue, and alpha，前三个是三原色，最后一个代表着透明度，术语叫做阿尔法通道，用过3DMax或者Maya等建模工具的人应该不会陌生。另外需要说明的是，纹理并不一定要存放颜色的信息，比如DXGI_FORMAT_R32G32B32_FLOAT，可以存放一个三维的向量。

 

3. Triple Buffering 三倍缓冲

我们经常看到游戏设置里会有双倍缓冲(double buffering)，三倍缓冲（triple buffering）之类的选项。具体是什么意思呢，无论硬件有多快，渲染一个画面都是需要花费一定时间的，一般来说，渲染一个画面是从上往下垂直的顺序渲染的，这样给用户的体验就很不好，我没应该没看过游戏把渲染过程展现给用户的吧，这样画面可是会很闪。。。Swap Chain就是为了避免这种情况设计的技术，实现很简单，就是用一个缓冲区存储下一帧需要渲染的内容，这样，"画"的过程就不会让用户看见了。

具体过程看下面的图解：

Buffer A和Buffer B是两个缓冲区（double buffering），有两个指针指向他们，Front Buffer Ptr始终指向现实给用户的那一帧画面，Back Buffer Ptr则始终指向下一帧，就是要在背后渲染的那一帧，然后通过不断的调换指针指向，来实现swap chain。

如果有三个Buffer，就称为Triple buffering。

Swap chain技术被封装在接口IDXGISwapChain中，具体的后面再说。

 

4. Depth Buffering 深度缓冲

最后说下这个深度缓冲，事实上，他是一种特殊的纹理，不保存图像信息，保存的是depth信息。事实上，深度信息就是一个0到1的浮点数（0表示该像素离屏幕最近，1最远），每个像素点对应一个depth项。他是用来让3D引擎知道该把哪个像素画在前面，如下图：

四个图形重叠在了同一快位置，但并没有出现前后的错位，具体是怎么实现的呢，虽然不难，但描述有些困难，下面还是有图示先：

上图展示了一种情况，p1,p2,p3分别为三个图形上的三个点，他们重合到了一起，对应到界面上的p点，那p点到底该渲染啥呢，显然是p1嘛，但要让计算机明白这个，需要一个比较麻烦的推导过程（笔者再小小的偷下懒，借用下书上的表格）：

Operation

P

d

Description

Clear operation

Black

1.0

Pixel and corresponding depth entry initialized.

Draw cylinder

P3

d3

Since d3 ≤ d = 1.0, the depth test passes and we update the buffers by setting P = P3 and d = d3.

Draw sphere

P1

d1

Since d1 ≤ d = d3, the depth test passes and we update the buffers by setting P = P1 and d = d1.

Draw cone

P1

d1

Since d2 > d = d1, the depth test fails and we do not update the buffers.

 

推导步骤：

  1. 清空屏幕：将D 设置为1，也就是最远，然后用一种单一的颜色来填充整个屏幕。假设三个图形的渲染顺序是，圆柱，球和圆锥。
  2. 不断的判断所需要画的像素的depth值dx，如果他小于当前的D ，就让D=dx，P=当前像素；否则，不做任何处理。
  3. 一切需要渲染的元素判断完了，讲当前的P渲染。

今天就写到这里吧，其实偶很菜，写这些博文也是为了加深自己对基础的印象，欢迎大牛拍砖。

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

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47314 <![CDATA[clikclak | AnimeTaste]]> plidezus http://h31home.com/rss/ 2010-3-10 22:03:44 2010-3-10 22:03:44


很有爱的3D动画，字幕和音效尤其出色！

原始链接:http://www.animetaste.net/?p=1809
diglog链接:http://www.diglog.com/story/entertainment_other_332311.html ]]> http://h31home.com/rss/blogto.asp?ID=47332 <![CDATA[各式各样的26个字母]]> yleo http://h31home.com/rss/ 2010-3-10 21:45:37 2010-3-10 21:45:37


字母表大家都很熟悉了，这些好玩的字母表，有的来自于生活，有的是艺术，有的有点少儿不宜……

原始链接:http://hi.baidu.com/yleo550/blog/item/fbb5d0ec0298c8222cf53413.html
diglog链接:http://www.diglog.com/story/culture_art_332310.html ]]> http://h31home.com/rss/blogto.asp?ID=47333 <![CDATA[写着玩(1)——地形编辑]]> Heath http://h31home.com/rss/ 2010-3-10 21:36:00 2010-3-10 21:36:00

Heath 2010-03-10 21:36 发表评论
]]> http://h31home.com/rss/blogto.asp?ID=47320 <![CDATA[新的开始新的思考(一)]]> shaipe http://h31home.com/rss/ 2010-3-10 21:05:00 2010-3-10 21:05:00 阅读: 550 评论: 1 作者: shaipe 发表于 2010-03-10 21:05 原文链接

　　毕业已快五年的技术人,是应该好好的思考和计划一下自己的技术人生啦!

 

　　从这篇日志开始准备把自己的思考和实际中的问题都一并写出来和大家分享,希望有什么不对的地方大家多多指教!

 

　　从学校一所普通学校的非计算机专业毕业以后就走上了编程之路,开始用VB做毕业设计,项目中使用Asp做项目,还用Delphi做过Com+主要是用来做工作流的解析(也就是所谓的工作流引擎),记得那会客户的流程变化特别大,客户需要自己绘制一些简单的流程.

 

　　记得2005年冬开始看到一些关于Ajax的新闻和用法(具体时间记不太清楚了),刚毕业那会儿对技术有着很高的热情,有很多很多的东西想去学习, 总觉得时间总是不够用.我开始给公司介绍Ajax叫公司的项目中可以使用Ajax这样来提高用户体验,在公司里用公司的电脑学校Ajax和一些新的东西.当有一天领导看到我在学习这些东西的时候,给我说了一句"这些东西我们又用不到学这些干什么"从那以后我就按时下班了.

 

　　再过了几个月之后我从公司离开了,出来后几个朋友找到我说我们一起创业吧,我一个写了一套基于Ajax办证系统,一个人从规划到项目的完成到实施完只用了5个月的时间,好像这一套东西卖了一个客户五万,可到2007年春由于种种原因从一起合伙的公司中出来了,也从南京来到了上海滩.

那时候没有资本只能还是给别人打工,进入一家公司做做erp刚进公司的时候,先从一个人搞需求并慢慢招人来做OA以及ERP中的其他项目.在做OA项目的过程中,发现了很多关于开发和管理方面的问题,也一次一次的进行改进,和想了很多提高工作效率的办法,为公司提供了自己封装的Ajax框架,和数据显示和快速录入的DataGrid控件.

 

　　由于ERP中以前的项目没有引入Ajax很多用户不停的反应太慢,给老项目中引入Ajax,也不断的研究怎么才能提高页面的执行和加载速度,在页面中尽量减少使用服务端控件可以减小页面生成的代码,应用Ajax进行异步的数据提取和处理等方法.

于是花了几个月的时间把oa项目基作完成,后期公司领导要求引入工作流,又开始继续我的工作流的研究,因为项目紧,人力资源紧,时间紧工作流里要学习的东西也多,于是一个人用了一个月的时间完成了OA项目里的一个工作流引擎.

 

　　OA项目结束以后又开始了新的财务,生产等ERP中其他项目的设计规划,在这期间也学习了财务知识和关于生产方面的流程以及管理方面的知识,也不断的为项目的顺利完成提供和思考着高效的开发模式,以及系统运行的稳定和执行效率问题,在这一个一个的项目中积累了很多很多的经验.

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

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47315 <![CDATA[蜘蛛侠论坛核心框架分析1 - 如何设计与实现当前访问用户]]> netfocus http://h31home.com/rss/ 2010-3-10 20:27:00 2010-3-10 20:27:00 阅读: 504 评论: 2 作者: netfocus 发表于 2010-03-10 20:27 原文链接

论坛演示地址：http://www.entityspider.com/
源代码下载地址：http://files.cnblogs.com/netfocus/Forum.rar

 

蜘蛛侠论坛采用Forms验证方式。

 

1： 当用户输入用户名和密码并登陆, 此时, 我们会将当前用户的身份标识保存到客户端：

文件：

\Core\Managers\MemberManager.cs

代码：

CookieManager.AddCookieToResponse(
FormsAuthentication.GetAuthCookie(member.MemberId.Value.ToString(), false), expireDays);

 

 

 

2： 用户登陆后, ASP.NET下次就自动知道当前访问用户的身份标识了. 我们可以通过如下方式获取当前登陆用户的标识：

HttpContext.Current.User.Identity.Name

 

另外, 如何判断一个用户是否处于登陆状态？ 我们可以通过如下的方式来判断：

HttpContext.Current.Request.IsAuthenticated

 

如果该属性返回TRUE，则表示当前用户已登陆，否则，表示未登陆。

 

3： 在什么时候获取当前用户的所有信息？

ASP.NET提供了一个时机，让我们对用户执行身份验证。该时机就是Application对象的AuthenticateRequest事件。所以，我们可以在该事件的处理函数中确定当前访问用户是否已经登陆，

文件：

\Core\Components\Common\HttpModule.cs

代码：

private void Application_AuthenticateRequest(Object source, EventArgs e)
{
    HttpRequest request = HttpContext.Current.Request;

    if (request.Url.LocalPath.ToLower().EndsWith(".aspx")
        || request.Url.LocalPath.ToLower().EndsWith(".ashx"))
    {
        SetCurrentUser();
    }
}
private void SetCurrentUser()
{
    if (!HttpContext.Current.Request.IsAuthenticated)
    {
        HttpContext.Current.User = UserManager.GetAnonymousUser();
    }
    else
    {
        try
        {
            User user = UserManager.GetUser(new Guid(HttpContext.Current.User.Identity.Name));
            if (user != null)
            {
                HttpContext.Current.User = user;
            }
            else
            {
                MemberManager.Logout();
                HttpContext.Current.User = UserManager.GetAnonymousUser();
            }
        }
        catch
        {
            MemberManager.Logout();
            HttpContext.Current.User = UserManager.GetAnonymousUser();
        }
    }
}

 

大家可以看到，我们在AuthenticateRequest事件的处理函数中确定一个当前用户，SetCurrentUser函数实现该功能。该函数首先判断当前用户是否已经登陆，如果未登陆，则获取一个匿名用户对象，并赋值给HttpContext.Current.User；如果已经登陆，则根据用户标识从数据库获取登陆用户对象，并同样把该用户对象赋值给HttpContext.Current.User;这里有一个很关键的问题，我们为什么可以把当前获取的用户对象赋值给HttpContext.Current.User？其实很简单，我们只要让我们自己定义的User类实现IPrinciple接口即可，User类的代码如下：

public class User : Entity, IPrincipal
{
    private IIdentity identity = null;

    #region Implementation of IPrincipal

    public IIdentity Identity
    {
        get
        {
            return identity;
        }
        set
        {
            identity = value;
        }
    }
    public bool IsInRole(string roleName)
    {
        //Return true or false by your own logic.
        return false;
    }

    #endregion
}

 

这里我为了突出重点，所以把User类的其他不相关的东西删除了。大家可以看到，我们只要让User类实现IPrinciple接口就行了。然后我们可以为User类包含很多我们自定义的属性。

这样的做法有什么好处呢？其实我们也完全可以把当前用户放在Session或Cache等其他地方。我觉得最大的好处就是自然，因为ASP.NET提供给我们的HttpContext.Current.User对象的意图就是表示当前发送请求的用户实例，但因为该对象所存储的信息非常少，基本上就只存放了一个标识当前登陆用户的标识（如用户名）。但大部分情况下，我们都需要更多的用户信息，所以就自然而然很容易想到扩展该User属性。

 

当然还有一个需要说明的细节是，

因为我们自己创建了一个新的User对象，并且赋值给了HttpContext.Current.User，而赋值之前，HttpContext.Current.User.Identity不为空，所以为了一致，我们也应该给我们自己定义的User类的Identity属性赋值。

文件：

\Core\UserRolePermissions\User.cs

代码：

public static User GetAnonymousUser()
{
    User user = Activator.CreateInstance(Configuration.Instance.UserType) as User;
    user.SetRoles(Configuration.Instance.AnonymousDefaultRoleList);
    user.Identity = new GenericIdentity(string.Empty);
    return user;
}
public static User GetUser(Guid memberId)
{
    TRequest<User> request = new TRequest<User>();
    request.Data = Activator.CreateInstance(Configuration.Instance.UserType) as User;
    request.Data.MemberId.Value = memberId;
    EntityList users = Engine.GetAll(request);
    User user = null;
    if (users.Count > 0)
    {
        user = users[0] as User;
    }
    if (user != null)
    {
        InitializeUser(user);
    }
    return user;
}
private static void InitializeUser(User user)
{
    if (user != null)
    {
        TEntityList<Role> roles = new TEntityList<Role>();
        foreach (UserAndRole userAndRole in RoleManager.GetUserRoles(user.EntityId.Value))
        {
            roles.Add(userAndRole.Role);
        }
        user.SetRoles(roles);
        user.Identity = HttpContext.Current.User.Identity;
    }
}

 

大家可以看到黄色高亮度显示的那几行代码，我对Identity属性进行了赋值。

 

4： 如何在页面中访问当前用户？

文件：

\Business\Controls\ForumUserControl.cs

代码：

public class ForumUserControl : BaseUserControl
{
    protected ForumUser CurrentUser
    {
        get
        {
            return HttpContext.Current.User as ForumUser;
        }
    }

    protected bool ValidatePermission(PermissionType permission)
    {
        return CurrentUser.GetPermissions().ValidatePermission((long)permission);
    }
    protected bool ValidatePermission(PermissionType permission, Entity entity)
    {
        return CurrentUser.GetPermissions(entity).ValidatePermission((long)permission);
    }
}

 

ForumUserControl是一个基类UserControl，我们可以在该控件中提供一个表示当前登陆用户的属性CurrentUser，这样一来，我们在各个地方就可以很容易的访问我们自定义好的用户对象啦。是不是很简单呢？

 

好了， 以上就是蜘蛛侠论坛中当前登陆用户的设计与实现。因为觉得可能对大家有用，所以写出来与大家分享。

 

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

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47316 <![CDATA[千奇百怪的linux发音!]]> 豆浆咖啡 http://h31home.com/rss/ 2010-3-10 20:19:00 2010-3-10 20:19:00 阅读: 660 评论: 6 作者: 豆浆咖啡 发表于 2010-03-10 20:19 原文链接

    最近就很郁闷,说到linux这个系统大家都很熟悉,但是许多人的读法都不相同,原来的我一直读成"你留客死"，但是我经常听到其他千奇百怪的读法"你雷客死"(其他读法实在打不出来),本来也没对此事作个深究，今天突然吃饱撑着抱着疑问上网Search了下还真发现了不少有趣的东西，传说Linux的发明人(Linus Torvalds)录了一段录音,录音如下：

[hjp3]hjptype=song&player=1&son=http://www.paul.sladen.org/pronunciation/torvalds-says-linux.mp3&autoplay=no&autoreplay=1&bgcolor=FFFFFF&width=200&height=20[/hjp3]

    这段录音说了一段话"Hello，this is Linus Torvalds and I pronounce Linux as Linux"虽然不是很清晰，但是也能听出里面的Linux发音大致为"你呢课死"or“你拿课死"之类的...听了这个录音的我更加郁闷了....其实我以前也曾经读成“你拿课死"的，但是没人懂我在说什么，我只好改掉读成"你留客死"，.以前的同学老师朋友（包括现在的）都是读"你留客死"的，╮(╯▽╰)╭到底怎么回事？

    网上这三种读法都有人念，....于是没有解决问题的我又抱着这个硕大的疑问来到了博客园，本来想这篇文章不能发到首页上去的....但是为了解决这件事还是明知不可为而为之，希望大家给我个满意的答案!

评论: 6　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47317 <![CDATA[美国加州大学正在研制能修理水管的机器人 - 机器人智能网]]> yiyix http://h31home.com/rss/ 2010-3-10 19:35:11 2010-3-10 19:35:11


机器人应用广泛的一个重要原因就是能帮助或代替人类一些危险的或难以完成的工作，比如深入自来水管道内部检测和修理管道（日本管道巡检机器人）。加州大学正在研制一个能在水管内部修复老化管道的机器人。

原始链接:http://www.robotain.com/news/keji/201003/10458.html
diglog链接:http://www.diglog.com/story/technology_hardware_332305.html ]]> http://h31home.com/rss/blogto.asp?ID=47334 <![CDATA[vc2008 fstream不支持中文路径的解决方案]]> clane http://h31home.com/rss/ 2010-3-10 19:19:00 2010-3-10 19:19:00      跟踪了一下ifstream的open函数，发现ifstream在打开文件之前会通过_mbstowcs_l_helper函数把文件路径从mutilbyte转换到unicode。其中的关键转换函数如下:
 if (_loc_update.GetLocaleT()->locinfo->lc_handle[LC_CTYPE] == _CLOCALEHANDLE)
        {
            /* C locale: easy and fast */
            while (count < n)
            {
                *pwcs = (wchar_t) ((unsigned char)s[count]);
                if (!s[count])
                    return count;
                count++;
                pwcs++;
            }
            return count;

        } 
    而vc的默认local信息就是_CLOCALEHANDLE,于是中文字符很悲剧的被转换成了莫名其妙的一串东西。google了下，似乎很多人碰到了这个问题，也没有特别好的解决方案，要不直接unicode,要不每次调用fstream前后都调用一遍setlocal，对代码的侵入性都很强。
    我做了个封装的解决方案，使用个模板类对fstream做一个wrapper，代码如下:
template<class T>
struct fstream_fix
    :public T
{
    fstream_fix(){};

    template<class T1>
    fstream_fix(T1 v1){
        setlocale(LC_CTYPE, ".936");
        T::open(v1);
        setlocale(LC_CTYPE, 0);
    }

    template<class T1,class T2>
    fstream_fix(T1 v1,T2 v2){
        setlocale(LC_CTYPE, ".936");
        T::open(v1,v2);
        setlocale(LC_CTYPE, 0);
    }


    template<class T1>
    void open(T1 v1){
        setlocale(LC_CTYPE, ".936");
        T::open(v1);
        setlocale(LC_CTYPE, 0);
    }

    template<class T1,class T2>
    void open(T1 v1,T2 v2){
        setlocale(LC_CTYPE, ".936");
        T::open(v1,v2);
        setlocale(LC_CTYPE, 0);
    }
};

#define ifstream fstream_fix<ifstream>
#define ofstream fstream_fix<ofstream>
    OK.完美，对原项目没有任何影响，ifstream fi(filepath);filepath中含有中文也能正常工作了。:) 当然要注意的是，在宏定义之后，就不能再include <fstream>，不然可能会有编译错误。





clane 2010-03-10 19:19 发表评论
]]> http://h31home.com/rss/blogto.asp?ID=47321 <![CDATA[VirtualBox 虚拟机 Debian系统上安装Cassandra步骤及遇到的问题]]> Birdshover http://h31home.com/rss/ 2010-3-10 18:51:00 2010-3-10 18:51:00 阅读: 389 评论: 2 作者: Birdshover 发表于 2010-03-10 18:51 原文链接

本文记录一下我在VirtualBox 虚拟机 Debian系统上安装Cassandra步骤及遇到的问题。其它Linux系统碰到的问题应该大同小异。

 

一、网络问题

Sun的VirtualBox中文界面，而且开源，有什么理由不用呢？最近想看看各种Linux操作系统的差异，和RHEL系列的比，果然有很大的差别。下载Debian,第一张盘就行了，因为习惯自己编译了，不用本地源，常用的东西都是下载好了的。接下来，安装好Debian,无论是中文也好英文也罢。

 

下面就是配置网络的问题，由于Debian默认的网段是10.10.*.*的，我本机还访问不了，因此需要修改IP地址。修改了很多次才成功。记录下成功的这次。

 

安装完VirtualBox虚拟机后，会多一个网卡——VirtualBox Host-Only Network，默认IP是192.168.56.1。启动VirtualBox时，网络连接选择Host-only Adapter。这种模式是主机和虚拟机能够互相通信，但是虚拟机不能上网。对开发环境来说已经足够了。至于Nat和Bridged没有去尝试，Nat的要做端口映射，Bridged要占用主机网段IP，可能会抢同事的IP，就不尝试了。

 

下面是配置网络。Debian的网络设置和RHEL的不一样。设置网卡是在/etc/network/interfaces文件，设置DNS是在/etc/resolv.conf 文件。现在设置如下：

 

首先通过命令 # ifconfig -a 查看到当前外网网卡标识。我前几次操作错误，现在的标识是eth2。

在/etc/network/interfaces 文件加入：

 

auto eth2
iface eth2 inet dhcp

auto eth2

iface eth2 inet dhcp

 

然后通过 

#ifdown eth2

#ifup eth2

重新载入设置。现在网络就OK了。

 

二、Java安装

Cassandra是基于Java的程序，先去下载和Jre，我下载的Jre1.6 update18——“jre-6u18-linux-i586.bin”。把文件传过去，然后在虚拟机运行：

#cd ~    //我的是root帐号，我的文件就传到了/root目录

#chmod +x jre-6u18-linux-i586.bin

#./jre-6u18-linux-i586.bin

#cp jre1.6.0_18/ /usr/local/ -r

现在就把jre的文件拷贝到了/usr/local/jre1.6.0_18/目录。

现在要设置Java了，在RHEL使用alternatives命令，而在Debian使用update-alternatives命令，语法一样的。

Debian默认是没装Java的，现在开始设置：

#update-alternatives --install  /usr/bin/java java /usr/local/jre1.6.0_18/bin/java 300  

如果要是已经安装了java要换版本，可以用update-alternatives --display java查看当前安装的java,使用update-alternatives --config java进行版本切换。

现在输入

#java -version

java version "1.6.0_18"

Java(TM) SE Runtime Environment (build 1.6.0_18-b07)

Java HotSpot(TM) Client VM (build 16.0-b13, mixed mode)

 

OK了，一切正常。

 

 

三、安装和启动

先到http://incubator.apache.org/cassandra/页面下载Cassandra。

我下载的是 apache-cassandra-0.5.1-bin.tar.gz

然后传到虚拟机上。

执行命令

#tar zxvf apache-cassandra-0.5.1-bin.tar.gz   //解压缩

#cd apache-cassandra-0.5.1/bin

#./cassandra

输出

Listening for transport dt_socket at address: 8888

INFO - Replaying /var/lib/cassandra/commitlog/CommitLog-1268246662083.log

INFO - LocationInfo has reached its threshold; switching in a fresh Memtable

INFO - Enqueuing flush of Memtable(LocationInfo)@19897293

INFO - Sorting Memtable(LocationInfo)@19897293

INFO - Writing Memtable(LocationInfo)@19897293

INFO - Completed flushing /var/lib/cassandra/data/system/LocationInfo-1-Data.db

INFO - Log replay complete

INFO - Saved Token found: 59927080841113489954773621748862915294

INFO - Starting up server gossip

 

成功了，呵呵。

 

当然，要用到生产环境的话可能还需要做很多工作。比如配置啊，开发啊什么的。自己弄来看看的话，这已经是第一步了，呵呵。

 

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

找优秀程序员，就在博客园

最新新闻：
· 谷歌雅虎等抗议英国屏蔽含盗版内容网站计划(2010-03-10 22:47)
· Twitter开始监控所有外部链接 以防钓鱼式攻击(2010-03-10 22:40)
· IBM联手大学开发老年与文盲群体易用手机(2010-03-10 21:32)
· Arm称今年将有五十余款iPad类平板电脑上市(2010-03-10 21:31)
· 互联网泡沫十周年 当年热股今何在(2010-03-10 21:22)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47318 <![CDATA[水彩画风格网站设计欣赏]]> mohaiguyan http://h31home.com/rss/ 2010-3-10 17:27:08 2010-3-10 17:27:08


Web Designer Wall

Boompa Shop

Agami Creative

原始链接:http://www.36ria.cn/?p=1600
diglog链接:http://www.diglog.com/story/technology_design_332283.html ]]> http://h31home.com/rss/blogto.asp?ID=47335 <![CDATA[Silverlight Path的Data生成]]> ghj1976 http://h31home.com/rss/ 2010-3-10 16:10:53 2010-3-10 16:10:53 Path的Data数据有下面几种生成方式：

  1. 来自其它矢量图。比如使用 Expression Design，就可以直接粘贴来自其它软件的矢量图形，然后选择导出，导出时做如后选择：文件->导出->导出属性->格式->XAML Silverlight 画布，即可得到XAML格式的矢量图形，也就是Path。
  2. 使用转换路径，比如，我们要把文字转成图形，相当于印刷行业里的文字转曲，可以直接用 Expression Blend。选中对象->路径->转换为路径，即可。
  3. 自己动手写。当然这也是最难的方式。不过对于简单图形来说非常有用。用Design生成的数据量很大，手写就会变得很简洁。这篇博客就是要介绍Path命令的格式，以及如何写一些简单的Path。

首先是Path命令列表

下面这个地址有详细描述，Silverlight路径标记语法，我下面用表格的方式给出，更直观点。

说明：

  • 下面命令中，语法部分显示的是单个空格，实际上使用单个空格的地方也可以使用多个空格；
  • 命令前后的空格也不是必须的；
  • 如果结果字符串比较明确，则无需使用逗号或空白将两个数字隔开。例如，2..3 解释为两个数字："2."和".3"。同样，2-3 包含两个数字："2"和"-3"。
  • 下面的命令中，绝大多数大写表示绝对值，小写表示相对于前一点的值。

 

类型 命令格式 解释
移动指令  Move Command（M） M x,y
或
m x,y		 比如：M 100,240 或 m 100,240

大写的 M 指示 x,y 是绝对值；
小写的 m 指示 x,y 是相对于上一个点的偏移量，如果是 (0,0)，则表示不存在偏移。
当您在 move 命令之后列出多个点时，即使您指定的是线条命令，也将绘制出连接这些点的线。
绘制指令
（Draw Command）

通过使用一个大写或小写字母输入各命令：

其中大写字母表示绝对值，
小写字母表示相对值。

线段的控制点是相对于上一线段的终点而言的。

依次输入多个同一类型的命令时，可以省略重复的命令项；

例如，L 100,200 300,400 等同于 L 100,200 L 300,400。

直线:Line(L)

 格式：
L 结束点坐标
或:
l 结束点坐标。
比如：L 100,100 或 l 100 100。
坐标值可以使用x,y（中间用英文逗号隔开）或x y（中间用半角空格隔开）的形式。

水平直线: Horizontal line(H)

 格式：
H x值
或
h x值
(x为System.Double类型的值)
绘制从当前点到指定x坐标的直线。
比如：H 100或h 100，也可以是：H 100.00或h 100.00等形式。

垂直直线: Vertical line(V)

 V y值
或
v y值
(y为System.Double类型的值)		 绘制从当前点到指定y坐标的直线。
比如：V 100或y 100，也可以是：V 100.00或v 100.00等形式。

三次方程式贝塞尔曲线:
Cubic Bezier curve(C)

 C 第一控制点 第二控制点 结束点
或
c 第一控制点 第二控制点 结束点		 通过指定两个控制点来绘制由当前点到指定结束点间的三次方程贝塞尔曲线。
比如：C 100,200 200,400 300,200 或 c 100,200 200,400 300,200
其中，点(100,200)为第一控制点，点(200,400)为第二控制点，点(300,200)为结束点。

二次方程式贝塞尔曲线:
Quadratic Bezier curve(Q)

 Q 控制点 结束点
或
q 控制点 结束点
通过指定的一个控制点来绘制由当前点到指定结束点间的二次方程贝塞尔曲线。
比如：q 100,200 300,200。其中，点(100,200)为控制点，点(300,200)为结束点。

平滑三次方程式贝塞尔曲线:
Smooth cubic Bezier curve(S)

 S 控制点 结束点
或
s 控制点 结束点
通过一个指定点来“平滑地”控制当前点到指定点的贝塞尔曲线。

比如：S 100,200 200,300

平滑二次方程式贝塞尔曲线:
smooth quadratic Bezier curve(T)

 T 控制点 结束点
或
t 控制点 结束点
与平滑三次方程贝塞尔曲线类似。在当前点与指定的终点之间创建一条二次贝塞尔曲线。控制点假定为前一个命令的控制点相对于当前点的反射。如果前一个命令不存在，或者前一个命令不是二次贝塞尔曲线命令或平滑的二次贝塞尔曲线命令，则此控制点就是当前点。

比如：T 100,200 200,300
椭圆圆弧: elliptical Arc(A) A 尺寸 圆弧旋转角度值 优势弧的标记 正负角度标记 结束点
或：
a 尺寸 圆弧旋转角度值 优势弧的标记 正负角度标记 结束点

在当前点与指定结束点间绘制圆弧。

  • 尺寸(Size): System.Windows.Size类型，指定椭圆圆弧X,Y方向上的半径值。
  • 旋转角度（rotationAngle）：System.Double类型。
  • 圆弧旋转角度值（rotationAngle）：椭圆弧的旋转角度值。
  • 优势弧的标记（isLargeArcFlag）：是否为优势弧，如果弧的角度大于等于180度，则设为1，否则为0。
  • 正负角度标记（sweepDirectionFlag）：当正角方向绘制时设为1，否则为0。
  • 结束点（endPoint）：System.Windows.Point类型。

比如：A 5,5 0 0 1 10,10
关闭指令  (close Command):
可选的关闭命令		 用Z或z表示 用以将图形的首、尾点用直线连接，以形成一个封闭的区域。
填充规则（fillRule）

如果省略此命令，则路径使用默认行为:即 EvenOdd。
如果指定此命令，则必须将其置于最前面。> 		EvenOdd 填充规则 F0 指定 EvenOdd 填充规则。 EvenOdd 确定一个点是否位于填充区域内的规则方法：从该点沿任意方向画一条无限长的射线，然后计算该射线在给定形状中因交叉而形成的路径段数。如果该数为奇数，则点在内部；如果为偶数，则点在外部。
Nonzero 填充规则 F1 指定 Nonzero 填充规则。 Nonzero 确定一个点是否位于路径填充区域内的规则方法：从该点沿任意方向画一条无限长的射线，然后检查形状段与该射线的交点。从 0 开始计数，每当线段从左向右穿过该射线时加 1，而每当路径段从右向左穿过该射线时减 1。计算交点的数目后，如果结果为 0，则说明该点位于路径外部。否则，它位于路径内部。

 

一些简单例子：

Xaml 文件

<UserControl
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	x:Class="SilverlightApplication_Test.MainPage"
	Width="640" Height="500">
	<Canvas Background="Black">
		<!-- 1 //-->
		<Path Stroke="BlanchedAlmond" Data="M101,95 L269,95"/>
		<!-- 2 //-->
		<Path Stroke="Blue" Data="m101,95 l269,95"/>
		<!-- 3 //-->
		<Path Stroke="BlanchedAlmond" Data="M101,95 58,54 60,38"/>
		<!-- 4 //-->
		<Path Stroke="BurlyWood" Data="M30,185 H100"/>
		<!-- 5 //-->
		<Path Stroke="BurlyWood" Data="M30,185 v100"/>
	</Canvas>
</UserControl>

执行效果，下面数字分别标识了上面代码注释中的5条线。

image

Xaml 文件

<UserControl
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	x:Class="SilverlightApplication_Test.MainPage"
	Width="640" Height="500">
	<Canvas Background="Black">
		<!-- 1 //-->
		<Path Stroke="AliceBlue" Data="M 150,50 c 80,3 8,60 120,30" />
		
		<!-- 2 //-->
		<Path Stroke="Aqua" Data="M 70,150 Q 80,30 120,90" />

		<!-- 3 //-->
		<Path Stroke="Azure" Data="M 90,150 s 118,3 190,90" />

		<!-- 4 //-->
		<Path Stroke="RosyBrown" Data="M 350,110 t10,20 32,10" />

		<!-- 5 //-->
		<Path Stroke="Red" Data="M 90,180 a 2 3 8 1 0 29,90" />
	</Canvas>
</UserControl>

执行效果，下面数字分别标识了上面代码注释中的5条线。

image 

Xaml 文件

<UserControl
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	x:Class="SilverlightApplication_Test.MainPage"
	Width="640" Height="500">
	<Canvas Background="Black">
		<!-- 1 //-->
		<Path Stroke="AliceBlue" Data="F0 M 150,50 c 5,30 8,60 120,30 z" />
		
		<!-- 2 //-->
		<Path Stroke="Red" Data="F1 M 95,180 a 2 3 8 1 0 29,90z" />
	</Canvas>
</UserControl>

执行效果，

image 

更复杂的，建议还是用前2种方法吧。 

 

参考资料：

silverlight中path对象使用总结
http://www.cnblogs.com/daizhj/archive/2008/07/14/1242181.html

Silverlight里C#绘制Path的方法
http://mcs.szu.edu.cn/user/zouzhxi/Article_53515

SilverLight 关于Path的Data生成问题
http://www.thinkaspx.com/wordpress/silverlight-on-the-path-of-the-data-generation-problem.Thinkaspx

Silverlight学习笔记--绘制与着色（上）
http://blog.joycode.com/ghj/archive/2009/11/24/115786.joy

乱弹琴 Silverlight 2.0 (14) 几何图形(Geometry)(二)路径标记语法
http://www.cnblogs.com/zxjay/archive/2008/04/18/1200692.html


博客堂源代码发布已经发布于Codeplex，邀请您来捉臭虫]]> http://h31home.com/rss/blogto.asp?ID=47311 <![CDATA[盖莫游戏引擎中的光照系统]]> ccsdu2009 http://h31home.com/rss/ 2010-3-10 15:31:00 2010-3-10 15:31:00

ccsdu2009 2010-03-10 15:31 发表评论
]]> http://h31home.com/rss/blogto.asp?ID=47322 <![CDATA[银光中国回复“菩提树下的杨过“的”转贴投诉“]]> silverlightchina http://h31home.com/rss/ 2010-3-10 15:20:00 2010-3-10 15:20:00 阅读: 339 评论: 8 作者: silverlightchina 发表于 2010-03-10 15:20 原文链接

首先我想对网友“菩提树下的杨过”表示抱歉，在转载的过程中引起了这些误会和矛盾，对此我们表示深深的歉意。

 

银光中国（SilverlightChina.Net)是一个非盈利性的专注讨论Silverlight技术社区， 众所周知，一门技术的发展需要众多的开发人员的支持和帮助，所以，银光中国多数文章是从国内或者国外网站收集而来的，在收集的过程中，为了保证项目源码的完整性和可用性，我们会对代码进行调试，在编译成功后，发布到网站，有时我们会对部分代码进行修改，其目的是希望能够帮助更多的朋友了解和学习Silverlight技术，顺利地学习和阅读项目源代码。在每次转贴过程中，我们一贯保证作者版权为主，从来没有修改任何作者的版权信息，在每篇文章的开始部分，我们都会明显标明出处和作者，对于优秀的Silverlight系列文章，我们会单独开设专题，对作者和文章教程进行宣传。而且，在每次的转贴后，我们都会在作者原文留言，通知该文章被银光中国网收录。在收录过程中，如果作者有所异议，可以发邮件到admin@silverlightchina.net，我们会及时处理。

 

对于网友“菩提树下的杨过”提出没有标示出版权信息，请看下图文章版权信息，同时您也可以访问其他文章页面，每篇文章都会有相关作者的版权信息，并且会在文章开始进行明显标注：

http://www.silverlightchina.net/html/works/2009/1019/207.html

 

 

 

 

http://www.silverlightchina.net/html/works/2010/0205/673.html

 

 



对于 网友“菩提树下的杨过”提出问题的解释：

 

对于转贴的解释:

对于网友“菩提树下的杨过”得文章，本站编辑在发布项目前进行了抓图，为了更好的宣传网站，修改了部分图片，这里我们表示深深地歉意，同时也希望网友“菩提树下的杨过”能够理解。在随后的时间，我们将修改部分抓图信息；

 

对于广告的解释：

银光中国，在转贴后，都会给作者留言，留下文章地址，目的也是为了让作者对于文章版权信息进行监督。这样的做法，是对作者负责的一种行为方式。

 

 

银光中国网

评论: 8　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 谷歌地图添加自行车路线 提供骑行线路(2010-03-10 15:54)
· 华尔街日报：谷歌超速网络建设面临两大挑战(2010-03-10 15:51)
· Myspace联席总裁：网站将全新改版以夺回市场(2010-03-10 15:46)
· Sun首席开源官菲普斯离职(2010-03-10 15:29)
· 腾讯在Facebook发布首款社交游戏“牧场生活”(2010-03-10 15:26)

编辑推荐：过去十年值得关注的十大技术事件

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

]]> http://h31home.com/rss/blogto.asp?ID=47299 <![CDATA[方便易用的客户端网络库]]> 饭中淹 http://h31home.com/rss/ 2010-3-10 14:49:00 2010-3-10 14:49:00 详情参阅 读我.txt
/Files/johndragon/ClientNet.zip

另外：静态链接需要将 ClientNet.lib 手动连接到工程的连接项里，或者在代码中使用
#pragma comment( lib, "ClientNet.lib" )
来进行连接。



饭中淹 2010-03-10 14:49 发表评论
]]> http://h31home.com/rss/blogto.asp?ID=47323