C++博客-梦幻白桦林-文章分类-C#.Net

把多个文件写入到一个文件中去并能分解

colys — Mon, 08 Oct 2007 03:50:00 GMT

对于一个文件的读写，其实很简单，就是用FileStream进行Read或者Write就行了。但是如何把多个文件写入到同一个文件，之后要能把这个文件进行还原成多个文件。那么光靠FileStream的Read和Write方法是不够的，首先你需要自行建立文件索引，来标明每个文件在当前文件的位置。

那么最近作了一个简单的DEMO，其中类的部分代码如下：

//------------------------------- Compose Files ----------------------------------

//--------------------------------------------------------------------------------

//---File:clsComposeFiles.cs

//---Description:This file is to show how-to compose multi-files into one file

// and decompose one file to multi-files.

//---Author:Knight

//---Date:May.16, 2006

//--------------------------------------------------------------------------------

//------------------------------{ Compose Files }---------------------------------

namespace ComposeFiles

{

using System;

using System.IO;

using System.Collections;

using System.Text;

///

/// Summary description for clsComposeFiles.

///

public class clsComposeFiles

{

private ArrayList arrFiles = new ArrayList();

public clsComposeFiles()

{

// TODO: Add constructor logic here

}

///

/// Add a file to be composed

///

public void AddFile( string sFileName )

{

arrFiles.Add( sFileName );

}

///

/// Compose files to the specific file

///

public bool ComposeFiles( string sFileName )

{

if( arrFiles.Count == 0 ) return false;

FileInfo fi = new FileInfo( sFileName );

// Open file to write

FileStream fsWriter = null;

try

{

if( !fi.Exists )

{

fsWriter = new FileStream(

sFileName,

FileMode.CreateNew,

FileAccess.ReadWrite,

FileShare.None );

}

else

fsWriter = new FileStream(

sFileName,

FileMode.Truncate,

FileAccess.ReadWrite,

FileShare.None );

}

catch(Exception err)

{

System.Diagnostics.Debug.WriteLine( err.Message );

return false;

}

byte[] bBuffer = null;

// Write files count

bBuffer = FileIndex.LongToBytes( arrFiles.Count );

fsWriter.Write( bBuffer, 0, 8 );

const long INDEX_START_POS = 8L;

// Init files index

FileIndex FI = new FileIndex();

for( int i = 0; i < arrFiles.Count; i++ )

fsWriter.Write( FileIndex.ConvertToBytes( ref FI ), 0, 32 );

long FILE_START_POS = INDEX_START_POS + 32 * arrFiles.Count;

long lCurFileStartPos = FILE_START_POS;

// Write every file

for( int i = 0; i < arrFiles.Count; i++ )

{

WriteFile( arrFiles[i].ToString(),

ref lCurFileStartPos,

INDEX_START_POS,

fsWriter,

i );

}

// Close stream

fsWriter.Close();

return true;

}

///

/// Write file name and data into composed file

///

private void WriteFile(

string sFileName,

ref long FileStartPos,

long IndexStartPos,

FileStream fsWriter,

int Index )

{

FileInfo fi = new FileInfo( sFileName );

if( !fi.Exists ) return;

FileStream fsReader = null;

try

{

fsReader = new FileStream(

sFileName, FileMode.Open,

FileAccess.Read );

}

catch{ return;}

// Get file name

byte[] bFileName = Encoding.Unicode.GetBytes( fi.Name );

// Write file name

fsWriter.Write( bFileName, 0, bFileName.Length );

const int BUFFER_LENGTH = 1024;

byte[] bBuffer = new byte[BUFFER_LENGTH];

int nRealRead = 0;

// Write data using

{

// Read data from file

nRealRead = fsReader.Read( bBuffer, 0,

BUFFER_LENGTH );

// Write data

fsWriter.Write( bBuffer, 0, nRealRead );

}while( nRealRead > 0 );

// Close file reader

fsReader.Close();

FileIndex FINew = new FileIndex();

FINew.NameStartPos = FileStartPos;

FINew.NameLength = bFileName.Length;

FINew.FileStartPos = FileStartPos + bFileName.Length;

FINew.FileLength = fi.Length;

// Go back to file index position

fsWriter.Seek( IndexStartPos + Index * 32, SeekOrigin.Begin );

// Write file index info

fsWriter.Write( FileIndex.ConvertToBytes( ref FINew ), 0, 32 );

// Go back to file end

fsWriter.Seek( 0, SeekOrigin.End );

// Set file current position

FileStartPos += bFileName.Length + fi.Length;

}

///

/// Decompose file to multi files into specific directory

///

public bool DecomposeFile( string sFileName, string sDestDir )

{

FileInfo fi = new FileInfo( sFileName );

if( !fi.Exists ) return false;

FileStream fsReader = null;

try

{

fsReader = new FileStream(

sFileName, FileMode.Open,

FileAccess.Read );

}

catch{ return false;}

// Read file count

byte[] bFileCount = new byte[8];

int nRealRead = 0;

nRealRead = fsReader.Read( bFileCount, 0, 8 );

if( nRealRead != 8 )

{

fsReader.Close();

return false;

}

long lFileCount = FileIndex.BytesToLong( bFileCount );

if( lFileCount > 0 )

{

//Init file index array

FileIndex[] fiArray = new FileIndex[lFileCount];

byte[] bFileIndex = new byte[32];

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

{

fsReader.Read( bFileIndex, 0, 32 );

fiArray[i] = FileIndex.ConvertToFileIndex( bFileIndex );

}

if( sDestDir[ sDestDir.Length - 1] != '\\' )

sDestDir += "\\";

// Save every file into current directory

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

{

SaveFile( fsReader,

ref fiArray[i],

sDestDir );

}

// Close file reader

fsReader.Close();

return true;

}

///

/// Save every file into directory

///

private void SaveFile(

FileStream fsReader,

ref FileIndex FI,

string sDestDir )

{

// Read file name

byte[] bFileName = new byte[ FI.NameLength ];

int nRealRead = fsReader.Read( bFileName, 0, bFileName.Length );

if( nRealRead != bFileName.Length ) return;

string sFileName = Encoding.Unicode.GetString( bFileName );

sFileName = sDestDir + sFileName;

FileInfo fi = new FileInfo( sFileName );

// Open file to write

FileStream fsWriter = null;

try

{

if( !fi.Exists )

{

fsWriter = new FileStream(

sFileName,

FileMode.CreateNew,

FileAccess.ReadWrite,

FileShare.None );

}

else

fsWriter = new FileStream(

sFileName,

FileMode.Truncate,

FileAccess.ReadWrite,

FileShare.None );

}

catch(Exception err){

System.Diagnostics.Debug.WriteLine( err.Message );

return;

}

// Init buffer

const int BUFFER_LENGTH = 1024;

byte[] bBuffer = new byte[BUFFER_LENGTH];

long lLeft = FI.FileLength;

// Copy file

{

if( lLeft > BUFFER_LENGTH )

{

fsReader.Read( bBuffer, 0, BUFFER_LENGTH );

fsWriter.Write( bBuffer, 0, BUFFER_LENGTH );

lLeft -= BUFFER_LENGTH;

}

else

{

nRealRead = fsReader.Read( bBuffer, 0, (int)lLeft );

fsWriter.Write( bBuffer, 0, nRealRead );

lLeft -= nRealRead;

}

while( lLeft > 0 );

// close file writer

fsWriter.Close();

}

///

/// File index data structure

///

public struct FileIndex

{

public long NameStartPos;

public long NameLength;

public long FileStartPos;

public long FileLength;

public static byte[] ConvertToBytes( ref FileIndex FI )

{

byte[] bData = new byte[32];

Array.Copy( LongToBytes( FI.NameStartPos ), 0, bData, 0, 8 );

Array.Copy( LongToBytes( FI.NameLength ), 0, bData, 8, 8 );

Array.Copy( LongToBytes( FI.FileStartPos ), 0, bData, 16, 8 );

Array.Copy( LongToBytes( FI.FileLength ), 0, bData, 24, 8 );

return bData;

}

public static byte[] LongToBytes( long lValue )

{

byte[] bData = new byte[8];

bData[0] = (byte)( ( lValue >> 56 ) & 0xFF);

bData[1] = (byte)( ( lValue >> 48 ) & 0xFF);

bData[2] = (byte)( ( lValue >> 40 ) & 0xFF);

bData[3] = (byte)( ( lValue >> 32 ) & 0xFF);

bData[4] = (byte)( ( lValue >> 24 ) & 0xFF);

bData[5] = (byte)( ( lValue >> 16 ) & 0xFF);

bData[6] = (byte)( ( lValue >> 8 ) & 0xFF);

bData[7] = (byte)(lValue & 0xFF);

return bData;

}

public static FileIndex ConvertToFileIndex( byte[] bData )

{

if( bData == null || bData.Length != 32 )

throw new Exception( "Invalid parameters!" );

FileIndex FI = new FileIndex();

byte[] bBuffer = new byte[8];

Array.Copy( bData, 0, bBuffer, 0, 8 );

FI.NameStartPos = BytesToLong( bBuffer );

Array.Copy( bData, 8, bBuffer, 0, 8 );

FI.NameLength = BytesToLong( bBuffer );

Array.Copy( bData, 16, bBuffer, 0, 8 );

FI.FileStartPos = BytesToLong( bBuffer );

Array.Copy( bData, 24, bBuffer, 0, 8 );

FI.FileLength = BytesToLong( bBuffer );

return FI;

}

public static long BytesToLong( byte[] bData )

{

if( bData == null || bData.Length != 8 )

throw new Exception( "Invalid parameters!" );

long lngValue = 0;

lngValue += bData[0];

lngValue = ( lngValue << 8 );

lngValue += bData[1];

lngValue = ( lngValue << 8 );

lngValue += bData[2];

lngValue = ( lngValue << 8 );

lngValue += bData[3];

lngValue = ( lngValue << 8 );

lngValue += bData[4];

lngValue = ( lngValue << 8 );

lngValue += bData[5];

lngValue = ( lngValue << 8 );

lngValue += bData[6];

lngValue = ( lngValue << 8 );

lngValue += bData[7];

return lngValue;

}

其中类的操作参看clsComposeFiles这个类，而文件索引结构参看FileIndex这个Structure。

之后的调用就很简单，例如：

合成文件：

clsComposeFiles myComposeFiles = new clsComposeFiles();

myComposeFiles.AddFile( @"D:\Ship.exe" );

myComposeFiles.AddFile( @"D:\LoginPage.JPG" );

myComposeFiles.ComposeFiles( @"D:\Ship.dat" );

分解文件：

clsComposeFiles myComposeFiles = new clsComposeFiles();

myComposeFiles.DecomposeFile( @"D:\Ship.dat", @"E:\" );

colys 2007-10-08 11:50 发表评论

利用客户端缓存对网站进行优化[转]

colys — Tue, 25 Sep 2007 05:23:00 GMT

介绍

        你的网站在并发访问很大并且无法承受压力的情况下,你会选择如何优化?
        很多人首先会想从服务器缓存方面着手对程序进行优化,许多不同的服务器缓存方式都有他们自己的特点,像我曾经参与的一些项目中,根据缓存的命中率不同使用过 Com+/Enterprise Libiary Caching/Windows服务,静态文件等方式的服务器端缓存和 HTTP Compression技术,但客户端缓存往往却被人们忽略了,即使服务器的缓存让你的页面访问起来非常地快,但她依然需要依赖浏览器下载并输出,而当你加入客户端缓存时,会给你带来非常多的好处.因为她可以对站点中访问最频繁的页进行缓存充分地提高 Web 服务器的吞吐量（通常以每秒的请求数计算）以提升应用程序性能和可伸缩性。
        一个在线购物调查显示，大多数人愿意去商店排队，但在在线购物时却不愿意等待。Websense调查公司称多达70%的上网者表示不愿意在页面读取上超过10秒钟。超过70%的人会因为中途速度过慢而取消当前的订单。

基础知识

        1) 什么是”Last-Modified”?

        在浏览器第一次请求某一个URL时，服务器端的返回状态会是200，内容是你请求的资源，同时有一个Last-Modified的属性标记此文件在服务期端最后被修改的时间，格式类似这样：

        Last-Modified: Fri, 12 May 2006 18:53:33 GMT

        客户端第二次请求此URL时，根据 HTTP 协议的规定，浏览器会向服务器传送 If-Modified-Since 报头，询问该时间之后文件是否有被修改过：

        If-Modified-Since: Fri, 12 May 2006 18:53:33 GMT

        如果服务器端的资源没有变化，则自动返回 HTTP 304 （Not Changed.）状态码，内容为空，这样就节省了传输数据量。当服务器端代码发生改变或者重启服务器时，则重新发出资源，返回和第一次请求时类似。从而保证不向客户端重复发出资源，也保证当服务器有变化时，客户端能够得到最新的资源。

        2) 什么是”Etag”?

        HTTP 协议规格说明定义ETag为“被请求变量的实体值” （参见 —— 章节 14.19）。另一种说法是，ETag是一个可以与Web资源关联的记号（token）。典型的Web资源可以一个Web页，但也可能是JSON或XML文档。服务器单独负责判断记号是什么及其含义，并在HTTP响应头中将其传送到客户端，以下是服务器端返回的格式：

        ETag: "50b1c1d4f775c61:df3"

        客户端的查询更新格式是这样的：

        If-None-Match: W/"50b1c1d4f775c61:df3"

        如果ETag没改变，则返回状态304然后不返回，这也和Last-Modified一样。本人测试Etag主要在断点下载时比较有用。

Last-Modified和Etags如何帮助提高性能?

        聪明的开发者会把Last-Modified 和ETags请求的http报头一起使用，这样可利用客户端（例如浏览器）的缓存。因为服务器首先产生 Last-Modified/Etag标记，服务器可在稍后使用它来判断页面是否已经被修改。本质上，客户端通过将该记号传回服务器要求服务器验证其（客户端）缓存。
        过程如下:
                1. 客户端请求一个页面（A）。
                2. 服务器返回页面A，并在给A加上一个Last-Modified/ETag。
                3. 客户端展现该页面，并将页面连同Last-Modified/ETag一起缓存。
                4. 客户再次请求页面A，并将上次请求时服务器返回的Last-Modified/ETag一起传递给服务器。
                5. 服务器检查该Last-Modified或ETag，并判断出该页面自上次客户端请求之后还未被修改，直接返回响应304和一个空的响应体。

示例代码

下面的例子描述如何使用服务器端代码去操作客户端缓存:

  //默认缓存的秒数
  int secondsTime = 100;

  //判断最后修改时间是否在要求的时间内
  //如果服务器端的文件没有被修改过，则返回状态是304，内容为空，这样就节省了传输数据量。如果服务器端的文件被修改过，则返回和第一次请求时类似。
  if (request.Headers["If-Modified-Since"] != null && TimeSpan.FromTicks(DateTime.Now.Ticks - DateTime.Parse(request.Headers["If-Modified-Since"]).Ticks).Seconds < secondsTime)
  {
      //测试代码,在这里会发现,当浏览器返回304状态时,下面的日期并不会输出
      Response.Write(DateTime.Now);

     response.StatusCode = 304;
     response.Headers.Add("Content-Encoding", "gzip");
     response.StatusDescription = "Not Modified";
  }
  else
  {
     //输出当前时间
     Response.Write(DateTime.Now);

     //设置客户端缓存状态
     SetClientCaching(response, DateTime.Now);
  }

  #region SetClientCaching..
  ///

/// 设置客户端缓存状态
///

  ///
  ///
  private void SetClientCaching(HttpResponse response, DateTime lastModified)
  {
     response.Cache.SetETag(lastModified.Ticks.ToString());
     response.Cache.SetLastModified(lastModified);
     //public 以指定响应能由客户端和共享（代理）缓存进行缓存。
     response.Cache.SetCacheability(HttpCacheability.Public);
     //是允许文档在被视为陈旧之前存在的最长绝对时间。
　    response.Cache.SetMaxAge(new TimeSpan(7, 0, 0, 0));
     //将缓存过期从绝对时间设置为可调时间
     response.Cache.SetSlidingExpiration(true);
  }
#endregion

如果你的缓存是基于文件的方式,如XML或http中的.ashx处理,也可以使用下面的基于文件方式的客户端缓存:

#region SetFileCaching..
///

/// 基于文件方式设置客户端缓存
///

  ///
  private void SetFileCaching(HttpResponse response, string fileName)
  {
     response.AddFileDependency(fileName);
      //基于处理程序文件依赖项的时间戳设置 ETag HTTP 标头。
     response.Cache.SetETagFromFileDependencies();
     //基于处理程序文件依赖项的时间戳设置 Last-Modified HTTP 标头。
     response.Cache.SetLastModifiedFromFileDependencies();
     response.Cache.SetCacheability(HttpCacheability.Public);
     response.Cache.SetMaxAge(new TimeSpan(7, 0, 0, 0));
     response.Cache.SetSlidingExpiration(true);
}
#endregion

使用后的效果如下图所示:

上图所使用的工具是在IE下运行的HttpWatchPro,在Firefox下可以使用FireBug+YSlow进行测试.
YSlow是建立在FireBug基础上运行的一个小工具,它可以对你的网页进行分析为什么缓存,并给出评分和缓慢的原因.这个工具来自Yahoo的研发团队,所以规则也是Yahoo制定的.

结论

        我们已经看了如何使用客户端缓存减少带宽和计算的方法,如前所述,如果能正确合理的利用各种不同的缓存,他们会给你带来很多的好处.我希望本文已为你当下或将来基于Web的项目提供了精神食粮，并正确地在底层利用Last- Modified和ETag响应头去优化你的项目。

参考资料:

301永久重定向实现方式及302重定向

理解ASP.NET与客户端缓存之HTTP协议

如何利用客户端缓存对网站进行优化?

原文地址：http://www.cnblogs.com/lion.net/archive/2007/09/24/904717.html

colys 2007-09-25 13:23 发表评论

nhibernate入门系列: many-to-many映射[转]

colys — Wed, 19 Sep 2007 03:31:00 GMT

多对多关系在数据库也是比较常见的，它通过一个中间表将两个主表关联起来。
下面来看看多对多关联在nh的实现，示例是一个User和Group之间的多对多关联。

先来看看User类的映射信息:

在多对多定义中，定义了中间表为UserGroups，此表只有两个字段：user_id和group_id；用于关联Users和Groups表。

User的定义：

public class User {

   public User() {
   }

   public int UserId
   {
      get { return userId; }
      set { userId = value; }
   }

   public int Name
   {
      get { return name; }
      set { name = value; }
   }

   public IDictionary Groups
   {
      get { return groups; }
      set { groups = value; }
   }

   private int userId;
   private string name;
   private IDictionary groups = new Hashtable();

} //class User

这里用一个数据字典IDictionary对角来保存组对象。

再来看看Group类的映射信息：

这里many-to-many的定义和User类映射信息中的差不多。

组类的定义：

public class Group {

   public Group() {
   }

   public int GroupId
   {
      get { return groupId; }
      set { groupId = value; }
   }

   public int Name
   {
      get { return name; }
      set { name = value; }
   }

   public int Description
   {
      get { return description; }
      set { description = value; }
   }

   public IDictionary Users
   {
      get { return users; }
      set { users = value; }
   }

   private int groupId;
   private string name;
   private IDictionary users = new Hashtable();

} //class Group

注意：多对多没有主次之分，保存时的两边都要save!

下面给出部分测试代码。

public TestCreate() {
   User user1 = new User();
   user1.Name = "test1";
   User user2 = new User();
   user2.Name = "test2";

   Group group1 = new Group();
   group1.Name = "group1";
   Group group2 = new Group();
   group2.Name = "group2";

   user1.Groups.Add( group2, group2 );
   user2.Groups.Add( group1. group1 );
   group1.Users.Add( user2, user2 );
   group2.Users.Add( user1, user1 );

   ITransactioin trans = null;
   try {
      trans = session.BeginTransaction();

      Session.Save( user1 );
      Session.Save( user2 );
      Session.Save( group1 );
      Session.Save( group2 );

      trans.Commit();
   }
   catch ( Exception e ) {
      if ( trans != null ) trans.Rollback();
      throw e;
   }
   finally {
      session.Close();
   }
}

以上测试代码中session的相关操作请查看相关文档。

在实际应用中，我较少使用many-to-many映射，当然这要从性能和实际需要考虑。
我的做法是一个elements来取得所有关联的identity, 然后在需要的时候才加载对象，有点类似lazy, 但lazy有一个问题，就是session必须没有被释放，这在分层开发中较难办到。

原文:http://www.seaskyer.net/Index/Catalog44/182.html

colys 2007-09-19 11:31 发表评论

分散数据库压力,分表处理设计思想和实现

colys — Tue, 18 Sep 2007 01:51:00 GMT

一、概述

分表是个目前算是比较炒的比较流行的概念，特别是在大负载的情况下，分表是一个良好分散数据库压力的好方法。

首先要了解为什么要分表，分表的好处是什么。我们先来大概了解以下一个数据库执行SQL的过程：

接收到SQL --> 放入SQL执行队列 --> 使用分析器分解SQL --> 按照分析结果进行数据的提取或者修改 --> 返回处理结果

当然，这个流程图不一定正确，这只是我自己主观意识上这么我认为。那么这个处理过程当中，最容易出现问题的是什么？就是说，如果前一个SQL没有执行完毕的话，后面的SQL是不会执行的，因为为了保证数据的完整性，必须对数据表文件进行锁定，包括共享锁和独享锁两种锁定。共享锁是在锁定的期间，其它线程也可以访问这个数据文件，但是不允许修改操作，相应的，独享锁就是整个文件就是归一个线程所有，其它线程无法访问这个数据文件。一般MySQL中最快的存储引擎MyISAM，它是基于表锁定的，就是说如果一锁定的话，那么整个数据文件外部都无法访问，必须等前一个操作完成后，才能接收下一个操作，那么在这个前一个操作没有执行完成，后一个操作等待在队列里无法执行的情况叫做阻塞，一般我们通俗意义上叫做“锁表”。

锁表直接导致的后果是什么？就是大量的SQL无法立即执行，必须等队列前面的SQL全部执行完毕才能继续执行。这个无法执行的SQL就会导致没有结果，或者延迟严重，影响用户体验。

特别是对于一些使用比较频繁的表，比如SNS系统中的用户信息表、论坛系统中的帖子表等等，都是访问量大很大的表，为了保证数据的快速提取返回给用户，必须使用一些处理方式来解决这个问题，这个就是我今天要聊到的分表技术。

分表技术顾名思义，就是把若干个存储相同类型数据的表分成几个表分表存储，在提取数据的时候，不同的用户访问不同的表，互不冲突，减少锁表的几率。比如，目前保存用户分表有两个表，一个是user_1表，还有一个是 user_2 表，两个表保存了不同的用户信息，user_1 保存了前10万的用户信息，user_2保存了后10万名用户的信息，现在如果同时查询用户 heiyeluren1 和 heiyeluren2 这个两个用户，那么就是分表从不同的表提取出来，减少锁表的可能。

我下面要讲述的两种分表方法我自己都没有实验过，不保证准确能用，只是提供一个设计思路。下面关于分表的例子我假设是在一个贴吧系统的基础上来进行处理和构建的。（如果没有用过贴吧的用户赶紧Google一下）

二、基于基础表的分表处理

这个基于基础表的分表处理方式大致的思想就是：一个主要表，保存了所有的基本信息，如果某个项目需要找到它所存储的表，那么必须从这个基础表中查找出对应的表名等项目，好直接访问这个表。如果觉得这个基础表速度不够快，可以完全把整个基础表保存在缓存或者内存中，方便有效的查询。

我们基于贴吧的情况，构建假设如下的3张表：

1. 贴吧版块表: 保存贴吧中版块的信息

2. 贴吧主题表：保存贴吧中版块中的主题信息，用于浏览

3. 贴吧回复表：保存主题的原始内容和回复内容

“贴吧版块表”包含如下字段：

版块ID board_id int(10)

版块名称 board_name char(50)

子表ID table_id smallint(5)

产生时间 created datetime

“贴吧主题表”包含如下字段：

主题ID topic_id int(10)

主题名称 topic_name char(255)

版块ID board_id int(10)

创建时间 created datetime

“贴吧回复表”的字段如下：

回复ID reply_id int(10)

回复内容 reply_text text

主题ID topic_id int(10)

版块ID board_id int(10)

创建时间 created datetime

那么上面保存了我们整个贴吧中的表结构信息，三个表对应的关系是：

版块 --> 多个主题

主题 --> 多个回复

那么就是说，表文件大小的关系是：

版块表文件 < 主题表文件 < 回复表文件

所以基本可以确定需要对主题表和回复表进行分表，已增加我们数据检索查询更改时候的速度和性能。

看了上面的表结构，会明显发现，在“版块表”中保存了一个"table_id"字段，这个字段就是用于保存一个版块对应的主题和回复都是分表保存在什么表里的。

比如我们有一个叫做“PHP”的贴吧，board_id是1，子表ID也是1，那么这条记录就是：

board_id | board_name | table_id | created

1 | PHP | 1 | 2007-01-19 00:30:12

相应的，如果我需要提取“PHP”吧里的所有主题，那么就必须按照表里保存的table_id来组合一个存储了主题的表名称，比如我们主题表的前缀是“topic_”，那么组合出来“PHP”吧对应的主题表应该是：“topic_1”，那么我们执行：

Select * FROM topic_1 Where board_id = 1 orDER BY topic_id DESC LIMIT 10

这样就能够获取这个主题下面回复列表，方便我们进行查看，如果需要查看某个主题下面的回复，我们可以继续使用版块表中保存的“table_id”来进行查询。比如我们回复表的前缀是“reply_”，那么就可以组合出“PHP”吧的ID为1的主题的回复：

Select * FROM reply_1 Where topic_id = 1 orDER BY reply_id DESC LIMIT 10

这里，我们能够清晰的看到，其实我们这里使用了基础表，基础表就是我们的版块表。那么相应的，肯定会说：基础表的数据量大了以后如何保证它的速度和效率？

当然，我们就必须使得这个基础表保持最好的速度和性能，比如，可以采用MySQL的内存表来存储，或者保存在内存当中，比如Memcache之类的内存缓存等等，可以按照实际情况来进行调整。

一般基于基础表的分表机制在SNS、交友、论坛等Web2.0网站中是个比较不错的解决方案，在这些网站中，完全可以单独使用一个表来来保存基本标识和目标表之间的关系。使用表保存对应关系的好处是以后扩展非常方便，只需要增加一个表记录。

【优势】增加删除节点非常方便，为后期升级维护带来很大便利

【劣势】需要增加表或者对某一个表进行操作，还是无法离开数据库，会产生瓶颈

三、基于 Hash 算法的分表处理

我们知道Hash表就是通过某个特殊的Hash算法计算出的一个值，这个值必须是惟一的，并且能够使用这个计算出来的值查找到需要的值，这个叫做哈希表。

我们在分表里的hash算法跟这个思想类似：通过一个原始目标的ID或者名称通过一定的hash算法计算出数据存储表的表名，然后访问相应的表。

继续拿上面的贴吧来说，每个贴吧有版块名称和版块ID，那么这两项值是固定的，并且是惟一的，那么我们就可以考虑通过对这两项值中的一项进行一些运算得出一个目标表的名称。

现在假如我们针对我们这个贴吧系统，假设系统最大允许1亿条数据，考虑每个表保存100万条记录，那么整个系统就不超过100个表就能够容纳。按照这个标准，我们假设在贴吧的版块ID上进行hash，获得一个key值，这个值就是我们的表名，然后访问相应的表。

我们构造一个简单的hash算法：

function get_hash($id){

$str = bin2hex($id);

$hash = substr($str, 0, 4);

if (strlen($hash)<4){

$hash = str_pad($hash, 4, "0");

}

return $hash;

}

算法大致就是传入一个版块ID值，然后函数返回一个4位的字符串，如果字符串长度不够，使用0进行补全。

比如：get_hash(1)，输出的结果是“3100”，输入：get_hash(23819)，得到的结果是：3233，那么我们经过简单的跟表前缀组合，就能够访问这个表了。那么我们需要访问ID为1的内容时候哦，组合的表将是：topic_3100、reply_3100，那么就可以直接对目标表进行访问了。

当然，使用hash算法后，有部分数据是可能在同一个表的，这一点跟hash表不同，hash表是尽量解决冲突，我们这里不需要，当然同样需要预测和分析表数据可能保存的表名。

如果需要存储的数据更多，同样的，可以对版块的名字进行hash操作，比如也是上面的二进制转换成十六进制，因为汉字比数字和字母要多很多，那么重复几率更小，但是可能组合成的表就更多了，相应就必须考虑一些其它的问题。

归根结底，使用hash方式的话必须选择一个好的hash算法，才能生成更多的表，然数据查询的更迅速。

【 优点hash算法直接得出目标表名称，效率很高 】通过

【劣势】扩展性比较差，选择了一个hash算法，定义了多少数据量，以后只能在这个数据量上跑，不能超过过这个数据量，可扩展性稍差

四、其它问题

1. 搜索问题

现在我们已经进行分表了，那么就无法直接对表进行搜索，因为你无法对可能系统中已经存在的几十或者几百个表进行检索，所以搜索必须借助第三方的组件来进行，比如Lucene作为站内搜索引擎是个不错的选择。

2. 表文件问题

我们知道MySQL的MyISAM引擎每个表都会生成三个文件，*.frm、*.MYD、*.MYI 三个文件，分表用来保存表结构、表数据和表索引。Linux下面每个目录下的文件数量最好不要超过1000个，不然检索数据将更慢，那么每个表都会生成三个文件，相应的如果分表超过300个表，那么将检索非常慢，所以这时候就必须再进行分，比如在进行数据库的分离。

使用基础表，我们可以新增加一个字段，用来保存这个表保存在什么数据。使用Hash的方式，我们必须截取hash值中第几位来作为数据库的名字。这样，完好的解决这个问题。

五、总结

在大负载应用当中，数据库一直是个很重要的瓶颈，必须要突破，本文讲解了两种分表的方式，希望对很多人能够有启发的作用。当然，本文代码和设想没有经过任何代码测试，所以无法保证设计的完全准确实用，具体还是需要读者在使用过程当中认真分析实施。

colys 2007-09-18 09:51 发表评论

非递归遍历文件夹

colys — Tue, 18 Sep 2007 01:39:00 GMT

///

/// 非递归遍历文件夹
///

    public class UnRecursionDirectoryReader
    {
        public event UnRecursionRead OnUnRecursionItemRead;
        public event UnRecursionRead OnUnRecursionDequeue;
        public event UnRecursionRead OnUnRecursionEnqueue;

        public void Read(string Path)
        {
            string P_Path = Path;
            Queue<string> source = new Queue<string>();
            bool IsHasChild = true;//是否有子文件夹
            while (IsHasChild)
            {
                string[] Directorys = System.IO.Directory.GetDirectories(P_Path);
                string[] Files = System.IO.Directory.GetFiles(P_Path);
                foreach (string dir in Directorys)
                {
                    source.Enqueue(dir); //入队列,开始访问文件夹
                    if (OnUnRecursionEnqueue != null) OnUnRecursionEnqueue(dir, P_Path);
                }
                foreach (string file in Files)
                {
                    if (OnUnRecursionItemRead != null) OnUnRecursionItemRead(file, P_Path); //访问文件
                }
                if (source.Count > 0)
                {
                    string OldPath = P_Path;
                    P_Path = source.Dequeue();//出队列,更换文件夹
                    if (OnUnRecursionDequeue != null) OnUnRecursionDequeue(P_Path, OldPath);
                }
                else
                {
                    IsHasChild = false;
                }
            }
        }
    }

demo:

TreeNode TargetNode = null; //指向treeview的结点
    Queue<TreeNode> TreeQueue = new Queue<TreeNode>(); //临时存放

        private void read()
    {
           CYS.UnRecursionDirectoryReader TreeReader = new CYS.UnRecursionDirectoryReader();
            TreeReader.OnUnRecursionDequeue+=new CYS.UnRecursionRead(TreeReader_OnUnRecursionDequeue);
            TreeReader.OnUnRecursionEnqueue+=new CYS.UnRecursionRead(TreeReader_OnUnRecursionEnqueue);
            TreeReader.OnUnRecursionItemRead+=new CYS.UnRecursionRead(TreeReader_OnUnRecursionItemRead);
            TreeReader.Read(AppRoot);
        }

        private void TreeReader_OnUnRecursionItemRead(string DireName, string Parent)
        {
            TargetNode.Nodes.Add(System.IO.Path.GetFileName(DireName));
        }

        private void TreeReader_OnUnRecursionDequeue(string DireName, string Parent)
        {
            TargetNode = TreeQueue.Dequeue();
        }

        private void TreeReader_OnUnRecursionEnqueue(string DireName, string Parent)
        {
            TreeNode Node = new TreeNode(System.IO.Path.GetFileName(DireName));
            TargetNode.Nodes.Add(Node);
            TreeQueue.Enqueue(Node);
        }

colys 2007-09-18 09:39 发表评论

如何获得数据库里所有表的名字（SQL+C#）

colys — Fri, 24 Aug 2007 01:34:00 GMT

平时我们操作比较多的都是表里的数据，也许突然有一天会需要把所有表的名字都列出来看一看——比如，你的论坛是按每个版块一个表来管理的，这时候你要在首页列出各版块的名字。应该怎么办呢？

肯定得用SELECT吧……但我们平时使用SELECT操作的数据都是表里的数据，表的名字并不是表的数据，这可怎么办呢？

你可能会想：“功能强大的SQL Server不会连这么简单的功能都实现不了吧？一定会把所有表的名字存储在某个表里……”注意啦！在这儿我要小小地偷换一下概念了——视图（View）也算是一种“表”，只不过它是由固定查询形成的一种“虚拟表”。

OK，你猜对啦！由SQL Server管理的每个数据库里都有一个名为sysobjects的视图，它是system级别的，所以它的全限定名是——sys.sysobjects

你可能又会问：“为什么不是sys.tables而是sys.objects呢？”问的好！因为这张表里存储的可不光是数据库里的表，它存储的是一个数据库中所有的“对象”——杂七杂八包括了表的主键、存储过程、触发器等等，一共是24种——表（Table，确切地说是“用户自定义表”）只是这24种对象中的一种。

剩下的事情……吼吼……

执行下面的查询语句，可以得到所有包含在sys.sysobjects视图里的数据

USE AdventureWorks
SELECT *
FROM sys.sysobjects
GO

得出数据后，请注意名为type的列——这一列标明了对象的类型，也就是前面提到的24种。在这里，我用一个表格把它们列出来：

AF = Aggregate function (CLR)

C = CHECK constraint

D = DEFAULT (constraint or stand-alone)

F = FOREIGN KEY constraint

FN = SQL scalar function

FS = Assembly (CLR) scalar function

FT = Assembly (CLR) table-valued function

IF = SQL inline table-valued function

IT = Internal table

P = SQL stored procedure

PC = Assembly (CLR) stored procedure

PK = PRIMARY KEY constraint

R = Rule (old-style, stand-alone)

RF = Replication-filter-procedure

S = System base table

SN = Synonym

SQ = Service queue

TA = Assembly (CLR) DML trigger

TF = SQL table-valued-function

TR = SQL DML trigger

U = Table (user-defined)

UQ = UNIQUE constraint

V = View

X = Extended stored procedure

OK，我们要得到名称的表（用户自定义表）就是类型为“U”的对象；而sys.objects的类型为“S”。所以，为了达到我们的最终目的，SQL语句应该是——

USE AdventureWorks
SELECT name
FROM sys.sysobjects
WHERE type='U'
GO

下面我再给出一段用C#实现的代码：

1//========<水之真谛>========//
2//====<以人为本，关注民生>====//
3//   http://blog.csdn.net/FantasiaX   //
4using System;
5using System.Data.SqlClient;
6
7namespace SqlSample
8{
9         class Program
10         {
11                   static void Main(string[] args)
12                   {
13                            string connectionString = @"Server=(local); Database=AdventureWorks; User ID=sa; Password=password";
14                            SqlConnection connection = new SqlConnection();
15                            connection.ConnectionString = connectionString;
16
17                            string sqlCommandString = @"USE AdventureWorks SELECT name FROM sys.sysobjects WHERE type='U' ORDER BY name";
18                            SqlCommand command = new SqlCommand();
19                            command.CommandType = System.Data.CommandType.Text;
20                            command.CommandText = sqlCommandString;
21                            command.Connection = connection;
22                            connection.Open();
23
24                            SqlDataReader reader = command.ExecuteReader();
25                            while (reader.Read())
26                            {
27                                     Console.WriteLine(reader[@"name"]);
28                            }
29                   }
30         }
31}
32

运行后得到的截图是：

colys 2007-08-24 09:34 发表评论

两个 DataTable 删改的算法

colys — Tue, 12 Jun 2007 15:53:00 GMT

/*

  已知 DataTable (first和 second) , 两个DataTable中都有一列 ID,并且值唯一

  要求:组织一个新的DataTable ,满足以下:
       如果 first 存在于 second 中则更新first的Name列为second的Name
       如果不存在则删除该行
       如果 second 的行不存在于first 就添加到 first中

*/
using System;
using System.Collections;
using System.Text;
using System.Data;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Demo d = new Demo();
            d.Run();
        }
    }

    class Demo
    {
        DataTable first, second;

        public void Run()
        {
            int i, j;
            first = new DataTable();
            first.Columns.Add("ID");
            first.Columns.Add("Name");
            DataRow dr;
            for (i = 1; i < 100; i++)
            {
                dr = first.NewRow();
                dr[0] = i;
                dr[1] = i;
                first.Rows.Add(dr);
            }
            Console.Write("\n\nold first:\n");
            foreach (DataRow outRow in first.Rows)
            {
                Console.Write(outRow[0].ToString() + "  |  " + outRow[1].ToString() + "\n");
            }

            second = first.Clone();
            this.AddToSecond(1, 00001);
            this.AddToSecond(2, 20000);
            this.AddToSecond(5, 55555);
            this.AddToSecond(100,00100);
            this.AddToSecond(150, 00150);
            Console.Write("\n\nold second:\n");
            foreach (DataRow outRow in second.Rows)
            {
                Console.Write(outRow[0].ToString() + "  |  " + outRow[1].ToString() + "\n");
            }
            int len1 = first.Rows.Count;
            int len2 = second.Rows.Count;
            ArrayList DeleteRows = new ArrayList();
            ArrayList NewRows = new ArrayList();
            for (i = 0, j = 0; i < len1 && j < len2; )
            {
                string se = second.Rows[j][0].ToString();
                string fi = first.Rows[i][0].ToString();
                int compar = se.CompareTo(fi);
                if (compar > 0) //second > first
                {
                    DeleteRows.Add(i++);//已经删除的
                }
                else if (compar == 0)
                {
                    first.Rows[i][1] = second.Rows[j][1].ToString() + "(修改)";
                    i++;
                    j++;
                }
                else
                {
                    NewRows.Add(j++); //新加的
                }
            }
            if (i < len1)
            {
                //如果第一个没有遍历完,说明剩下的都是要删除的
                for (; i < len1; i++)
                {
                    DeleteRows.Add(i);
                }
            }
            else if (j < len2)
            {
                //如果第二个没有遍历完,说明剩下的都是要添加的
                for (; j < len2; j++)
                {
                    NewRows.Add(j);
                }
            }
            //delete
            int[] DeleteArray = (int[])DeleteRows.ToArray(typeof(int));
            i = DeleteArray.Length - 1;
            while (i > -1)
            {
                //从后面开始删
                first.Rows.RemoveAt(DeleteArray[i]);
                i--;
            }

            //add new
            int[] NewArray = (int[])NewRows.ToArray(typeof(int));
            for (i = 0; i < NewArray.Length; i++)
            {
                DataRow drNew = first.NewRow();
                drNew[0] = second.Rows[NewArray[i]][0];
                drNew[1] = second.Rows[NewArray[i]][1].ToString() + "(新增)";
                first.Rows.Add(drNew);
            }
            Console.Write("\n\nresult second:\n");
            foreach (DataRow outRow in first.Rows)
            {
                Console.Write(outRow[0].ToString() + "  |  " + outRow[1].ToString() + "\n");
            }
            Console.Read();
        }

        private void AddToSecond(object text1, object text2)
        {
            DataRow dr24 = second.NewRow();
            dr24[0] = text1;
            dr24[1] = text2;
            second.Rows.Add(dr24);
        }
    }
}

colys 2007-06-12 23:53 发表评论

c#时间格式化字符串详解

colys — Fri, 08 Jun 2007 08:29:00 GMT

有时候我们要对时间进行转换,达到不同的显示效果
默认格式为:2005-6-6 14:33:34
如果要换成成200506,06-2005,2005-6-6或更多的该怎么办呢
我们要用到:DateTime.ToString的方法(String, IFormatProvider)

using System;
using System.Globalization;
String format="D";
DateTime date=DataTime,Now;
Response.Write(date.ToString(format, DateTimeFormatInfo.InvariantInfo));
结果输出
Thursday, June 16, 2005

参数format格式详细用法
格式字符关联属性/说明
d ShortDatePattern -----08/30/2006
D LongDatePattern -----Wednesday, 30 August 2006
f 完整日期和时间（长日期和短时间） -----Wednesday, 30 August 2006 23:21
F FullDateTimePattern（长日期和长时间） -----Wednesday, 30 August 2006 23:22:02
g 常规（短日期和短时间） -----08/30/2006 23:22
G 常规（短日期和长时间） -----08/30/2006 23:23:11
m、M MonthDayPattern
r、R RFC1123Pattern
s 使用当地时间的 SortableDateTimePattern（基于 ISO 8601）
t ShortTimePattern ------23:24
T LongTimePattern -------23:24:30
u UniversalSortableDateTimePattern 用于显示通用时间的格式 -------2006-08-30 23:25:10Z
U 使用通用时间的完整日期和时间（长日期和长时间） -----Wednesday, 30 August 2006 15:25:37
y、Y YearMonthPattern

下表列出了可被合并以构造自定义模式的模式。这些模式是区分大小写的；例如，识别“MM”，但不识别“mm”。如果自定义模式包含空白字符或用单引号括起来的字符，则输出字符串页也将包含这些字符。未定义为格式模式的一部分或未定义为格式字符的字符按其原义复制。

格式模式说明
d 月中的某一天。一位数的日期没有前导零。
dd 月中的某一天。一位数的日期有一个前导零。
ddd 周中某天的缩写名称，在 AbbreviatedDayNames 中定义。
dddd 周中某天的完整名称，在 DayNames 中定义。
M 月份数字。一位数的月份没有前导零。
MM 月份数字。一位数的月份有一个前导零。
MMM 月份的缩写名称，在 AbbreviatedMonthNames 中定义。
MMMM 月份的完整名称，在 MonthNames 中定义。
y 不包含纪元的年份。如果不包含纪元的年份小于 10，则显示不具有前导零的年份。
yy 不包含纪元的年份。如果不包含纪元的年份小于 10，则显示具有前导零的年份。
yyyy 包括纪元的四位数的年份。
gg 时期或纪元。如果要设置格式的日期不具有关联的时期或纪元字符串，则忽略该模式。
h 12 小时制的小时。一位数的小时数没有前导零。
hh 12 小时制的小时。一位数的小时数有前导零。
H 24 小时制的小时。一位数的小时数没有前导零。
HH 24 小时制的小时。一位数的小时数有前导零。
m 分钟。一位数的分钟数没有前导零。
mm 分钟。一位数的分钟数有一个前导零。
s 秒。一位数的秒数没有前导零。
ss 秒。一位数的秒数有一个前导零。
f 秒的小数精度为一位。其余数字被截断。
ff 秒的小数精度为两位。其余数字被截断。
fff 秒的小数精度为三位。其余数字被截断。
ffff 秒的小数精度为四位。其余数字被截断。
fffff 秒的小数精度为五位。其余数字被截断。
ffffff 秒的小数精度为六位。其余数字被截断。
fffffff 秒的小数精度为七位。其余数字被截断。
t 在 AMDesignator 或 PMDesignator 中定义的 AM/PM 指示项的第一个字符（如果存在）。
tt 在 AMDesignator 或 PMDesignator 中定义的 AM/PM 指示项（如果存在）。
z 时区偏移量（“+”或“-”后面仅跟小时）。一位数的小时数没有前导零。例如，太平洋标准时间是“-8”。
zz 时区偏移量（“+”或“-”后面仅跟小时）。一位数的小时数有前导零。例如，太平洋标准时间是“-08”。
zzz 完整时区偏移量（“+”或“-”后面跟有小时和分钟）。一位数的小时数和分钟数有前导零。例如，太平洋标准时间是“-08:00”。
: 在 TimeSeparator 中定义的默认时间分隔符。
/ 在 DateSeparator 中定义的默认日期分隔符。
% c 其中 c 是格式模式（如果单独使用）。如果格式模式与原义字符或其他格式模式合并，则可以省略“%”字符。
\ c 其中 c 是任意字符。照原义显示字符。若要显示反斜杠字符，请使用“\\”。

只有上面第二个表中列出的格式模式才能用于创建自定义模式；在第一个表中列出的标准格式字符不能用于创建自定义模式。自定义模式的长度至少为两个字符；例如，

DateTime.ToString( "d") 返回 DateTime 值；“d”是标准短日期模式。
DateTime.ToString( "%d") 返回月中的某天；“%d”是自定义模式。
DateTime.ToString( "d ") 返回后面跟有一个空白字符的月中的某天；“d”是自定义模式。

比较方便的是,上面的参数可以随意组合,并且不会出错,多试试,肯定会找到你要的时间格式
如要得到2005年06月这样格式的时间
可以这样写:
date.ToString("yyyy年MM月", DateTimeFormatInfo.InvariantInfo)
如此类推

date.ToString("yyyy/MM/dd HH:mm:ss", DateTimeFormatInfo.InvariantInfo)

colys 2007-06-08 16:29 发表评论

c#操作excel后关闭excel.exe的方法

colys — Fri, 01 Jun 2007 03:51:00 GMT

关闭进程

C#和Asp.net下excel进程一被打开,有时就无法关闭,   尤其是website.对关闭该进程有过GC、release等方法，但这些方法并不是在所有情况下均适用。于是提出了kill   process的方法,   目前我见过的方法多是用进程创建时间筛选excel.exe进程,   然后kill 。     这样的方法是不精确的,   也是不安全的,   通过对网上一些关于Api运用文章的阅读,   我找到了更为直接精确找到这个process并kill的方法，以下就是代码
using   System.Runtime.InteropServices;

[DllImport("User32.dll",   CharSet   =   CharSet.Auto)]
public   static   extern   int   GetWindowThreadProcessId(IntPtr   hwnd,   out   int   ID);
protected   void   Button1_Click(object   sender,   EventArgs   e)
{
      Excel.ApplicationClass   excel   =   new   Microsoft.Office.Interop.Excel.ApplicationClass();
      excel.Workbooks.Open("d:\aaa.xls",   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing,   Type.Missing);
      IntPtr   t   =   new   IntPtr(excel.Hwnd);
      int   k   =   0;
      GetWindowThreadProcessId(t,   out   k);
      System.Diagnostics.Process   p   =   System.Diagnostics.Process.GetProcessById(k);
      p.Kill();
   }

以上代码百分百成功的关闭excel.exe进程
我的做法是结合两者，先释放资源，然后关闭进程。
同时网上说避免使用GC.Collect 方法 (),因为会导致整个clr进行gc，影响你的性能.所以我也没有调用GC.Collect

colys 2007-06-01 11:51 发表评论

进制介绍

colys — Wed, 25 Apr 2007 11:35:00 GMT

1. 十进制数
十进制数的两个主要特点：

⑴有十个不同的数字：0、1、2、3、4、5、6、7、8、9;

⑵逢十进一的进位法,10是十进制数的基数(进制中所用不同数字的个数)。

(1993)10=1×10³+9×10²+9×10¹+3×10⁰(每位上的系数只在0—9中取用)

2. 二进制数
二进制数的两个主要特点：

⑴有两个不同的数字：0、1;

⑵逢二进一的进位法,2是二进制数的基数。

(1011)2=1×2³+0×2²+1×2¹+1×2⁰(每位上的系数只在0、1中取用)

3. 八进制数
八进制数的两个主要特点：

⑴采用八个不同的数字：0、1、2、3、4、5、6、7;

⑵逢八进一的进位法,8是八进制数的基数。

(1725)8=1×8³+7×8²+2×8¹+5×8⁰(每位上的系数只在0—7中取用)

4. 十六进制
十六进制数的两个主要特点：

⑴有十六个不同的数字：0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F(其中后六个数字符号其值对应于十进制的10,11,12,13,14,15；也有选用S,T,U,V,W,X的记法);

⑵逢十六进一的进位法,16是十六进制数的基数。

(B56E)16=B×16³+5×16²+6×16¹+E×16⁰=11×163+5×162+6×161+14×160

二进制换算为十六进制是这样:

先把二进制从低位（也就是从右到左）按四位一组分开，分到最后不够四位的也按一组来算。
分好以后再把每组的二进制换算成十六进制，之后再接换算好的组合起来就可以了。

如： 1101110111010

分组后是: 1，1011，1011，1010

每组换算成十六进制是1，B,B,A 组合是1BBA

colys 2007-04-25 19:35 发表评论

Asp.net2.0水晶报表的一些示例源码

colys — Sat, 21 Apr 2007 07:11:00 GMT

最近关注了一下Asp.net2.0中水晶报表的资料，发现示例少之又少（怀疑是水晶报表免费的比较少的缘故），搜集到了Asp.net官方的许多示例源码，试了几个还不错，这里发给大家分享一下（我仅把Asp.net C#部分提出来了）

环境VS2005+ACCESS

这些例子实现了水晶报表的查看、柱状图显示、打印、导出、缩放等基本功能，如果想了解更多比如说利用DataSet方式、Push、Pull等模式需要自己更深一步的研究了

由于其中源码太多，51aspx仅仅进行了部分调测，一些配置文件请自行更改

代码打包下载

51aspx.com 2007-04-21 15:11 发表评论

colys 2007-04-21 15:11 发表评论

Asp.net无刷新中文验证码调试成功，特分享给大家

colys — Sat, 21 Apr 2007 03:22:00 GMT

以前在网上找到了很多关于中文验证码的文章（园子里也有，大家自己去找吧），但是都没有调测成功，总出现
The target '__Page' for the callback could not be found or did not implement ICallbackEventHandler不能ICallbackEventHandler回掉的错误，我进行了一下修正并整理，现在可以实现了中文验证码无刷新的操作，现特把全部源码分享给大家

核心源码

1    public partial class Image : System.Web.UI.Page
2    {
3    protected void Page_Load(object sender, EventArgs e)
4    {
5        CreateCheckCodeImage(GenCode(4));
6    }
7    /**////

8 /// '产生随机字符串
9 ///

10    /// 随机出几个字符
11    /// 随机出的字符串
12    private string GenCode(int num)
13    {
14        string str = "的一是在不了有和人这中大为上个国我以要他时来用们...";
15        char[] chastr = str.ToCharArray();
16
17        string code = "";
18        Random rd = new Random();
19        int i;
20        for (i = 0; i < num; i++)
21        {
22            //code += source[rd.Next(0, source.Length)];
23            code += str.Substring(rd.Next(0, str.Length), 1);
24        }
25        return code;
26
27    }
28
29    /**////

30 /// 生成图片（增加背景噪音线、前景噪音点）
31 ///

32    /// 随机出字符串
33    private void CreateCheckCodeImage(string checkCode)
34    {
35        if (checkCode.Trim() == "" || checkCode == null)
36            return;
37        Session["Code"] = checkCode; //将字符串保存到Session中，以便需要时进行验证
38        System.Drawing.Bitmap image = new System.Drawing.Bitmap((int)(checkCode.Length * 21.5), 22);
39        Graphics g  = Graphics.FromImage(image);
40        try
41        {
42            //生成随机生成器
43            Random random = new Random();
44
45            //清空图片背景色
46            g.Clear(Color.White);
47
48            // 画图片的背景噪音线
49            int i;
50            for (i = 0; i < 25; i++)
51            {
52                int x1 = random.Next(image.Width);
53                int x2 = random.Next(image.Width);
54                int y1 = random.Next(image.Height);
55                int y2 = random.Next(image.Height);
56                g.DrawLine(new Pen(Color.Silver), x1, y1, x2, y2);
57            }
58
59            Font font = new System.Drawing.Font("Arial", 12, (System.Drawing.FontStyle.Bold));
60            System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(new Rectangle(0, 0, image.Width, image.Height), Color.Blue, Color.DarkRed, 1.2F, true);
61            g.DrawString(checkCode, font, brush, 2, 2);
62
63            //画图片的前景噪音点
64            g.DrawRectangle(new Pen(Color.Silver), 0, 0, image.Width - 1, image.Height - 1);
65            System.IO.MemoryStream ms = new System.IO.MemoryStream();
66            image.Save(ms, System.Drawing.Imaging.ImageFormat.Gif);
67            Response.ClearContent();
68            Response.ContentType = "image/Gif";
69            Response.BinaryWrite(ms.ToArray());
70
71        }
72        catch
73        {
74            g.Dispose();
75            image.Dispose();
76        }
77
78    }

希望该源码只是一个抛砖引玉的作用，你可以进行修改，比如说改中文字库，字体背景噪音等等
默认帐号密码均为51aspx，这里用户登录只是一个验证的例子，没有其他功能

作者51aspx
完整源码下载地址http://www.51aspx.com/CV/ZhongWenYanZhengMa

51aspx.com 2007-04-21 11:22 发表评论

colys 2007-04-21 11:22 发表评论

多文件上传示例源码(默认支持各种类型，包括图片)

colys — Tue, 10 Apr 2007 03:45:00 GMT

前几天在园子里发布了一个图片上传(加水印、缩略图、远程保存）的简单例子，很受大家的欢迎，这类再发布一个多文件上传示例源码(默认支持各种类型，包括图片)的例子，可以同时批量上传文件（包括图片）

网上包括园子里有很多多文件上传的例子，但是没有完整的示例代码，本人整理了一下发布出来，这样更直观，希望对大家有所帮助

开发环境VS2005

下载该源码

部分源码

public partial class _Default : System.Web.UI.Page
    {
        static public ArrayList hif = new ArrayList(); // 保存文件列表
        public int filesUploaded = 0; // 上传文件的数量

        protected void Page_Load(object sender, EventArgs e)
        {

        }
       ///

/// 将要上传的文件添加到listbox中
///

       ///
       ///

        protected void AddFile_Click(object sender, EventArgs e)
        {
            if (Page.IsPostBack == true)
            {
                hif.Add(FindFile);
                FileList.Items.Add(FindFile.PostedFile.FileName);
            }
            else
            { }

        }

        ///

/// 从listbox中删除指定的文件
///

        ///
        ///
        protected void RemvFile_Click(object sender, EventArgs e)
        {
            if (FileList.SelectedIndex == -1)
            {
                TipInfo.Text = "错误 - 必须指定要删除的文件.";
                return;
            }
            else if (FileList.Items.Count != 0)
            {
                hif.RemoveAt(FileList.SelectedIndex);
                FileList.Items.Remove(FileList.SelectedItem.Text);
                TipInfo.Text = "";
            }

        }

          ///

/// 循环上传listbox中的文件到指定的文件夹下
///

  ///
  ///
        public void Upload_ServerClick(object sender, System.EventArgs e)
        {
            string baseLocation = Server.MapPath("UploadFiles/"); // 上传路径
            string status = "";  // 上传成功后显示的文件列表

            if ((FileList.Items.Count == 0) && (filesUploaded == 0))
            {
                TipInfo.Text = "错误 - 必须指定要上传的文件.";
                return;
            }
            else
            {
                foreach (System.Web.UI.HtmlControls.HtmlInputFile HIF in hif)
                {
                    try
                    {
                        string fn = System.IO.Path.GetFileName(HIF.PostedFile.FileName);
                        HIF.PostedFile.SaveAs(baseLocation + fn);
                        filesUploaded++;
                        status += fn + "
";
                    }
                    catch (Exception err)
                    {
                        TipInfo.Text = "上传错误 " + baseLocation
                         + "
" + err.ToString();
                    }
                }

                if (filesUploaded == hif.Count)
                {
                    TipInfo.Text = "共上传了 " + filesUploaded + " 个文件。
" + status;
                }
                hif.Clear();
                FileList.Items.Clear();
            }

        }
    }

51aspx.com 2007-04-10 11:45 发表评论

colys 2007-04-10 11:45 发表评论

JavaScript与C# Windows应用程序交互

colys — Sun, 18 Mar 2007 06:06:00 GMT

一、建立网页

1 <html>
2 <head>
3        <meta http-equiv="Content-Language" content="zh-cn">
4        <script language="javascript" type="text/javascript">
5               
6              function messageBox(message)
7              {
8                     alert(message);
9              }
10        script>
11 head>
12
13 <body>
14        
15        <button onclick="window.external.MyMessageBox('javascript访问C#代码')" >
16        javascript访问C#代码button>
17 body>
18 html>

二、建立Windows应用程序

1. 创建Windows应用程序项目

2. 在Form1窗体中添加WebBrowser控件

3. 在Form1类的上方添加

[System.Runtime.InteropServices.ComVisibleAttribute(true)]

这是为了将该类设置为com可访问。如果不进行该声明将会出错。出错信息如下图所示：

如：

[System.Runtime.InteropServices.ComVisibleAttribute(true)]

publicpartialclassForm1 : Form

4．初始化WebBrowser的Url与ObjectForScripting两个属性。

Url属性：WebBrowser控件显示的网页路径

ObjectForScripting属性：该对象可由显示在WebBrowser控件中的网页所包含的脚本代码访问。

将Url属性设置为需要进行操作的页的URL路径。

JavaScript通过window.external调用C#公开的方法。即由ObjectForScripting属性设置的类的实例中所包含的公共方法。具体设置例子如下：

System.IO.FileInfo file = new System.IO.FileInfo("index.htm");

// WebBrowser控件显示的网页路径

webBrowser1.Url = newUri(file.FullName);

// 将当前类设置为可由脚本访问

webBrowser1.ObjectForScripting = this;

5．C#调用JavaScript方法

通过WebBrowser类的Document属性中的InvokeScript方法调用当前网页的Javascript方法。如：

// 调用JavaScript的messageBox方法，并传入参数

object[] objects = newobject[1];

objects[0] = "C#访问JavaScript脚本";

webBrowser1.Document.InvokeScript("messageBox", objects);

完整代码如下：

1 [System.Runtime.InteropServices.ComVisibleAttribute(true)]
2
3 public partial class Form1 : Form
4
5 {
6
7     public Form1()
8
9     {
10
11         InitializeComponent();
12
13         System.IO.FileInfo file = new System.IO.FileInfo("index.htm");
14
15         // WebBrowser控件显示的网页路径
16
17         webBrowser1.Url = new Uri(file.FullName);
18
19         // 将当前类设置为可由脚本访问
20
21         webBrowser1.ObjectForScripting = this;
22
23     }
24
25
26
27     private void button1_Click(object sender, EventArgs e)28
29     {
30
31         // 调用JavaScript的messageBox方法，并传入参数
32
33         object[] objects = new object[1];
34
35         objects[0] = "C#访问JavaScript脚本";
36
37         webBrowser1.Document.InvokeScript("messageBox", objects);
38
39     }
40
41     // 提供给JavaScript调用的方法
42
43     public void MyMessageBox(string message)44
45     {
46
47         MessageBox.Show(message);
48     }
49 }
50

colys 2007-03-18 14:06 发表评论