@StartIndex为当前页起始序号，@EndIndex为当前页结束记录序号，可以直接作为参数输入，也可以通过输入PageSize和PageIndex计算得出

select * from
(
select *,row_number() over(order by OrderColumn) as orderindex from TableName
) as a
where a.orderindex between @StartIndex and @EndIndex

   }

ASCII码转字符：

public static string Chr(int asciiCode)
   {
    if (asciiCode >= 0 && asciiCode <= 255)
    {
     System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding();
     byte[] byteArray = new byte[] { (byte)asciiCode };
     string strCharacter = asciiEncoding.GetString(byteArray);
     return (strCharacter);
    }
    else
    {
     throw new Exception("ASCII Code is not valid.");
    }
   }

可以在where语句中填写要查询指定表的名称,将显示指定的结构信息和说明

/// <summary>
/// 数据缓存保存信息异步处理委托
/// </summary>
delegate void EventSaveCache(object key, object value);
/// <summary>
/// 对象缓存类
/// </summary>
public class Cache
{
     private MappingContainer mContainer;
     /// <summary>
     /// 获取或设置当前缓存对象所在的关系映象容器
     /// </summary>
     public MappingContainer Container
     {
         get
         {
             return mContainer;
         }
         set
         {
             mContainer = value;
         }
     }
     /// <summary>
     /// 构造缓存对象
     /// </summary>
     public Cache()
     {
         //
         // TODO: 在此处添加构造函数逻辑
         //
     }
     /// <summary>
     /// 用于缓存数据的Hashtable
     /// </summary>
     protected System.Collections.Hashtable _Cache = new System.Collections.Hashtable();
     protected Object _LockObj = new object();
     /// <summary>
     /// 获取指定键值的对象
     /// </summary>
     /// <param name="key">键值</param>
     /// <returns>object</returns>
     public virtual object GetObject(object key)
     {
         if (_Cache.ContainsKey(key))
             return _Cache[key];
         return null;
     }
     /// <summary>
     /// 把对象按指定的键值保存到缓存中
     /// </summary>
     /// <param name="key">键值</param>
     /// <param name="value">保存的对象</param>
     public void SaveCaech(object key, object value)
     {
         EventSaveCache save = new EventSaveCache(SetCache);
         IAsyncResult ar = save.BeginInvoke(key, value, new System.AsyncCallback(Results), null);
     }
     private void Results(IAsyncResult ar)
     {
         EventSaveCache fd = (EventSaveCache)((AsyncResult)ar).AsyncDelegate;
         fd.EndInvoke(ar);
     }
     /// <summary>
     /// 把对象按指定的键值保存到缓存中
     /// </summary>
     /// <param name="key">键值</param>
     /// <param name="value">保存的对象</param>
     protected virtual void SetCache(object key, object value)
     {
         lock (_LockObj)
         {
             if (!_Cache.ContainsKey(key))
                 _Cache.Add(key, value);
         }
     }
     public int Count
     {
         get
         {
             return _Cache.Count;
         }
     }
     /// <summary>
     /// 在缓存中删除指定键值的对象
     /// </summary>
     /// <param name="key">键值</param>
     public virtual void DelObject(object key)
     {
         lock (_Cache.SyncRoot)
         {
             _Cache.Remove(key);
         }
     }
     /// <summary>
     /// 清除缓存中所有对象
     /// </summary>
     public virtual void Clear()
     {
         lock (_Cache.SyncRoot)
         {
             _Cache.Clear();
         }
     }
}

/// <summary>
///针对一条记录操作命令的缓存类
/// </summary>
public class CachePersistentCommand : Cache
{

     /// <summary>
     /// 把记录操作命令缓存到内存中
     /// </summary>
     /// <param name="key">标识</param>
     /// <param name="value">值</param>
     protected override void SetCache(object key, object value)
     {
         lock (_LockObj)
         {
             int count = 0;
             if (Container.Config.CommandsCache.ContainsKey(key))
                 count = (int)Container.Config.CommandsCache[key];
             System.Collections.IList _list;
             //如果缓存中已经存在这种命令的列表
             if (_Cache.ContainsKey(key))
             {
                 _list = (System.Collections.IList)_Cache[key];

                 if (count > 0)//命令的缓存总数
                 {
                     if (_list.Count < count)//缓存数据量少于缓存总数
                         _list.Add(value);
                 }
                 else
                 {
                     if (_list.Count < Container.Config.CommandBuffer)//缓存数小于组件的默认列表
                         _list.Add(value);
                 }
             }
             else//如果不存在列表
             {
                 if (count > 0 || Container.Config.CommandBuffer > 0)//如果组件允许对象缓存
                 {
                     _list = new System.Collections.ArrayList();
                     _list.Add(value);
                     _Cache.Add(key, _list);
                 }
             }
         }
     }
     /// <summary>
     /// 从缓存中获取相关命令对象
     /// </summary>
     /// <param name="key">标识</param>
     /// <returns>IPersistentCommand</returns>
     public override object GetObject(object key)
     {

         if (_Cache.Contains(key))//如果命令存在缓冲中
         {
             foreach (IPersistentCommand cmd in (System.Collections.IList)_Cache[key])
             {
                 if (!cmd.State)//命令是否可以过行锁定
                     if (cmd.Lock())//命令锁定
                         return cmd;
             }
         }
         return null;
     }

}

　　Cache["key"] = "value";　　

　　这种做法将在缓存中存储项，同时不带任何依赖项，因此它不会到期，除非缓存引擎为了给其他缓存数据提供空间而将其删除。要包括特定的缓存依赖项，可使用 Add() 或 Insert() 方法。其中每个方法都有几个重载。Add() 和 Insert() 之间的唯一区别是，Add() 返回对已缓存对象的引用，而 Insert() 没有返回值（在 C# 中为空，在 VB 中为 Sub）。　　

.NET中缓存分为为几种,在这里我介绍种较常用的缓存方式,能极大限度的提高WEB的性能. 看下面一段代码:

private static City GetCityInfo(string cityname,string citycode)
   {
    string cacheKey="City"+cityname+citycode;

    if( HttpRuntime.Cache[cacheKey]==null)
    {
     City city=null;

     SincooWapDataProvider dp=new SincooWapDataProvider(ConnInfo.Conn71NewWap);    
     city =dp.GetCityInfo(cityname,citycode);
    
     HttpRuntime.Cache.Insert(cacheKey,city,null,DateTime.Now.AddMinutes(5),TimeSpan.Zero);   
    }    
    return (City)HttpRuntime.Cache[cacheKey];
   }

代码片断中出现的

     City city=null;

     SincooWapDataProvider dp=new SincooWapDataProvider(ConnInfo.Conn71NewWap);    
     city =dp.GetCityInfo(cityname,citycode);

这是我获取的数据集及获取方式,不用管,看下面的

HttpRuntime.Cache.Insert(cacheKey,city,null,DateTime.Now.AddMinutes(5),TimeSpan.Zero);

具体的HttpRuntime.Cache.Insert()的使用方法请参考相关文档,这里不做具体介绍.

通过这种方式,就能避免重复读取数据库,提高效率,缺点是不能及时获取到信息,在频繁更新的页面不推荐!

答案：

select * from 表 where 列 not in (select 列+1 from 表) and 列>(select min(列) from 表)