博客园_陈晨

合并DataTable并排除重复数据的通用方法

2011-11-25T14:04:00Z

网上合并DataTable通用方法的文章很多，结合项目开发中的常用需求，并借鉴网上的做法，写了一个合并DataTable的通用方法，主要功能是合并两个DataTable（结构可以不同，如字段不完全一致），并可以根据某一列值进行排重处理。代码如下：

///<summary>
/// 将两个列不同的DataTable合并成一个新的DataTable
///</summary>
///<param name="dt1">源表</param>
///<param name="dt2">需要合并的表</param>
///<param name="primaryKey">需要排重列表（为空不排重）</param>
///<param name="maxRows">合并后Table的最大行数</param>
///<returns>合并后的datatable</returns>
public static DataTable MergeDataTable(DataTable dt1, DataTable dt2, string primaryKey, int maxRows)
{
//判断是否需要合并
if (dt1 == null && dt2 == null)
{
return null;
}
if (dt1 == null && dt2 != null)
{
return dt2.Copy();
}
else if (dt1 != null && dt2 == null)
{
return dt1.Copy();
}
//复制dt1的数据
DataTable dt = dt1.Copy();
//补充dt2的结构（dt1中没有的列）到dt中
for (int i = 0; i < dt2.Columns.Count; i++)
{
string cName = dt2.Columns[i].ColumnName;
if (!dt.Columns.Contains(cName))
{
dt.Columns.Add(new DataColumn(cName));
}
}
//复制dt2的数据
if (dt2.Rows.Count > 0)
{
Type t = dt2.Rows[0][primaryKey].GetType();
bool isNeedFilter = string.IsNullOrEmpty(primaryKey) ? false : true;
bool isNeedQuotes = t.Name == "String" ? true : false;
int mergeTableNum = dt.Rows.Count;
for (int i = 0; i < dt2.Rows.Count && mergeTableNum < maxRows; i++)
{
bool isNeedAdd = true;
//如果需要排重时，判断是否需要添加当前行
if (isNeedFilter)
{
string primaryValue = dt2.Rows[i][primaryKey].ToString();
string fileter = primaryKey + "=" + primaryValue;
if(isNeedQuotes)
{
fileter = primaryKey + "='" + primaryValue + "'";
}
DataRow[] drs = dt.Select(fileter);
if (drs != null && drs.Length > 0)
{
isNeedAdd = false;
}
}
//添加数据
if (isNeedAdd)
{
DataRow dr = dt.NewRow();
for (int j = 0; j < dt.Columns.Count; j++)
{
string cName = dt.Columns[j].ColumnName;
if (dt2.Columns.Contains(cName))
{
//防止因同一字段不同类型赋值出错
if (dt2.Rows[i][cName] != null && dt2.Rows[i][cName] != DBNull.Value && dt2.Rows[i][cName].ToString() != "")
{
dr[cName] = dt2.Rows[i][cName];
}
}
}
dt.Rows.Add(dr);
mergeTableNum++;
}
}
}
return dt;
}

本文链接

巧用row_number和partition by分组取top数据

2011-10-30T02:06:00Z

分组取TOP数据是T-SQL中的常用查询，如学生信息管理系统中取出每个学科前3名的学生。这种查询在SQL Server 2005之前，写起来很繁琐，需要用到临时表关联查询才能取到。SQL Server 2005后之后，引入了row_number()函数，row_number()函数的分组排序功能使这种操作变得非常简单。下面是一个简单示例：

--1.创建测试表
create table #score
(
name varchar(20),
subject varchar(20),
score int
)
--2.插入测试数据
insert into #score(name,subject,score) values('张三','语文',98)
insert into #score(name,subject,score) values('张三','数学',80)
insert into #score(name,subject,score) values('张三','英语',90)
insert into #score(name,subject,score) values('李四','语文',88)
insert into #score(name,subject,score) values('李四','数学',86)
insert into #score(name,subject,score) values('李四','英语',88)
insert into #score(name,subject,score) values('李明','语文',60)
insert into #score(name,subject,score) values('李明','数学',86)
insert into #score(name,subject,score) values('李明','英语',88)
insert into #score(name,subject,score) values('林风','语文',74)
insert into #score(name,subject,score) values('林风','数学',99)
insert into #score(name,subject,score) values('林风','英语',59)
insert into #score(name,subject,score) values('严明','英语',96)
--3.取每个学科的前3名数据
select * from
(
select subject,name,score,ROW_NUMBER() over(PARTITION by subject order by score desc) as num from #score
) T where T.num <= 3 order by subject
--4.删除临时表
truncate table #score
drop table #score

语法形式：ROW_NUMBER() OVER(PARTITION BY COL1 ORDER BY COL2)

解释：根据COL1分组，在分组内部根据 COL2排序，而此函数计算的值就表示每组内部排序后的顺序编号（组内连续的唯一的)

本文链接

小改动大效果：记一次CPU负载高问题排查和解决

2011-09-26T15:14:00Z

问题缘起：收到运维同事发来的邮件，说自上次网站更新后，CPU使用率上升趋势明显（下图中红框部分所示），但网站访问数并没有增加。

问题排查：是什么原因导致CPU使用率上升呢？肯定是某个访问量比较大的页面进行了耗CPU的操作，如文件读写、内存中的一些复杂运算等。结合上次网站更新内容，将问题锁定在了房源详情页。主要涉及到读xml文件（最大的有2M多）到DataTable中，每次打开页面时根据DataTable中的两个列值判断在这个DataTable中有没有，比较严重的是读文件没加缓存，造成了频繁的读文件，使CPU一直处于忙碌状态。

找到了问题所在，修改起来就容易多了，增加缓存就好了，下面是修改后的伪代码。修改之后更新网站，CPU使用率又恢复到正常值了（红框后面的部分）。

/// <summary>
/// 获取置业专家列表
/// </summary>
/// <returns>置业专家列表</returns>
public static DataTable GetAgentXML()
{
DataTable dt = null;
string cacheName = "agentall_zyzj";
if (CacheManager.IsCached(cacheName))
{
object o = CacheManager.GetCache(cacheName);
if (o != null)
{
dt = o as DataTable;
}
}
if (dt == null)
{
//读取xml文件到DataTable中
dt = GetAgentXMLFromFile();
if (dt != null)
{
try
{
if (dt.Rows.Count > 0)
{
dt.PrimaryKey = new DataColumn[] { dt.Columns["newcode"], dt.Columns["agentid"] };
}
}
catch
{ }
CacheManager.InsertCache(cacheName, dt, System.DateTime.Now.AddMinutes(60));
}
}
return dt;
}
/// <summary>
/// 判断是否为置业专家
/// </summary>
/// <returns>是否为置业专家</returns>
public static bool CheckZyzj(long agentID, long newCode)
{
DataTable Agentdt = new DataTable();
bool isZyzj = false;
try
{
Agentdt = GetAgentXML();
if (Agentdt != null && Agentdt.Rows.Count > 0)
{
DataRow[] drs = Agentdt.Select(" agentid=" + agentID + " and newcode=" + newCode);
if (drs != null && drs.Length > 0)
{
isZyzj = true;
}
}
}
catch (Exception ex)
{
isZyzj = false;
}
return isZyzj;
}

需要特别说明的一点，此次优化在增加缓存的同时，还做了一个小调整，将数据从xml文件读到DataTable后，为DataTable设置了主键“dt.PrimaryKey = new DataColumn[] { dt.Columns["newcode"], dt.Columns["agentid"] }”，为DataTable设置主键可以大大提高select查询效率（这点有些类似于数据库中表的主键）。因为这次修改了两个地方，增加主键的效率不好用数据说明。但之前做过一个复杂报表的生成，在内存中要对DataTable做大量查询，简单的增加主键后，效率提升了七八倍。

缓存在编程中至关重要，网站访问量小时缓存与否影响不大，一旦量上来了，再简单的逻辑也需要多考虑，平日里要多有些思想意识在里头，才会有预见性，减少上线后出现问题的几率。

本文链接

NET也不能忽略基础

2011-05-08T01:53:00Z

有时候，我们项目做多了，尤其是网站项目做多了，就会觉得基础知识好像没多大用，但殊不知，对一些基础概念理解不深，就会带来问题。整理下项目中因为基础概念理解不深造成的问题，希望能给以启发。

1.引用类型存储问题

我们知道引用类型存储在堆中，将一个引用类型赋值给另外一个引用类型时，两者指向的是同一个对象，对任何一个变量的修改都会影响到另外一个变量的值。如果单拿这句话或者是应对面试中的题目，大家理解都没问题。但落实到具体项目中，加上一些复杂的逻辑，如果对这话理解不深，就会造成一些问题。下面是项目中犯错的一个真实案例。

static void Main(string[] args)
{
RefTypeCache rtc = new RefTypeCache();
rtc.ShowDatas("B");
rtc.ShowDatas("A");
rtc.ShowDatas("B");

Console.Read();
}

public class RefTypeCache
{
/// <summary>
/// 不同类型用户操作数据
/// </summary>
public void ShowDatas(string userType)
{
DataTable dt = this.GetUserData();
//A类用户想显示下用户积分，就在新赋值的dt中加了一列积分列
if (userType == "A")
{
dt.Columns.Add("score");
Console.WriteLine("A类用户获取到的数据中有积分列：" + dt.Columns.Contains("score"));
}
//B类用户直接显示就好了，不加积分列
if (userType == "B")
{
Console.WriteLine("B类用户获取到的数据中有积分列：" + dt.Columns.Contains("score"));
}
}

/// <summary>
/// 获取数据
/// </summary>
private DataTable GetUserData()
{
DataTable dt = null;
System.Web.Caching.Cache cache = System.Web.HttpRuntime.Cache;
string cacheName = "alldata";
object o = cache.Get(cacheName);
//有缓存则从缓存种获取
if (o != null)
{
dt = o as DataTable;
}
//无缓存则初始化数据
if(dt == null)
{
dt = new DataTable();
dt.Columns.Add("id");
dt.Columns.Add("datas");
DataRow dr0 = dt.NewRow();
dr0["id"] = "1";
dr0["datas"] = "张三";
dt.Rows.Add(dr0);
DataRow dr1 = dt.NewRow();
dr1["id"] = "2";
dr1["datas"] = "李四";
dt.Rows.Add(dr1);
DataRow dr2 = dt.NewRow();
dr2["id"] = "3";
dr2["datas"] = "赵六";
dt.Rows.Add(dr2);
cache[cacheName] = dt;
}

return dt;
}
}

从上面的例子可以看出，缓存中的对象赋值给其他变量后，对赋值变量做了修改，从而改变了缓存对象的值，造成了程序的异常。

2.对象实例化

我们知道new ClassName()，就实例化了一个对象，对象中的一些变量如int型就会有默认初值。但在这稍不小心，还会出现问题。一个具体实例是这样出现的，其伪代码如下：

UserEntity user = new UserEntity(); //用户实体
BillEntity bill = new BillEntity(); //用户钱变动实体

//如果满足条件，给用户加钱，同时生成消费明细
if (condition)
{
bill.UserID = UserID;
bill.SetMoney = 5;
bill.CreateTime = DateTime.Now;
bill.Type = 0; //类型为赠送
}

//修改用户资料
UserBiz ub = new UserBiz();
ub.Update(user);
//如果有帐号变动就增加消费明细记录
//这里的问题在于以为没给bill实体赋值，就以为bill为null，
//却忽略了new BillEntity()后，已经为bill分配了内存，bill变量已经有了储值
if (bill != null)
{
BillBiz bb = new BillBiz();
bb.Add(bill);
}

上面两个例子很简单，大家可能一下子就发现问题的所在，觉得很难犯这样的错误，但这种问题是开发过程中真实存在的，如果对基础概念理解的不够，再加上复杂的逻辑，可能就会犯奇奇怪怪的错误，所以.NET基础知识还是不能忽视的。

本文链接

<img/>标签onerror事件在IE下的bug和解决方法

2011-01-12T13:14:00Z

IE下打开网页时，会弹出“Stack overflow at line: 0”的弹框。经分析，这个bug是由于img标签的onerror事件引起的。程序中用到的代码片段如下：正常情况下显示src所指路径的图片，加载失败时显示通过img标签的onerror事件显示另一张图片，问题就出现在了这里，当另一张图片也不存在时，就造成了循环触发onerror事件，在IE下就会弹出“stack overflow”的弹框。

解决的方法也很简单，在重新给img的src属性赋值时，先将onerror事件清除掉，再赋值，这样就不存在循环调用的问题了，代码段如下：

本文链接

表变量和临时表

2010-11-14T03:43:00Z

表变量存储在内存中，而临时表存储在tempdb中，会涉及到物理IO读写，那么我们是否可以由此得出结论，使用表变量要比使用临时表效率高呢？相信有一部分人会和我有同样的想法，使用表变量的效率高，真是如此吗？先从一次优化存储过程的经历说起。

存储过程涉及到两个表，一个是用户今日积分表@tableUserScore（数据源来自用户积分详情表中的今日数据)，一个是用户积分统计表UserScoreSum，该存储过程逻辑就是统计@tableUserScore中用户不同原因的积分值，生成到表UserScoreSum中。数据量不算很大，@tableUserScore中大概40万条，但这个存储过程执行时间却有些惊人，通常都在1个小时之上。优化的最终结果是将表变量@tabeUserScore换成了临时表#tableUserScore，并在userid和reason上添加了联合索引，优化的效果是执行时间控制在了40S左右。临时表和表变量效率相差百倍，这次优化经历让我对临时表和表变量有了重新认识，也有了一连串的疑问，它们是如何存储的，效率如何，如何选用？

declare @tableUserScore table(
userid int, --用户编号
name varchar(10), --用户姓名
reason varchar(32), --积分原因
score int --积分值
)

create table UserScoreSum(
userid int, --用户编号
name varchar(10), --用户姓名
createTime datetime, --时间
reason1Score int, --原因1积分值
reason2Score int, --原因2积分值
reason3Score int, --原因3积分值
reason4Score int, --原因4积分值
)

以下是个人翻阅资料后的理解，总结出来希望能给和我有同样认识的人提个醒，起到抛砖引玉的作用，也希望大家对理解错误之处提出指正。

临时表

临时表有两种类型：本地表和全局表。在与首次创建或引用表时相同的 SQL Server 实例连接期间，本地临时表只对于创建者是可见的。当用户与 SQL Server 实例断开连接后，将删除本地临时表。全局临时表在创建后对任何用户和任何连接都是可见的，当引用该表的所有用户都与 SQL Server 实例断开连接后，将删除全局临时表。本地临时表的名称都是以“#”为前缀，全局临时表的名称都是以“##”为前缀。

临时表存储在tempdb中，因此临时表的访问是有可能造成物理IO的，当然在修改时也需要生成日志来确保一致性，同时锁机制也是不可缺少的。

临时表可以创建索引，也可以定义统计数据，所以可以用数据定义语言(DDL)的声明来阻止临时表添加的限制，约束，并参照完整性，如主键和外键约束。

表变量

表变量是变量的一种，表变量也分为本地及全局的两种，本地表变量的名称都是以“@”为前缀，只有在本地当前的用户连接中才可以访问。全局的表变量的名称都是以“@@”为前缀，一般都是系统的全局变量，像我们常用到的，如@@Error代表错误的号，@@RowCount代表影响的行数。

表变量存放在内存中，正是因为这一点所有用户访问表变量的时候SQL Server是不需要生成日志。同时变量是不需要考虑其他会话访问的问题，因此也不需要锁机制，对于非常繁忙的系统来说，避免锁的使用可以减少一部分系统负载。[表变量存放在内存是有一定限制的，如果表变量数据量超过阈值，会把内存耗尽，然后使用TempDB的空间，这样主要还是使用硬盘空间，但同时把内存基本耗尽，增加了内存调入调出的机会，反而降低速度]

表变量另外还有一个限制就是不能创建索引，当然也不存在统计数据的问题，因此在用户访问表变量的时候也就不存在执行计划选择的问题了(也就是以为着编译阶段后就没有优化阶段了)，这一特性有的时候是件好事，而有些时候却会造成一些麻烦。

临时表 vs. 表变量

1.存储位置：临时表是利用了硬盘(tempdb数据库) ，表名变量是占用内存，因此小数据量当然是内存中的表变量更快。当大数据量时，就不能用表变量了，太耗内存了。大数据量时适合用临时表。

2.性能：不能一概而论，表变量存储数据有个性能临界点，在这个临界点之内，表变量比临时表快，表变量是存储在内存中的。

3.索引：表变量不支持索引和统计数据，但可以有主键；临时表则可以支持索引和统计数据。

我们对于较小的临时计算用数据集考虑使用表变量。如果数据集比较大，如果在代码中用于临时计算，同时这种临时使用永远都是简单的全数据集扫描而不需要考虑什么优化，比如说没有分组或分组很少的聚合(比如说COUNT、SUM、AVERAGE、MAX等)，也可以考虑使用表变量。使用表变量另外一个考虑因素是应用环境的内存压力，如果代码的运行实例很多，就要特别注意内存变量对内存的消耗。一般对于大的数据集我们最好使用临时表，同时创建索引。

本文链接

动态创建WebService

2010-11-07T16:40:00Z

需求背景：公司对外提供了几个WebService服务，部署在多台服务器上，WebMethod参数为XML格式，测试起来很不方便，只能由开发人员进行测试，单靠一两个人测试质量难以保证。本着对用户负责，解放开发人员的初衷，开发一个WebService的测试程序。

设计思路：首先考虑的是通过添加Web引用的方式，让.NET编译器帮我们生成服务代理，然后调用对应的Web服务，这种方式最简单，但却和Web服务的地址、方法名、参数全都绑定在了一起，如果Web服务的方法或者是参数发生改变，就需要重新添加引用，使用起来不大方便。而且，还要应对若干个站点的Web服务，都要添加Web引用（其实这个理由不成立，添加Web引用方式应对多个站点没问题，只要站点提供的Web服务相同，就可以靠动态设置Url的方式，实现调用不同站点的WebService，根本不用为每个站点都添加Web引用），很不方便，于是想到了动态创建调用WebService。

动态调用WebService的方法在园子里可以搜索到很多，看看标题看看内容，发现大多源于同一版本，这里作为知识整理记录下来，内容来自园友博客。动态调用，需要准备几个方面的知识：反射、WSDL、CodeDomProvider、编程使用编译器、泛型、WebService，具体关系参见下图，图的上半部分是动态创建调用WebService的过程，下半部分是通过添加Web引用调用WebService的过程。

实现动态创建WebService的完整代码如下，只需要调用函数public static T InvokeMethod<T>(string url, string methodName, params object[] args)传入服务地址、方法名称、参数集合即可实现动态调用Web方法。

using System;
using System.Web;
using System.Net;
using System.IO;
using System.CodeDom;
using Microsoft.CSharp;
using System.Reflection;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Web.Services.Protocols;
using System.Web.Services.Description;

namespace HIIStest.UIBase
{
/// <summary>
/// 动态调用WebService帮助类
/// </summary>
public class WebServiceHelper
{
/// <summary>
/// 调用WebService
/// </summary>
/// <typeparam name="T">方法返回值类型</typeparam>
/// <param name="url">服务网址</param>
/// <param name="methodName">方法名</param>
/// <param name="args">方法参数</param>
/// <returns>返回调用结果</returns>
public static T InvokeMethod<T>(string url, string methodName, params object[] args)
{
//设置泛型类型的默认值
T result = default(T);
//获得类型
Type t = GetType(url, GetWsClassName(url));
try
{
//依据类型创建实例
object obj = CreateInstance(t);
//调用方法
result = InvokeMethod<T>(obj, t, methodName, args);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return result;
}

/// <summary>
/// 调用WebService
/// </summary>
/// <typeparam name="T">方法返回值类型</typeparam>
/// <param name="InstanceObject">实例</param>
/// <param name="t">类的类型(Type)</param>
/// <param name="methodName">方法名</param>
/// <param name="args">方法参数</param>
/// <returns>返回调用结果</returns>
private static T InvokeMethod<T>(object InstanceObject, Type t, string methodName, params object[] args)
{
T result = default(T);
//依据方法名获取方法信息
System.Reflection.MethodInfo mi = t.GetMethod(methodName);
//调用实例方法
result = (T)mi.Invoke(InstanceObject, args);
return result;
}

/// <summary>
/// 获取类型
/// </summary>
/// <param name="url">服务网址</param>
/// <param name="className">服务类型名称</param>
/// <returns>返回Type</returns>
private static Type GetType(string url, string className)
{
Type result = null;
string @namespace = "HIIStest.UIBase.Temp.WebService";
if (string.IsNullOrEmpty(className))
{
className = WebServiceHelper.GetWsClassName(url);
}
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
//生成客户端代理类代码
CodeNamespace np = new CodeNamespace(@namespace);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(np);
sdi.Import(np, ccu);
//获取c#编译器的实例
CodeDomProvider provider = CodeDomProvider.CreateProvider("C#");
//设定编译参数
CompilerParameters param = new CompilerParameters();
param.GenerateExecutable = false;
param.GenerateInMemory = true;
param.ReferencedAssemblies.Add("System.dll");
param.ReferencedAssemblies.Add("System.XML.dll");
param.ReferencedAssemblies.Add("System.Web.Services.dll");
param.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = provider.CompileAssemblyFromDom(param, ccu);
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
//反射获取类型
result = assembly.GetType(@namespace + "." + className, true, true);
return result;
}

/// <summary>
/// 依据类型创建实例
/// </summary>
/// <param name="t">类型(Type)</param>
/// <returns>类型实例</returns>
private static object CreateInstance(Type t)
{
//获取类型的默认值
object result = null;
try
{
//创建实例类型
result = Activator.CreateInstance(t);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return result;
}

/// <summary>
/// 给实例对象属性赋值
/// </summary>
/// <param name="InstanceObject">对象实例</param>
/// <param name="valueObj">值</param>
/// <param name="t">类型</param>
/// <param name="propertyName">属性的名字</param>
private static void SetProperty(object InstanceObject, object valueObj, Type t, string propertyName)
{
//依据类型获得类型属性
System.Reflection.PropertyInfo pi = t.GetProperty(propertyName, BindingFlags.Public);
//给实例对象属性赋值
pi.SetValue(InstanceObject, valueObj, null);
}

/// <summary>
/// 获得类的名字
/// </summary>
/// <param name="url">网址</param>
/// <returns>类型名</returns>
private static string GetWsClassName(string url)
{
string result = string.Empty;
string[] parts = url.Split('/');
string fileName = parts[parts.Length - 1];
result = fileName.Split('.')[0];
return result;
}
}
}

动态调用http://www.webxml.com.cn/WebServices/WeatherWebService.asmx提供Web服务获取天气预报的示例。这个示例稍加改造，利用中移动139邮箱邮件短信提醒功能，就可以做成一个自动发送天气预报短信的小程序，感兴趣的朋友可以试试哦。

private void GetWeather()
{
string url = "http://www.webxml.com.cn/WebServices/WeatherWebService.asmx";
string methodName = "getWeatherbyCityName";
object[] args = new object[1];
args[0] = "北京";

String[] str = WebServiceHelper.InvokeMethod<String[]>(url, methodName, args);
this.message.InnerHtml = str[6] + " " + str[5] + "<br />" + str[7] + "<br />" + str[10];
}

到这，动态创建并调用WebService的问题已经解决了，这种方式不需要添加Web引用，项目中没有额外的代码，看起来很美，可当运行示例程序时，发现原来并没有想象中的美。这种方式存在什么问题呢？效率，每一次调用Web服务，都要经历获取WSDL，生成客户代理类，动态编译，调用获取数据的过程，不是一般的慢，这也是美的代价吧，而且是我们不能承受的代价。如果直接把这种方式用在项目中，肯定是不行的，一种初步的思路是利用缓存，将生成代理类缓存起来，第一次访问添加到缓存后，以后直接从内存中获取，想必可以大幅提高效率，接下来会做这方面的研究，提升效率，使这种方式具有实用性。

本文链接

网站访问量大+数据量大=>看似简单的SQL语句也会搞挂系统

2010-11-02T00:05:00Z

一个简单的SQL语句：select count(1) from tableName with(nolock) where columnA=A and columnB=B and columnC=C，被一个关键页面调用，虽然加了Memcache缓存，但由于数据结构设计问题，造成了数据库服务器CPU负载高达100%，关键页面响应超时，造成极其不好的影响。

究其原因，缺少索引，数据结构设计之初，没有为该表建立索引，而后又忽略了该表仅测试数据就达到五六百万级别，以每天25万左右的速度增长。测试时，由于没有访问量，性能问题没被发现；而上线前的压力测试，由于测试帐号只有有限的几个，而系统根据帐号增加了Memcache缓存，因此该问题又被忽略了；直到系统上线第二天，真实的用户访问量上来了，该问题才暴露无遗，客服电话很快被打爆。

为了彻底解决该问题，花费了几个工作日，血淋淋的教训。如果开发之前设计好数据结构建好索引、如果开发测试的时候关注下数据量、如果把写好的SQL语句放到查询分析器分析下性能...做设计写程序，意识不能少，开发前的设计要做到位，开发流程要把握好，否则发生杯具只能自己埋单了。

本文链接

"动软.Net代码生成器"的一次扩展经历

2010-10-01T16:51:00Z

一直很喜欢用李天平的“动软.Net代码生成器”，界面简洁、操作简单，用来开发辅助生成代码和生成Word文档，大大提高效率。唯一不喜欢的是实体层变量命名方式采用了变量用“_”+数据库字段名方式，属性名采用数据库字段名方式，个人更喜欢用变量首字母小写属性首字母大写的方式。国庆假期闲来无事，决定改造下生成实体层的方法，让其按照自己的习惯来命名，感谢李天平对代码生成器的开源，才使这次改造成为可能。

很容易就找到了实体层生成的类和方法LTP.BuilderModel.BuilderModel.CreatModelMethod()，去掉变量名前面的下划线很简单，直接删除即可，遇到的一个难题是如何把属性名的首字母变成大写，首先想到的是利用正则表达式。对正则表达式真是既爱又恨，爱是因为功能强大，处理文本问题几乎无所不能，恨是因为自己对正则表达式一直是一知半解，虽然专门学过几次，可由于求知欲不强加上悟性不够，一直没能理解正则表达式的本质，每次用到都要借助网络。这次网络没能帮助我，倒是意外的发现了用C#字符串很容易就能实现首字母大写，只要一条语句即可string propertyColumnName = columnName.Substring(0, 1).ToUpper() + columnName.Substring(1)。是自己把问题想复杂了。完整的改造代码如下：

/// <summary>
/// 生成实体类的属性
/// </summary>
/// <returns></returns>
public string CreatModelMethod()
{
StringPlus strclass = new StringPlus();
StringPlus strclass1 = new StringPlus();
StringPlus strclass2 = new StringPlus();
//strclass.AppendSpaceLine(2, "#region Model");
strclass1.AppendSpaceLine(2, "");
strclass2.AppendSpaceLine(2, "");
foreach (ColumnInfo field in Fieldlist)
{
string columnName = field.ColumnName;
string columnType = field.TypeName;
bool IsIdentity = field.IsIdentity;
bool ispk = field.IsPK;
bool cisnull = field.cisNull;
string deText = field.DeText;
columnType = CodeCommon.DbTypeToCS(columnType);
string isnull = "";
if (CodeCommon.isValueType(columnType))
{
//if ((!IsIdentity) && (!ispk) && (cisnull))
//{
// isnull = "?";//代表可空类型
//}
}
//变量直接用数据库字段名
string privateColumnName = columnName;
//属性名需要把数据库字段名首字母大写
string propertyColumnName = columnName.Substring(0, 1).ToUpper() + columnName.Substring(1);

strclass1.AppendSpaceLine(2, "private " + columnType + isnull + " " + privateColumnName + ";");//私有变量
strclass2.AppendSpaceLine(2, "/// <summary>");
strclass2.AppendSpaceLine(2, "/// " + deText);
strclass2.AppendSpaceLine(2, "/// </summary>");
strclass2.AppendSpaceLine(2, "public " + columnType + isnull + " " + propertyColumnName);//属性
strclass2.AppendSpaceLine(2, "{");
strclass2.AppendSpaceLine(3, "set {" + privateColumnName + "=value;}");
strclass2.AppendSpaceLine(3, "get {return " + privateColumnName + ";}");
strclass2.AppendSpaceLine(2, "}");
}
strclass.Append(strclass1.Value);
strclass.Append(strclass2.Value);
//strclass.AppendSpaceLine(2, "#endregion Model");

return strclass.ToString();
}

重新编译项目，将LTP.BuilderModel.dll替代原安装目录中的dll，打开代码生成器生成代码，生成的实体层变成自己习惯的命名规则了^_^。其实这次改造并不难，但有两点体会：一是开源真的很方便，可以按需修改，满足自己或者说是开发团队的需求；二是C#（语言）基础要好好掌握，不能一遇到问题就求助网络，先从基础着手解决问题，改掉思维定势。

本文链接

小心枚举陷阱

2010-07-18T03:14:00Z

枚举类型无疑给我们开发带来了很大的便利，智能感应+代码可读性就让我们有足够的理由在项目中使用。但枚举类型使用不当也存在着温柔陷阱，而且陷阱很难发现。

事情的缘起是这样的，项目A是公共基类，很多项目都会引用，项目B会引用项目A，但由于项目B使用人数不多而且功能很稳定，所以部署的时候一般不会传项目B的dll文件。但前前几天项目B突然出错了，报错的“找不到业务类型对应的数据库连接”。本地调试项目B，一点问题没有，可线上的就是出错，重新上传了项目B的dll，神奇般的好了。感觉有些莫名奇妙，一点都没改动，重新上传下dll就好了，是什么原因呢？没有无缘无故的爱，同样也没有无缘无故的错误，《温柔的枚举陷阱》一文帮我找到了答案，问题的根源是项目A中枚举类型的更改。

我们可以从下面的示例中找到答案。ProjectA是很多项目共用的基础类库，ProjectB会添加ProjectA的引用，但二者并不在一个解决方案下面，更新ProjectA时会把A的dll文件放到B的bin目录下面。

namespace ProjectA
{
/// <summary>
/// 业务类型
/// </summary>
public enum BusinessType
{
UserRead,
UserWrite,
ProductRead,
ProductWrite
}

public class DBHelper
{
/// <summary>
/// 根据业务类型获取连接字符串
/// </summary>
public static string GetConnectString(BusinessType bt)
{
string connectString = string.Empty;
switch (bt)
{
case BusinessType.UserRead:
connectString = "UserRead";
break;
case BusinessType.UserWrite:
connectString = "UserWrite";
break;
case BusinessType.ProductRead:
connectString = "ProductRead";
break;
case BusinessType.ProductWrite:
connectString = "ProductWrite";
break;
default:
connectString = "UserRead";
break;
}
return connectString;
}
}
}

项目B添加对项目A的引用后，其代码如下。

using ProjectA;

namespace ProjrctB
{
public class B
{
public static void GetUser(BusinessType bt)
{
//根据BusinessType选择合适的数据库获取数据
string connectString = DBHelper.GetConnectString(bt);
Console.WriteLine(connectString);
}
}
}

执行ProjrctB.B.GetUser(BusinessType.ProductRead)后毫无疑问输出“ProductRead”，和我们预期的一致。接下来业务类型扩展了，要在BusinessType中增加评论类型，修改后的代码如下。

namespace ProjectA
{
/// <summary>
/// 业务类型
/// </summary>
public enum BusinessType
{
CommentRead,
CommentWrite,
UserRead,
UserWrite,
ProductRead,
ProductWrite
}

public class DBHelper
{
/// <summary>
/// 根据业务类型获取连接字符串
/// </summary>
public static string GetConnectString(BusinessType bt)
{
string connectString = string.Empty;
switch (bt)
{
case BusinessType.CommentRead:
connectString = "CommentRead";
break;
case BusinessType.CommentWrite:
connectString = "CommentWrite";
break;
case BusinessType.UserRead:
connectString = "UserRead";
break;
case BusinessType.UserWrite:
connectString = "UserWrite";
break;
case BusinessType.ProductRead:
connectString = "ProductRead";
break;
case BusinessType.ProductWrite:
connectString = "ProductWrite";
break;
default:
connectString = "UserRead";
break;
}
return connectString;
}
}
}

重新生成ProjectA，将其dll部署到ProjectB的bin目录下面，这时候执行ProjrctB.B.GetUser(BusinessType.ProductRead)还会得到我们期待的结果吗？答案是否定的，执行后得到的结果是“UserRead”，并不是我们想要的“ProductRead”类型。为什么会出现这种情况呢？

枚举值本质上就是个整数值，代码编译后，dll中只保留该枚举的整数值，而不会保留枚举变量名。如果枚举本身发生变化，如示例中在枚举BusinessType前面插入了两项，那么后面枚举变量的值都会改变的（如果不是显示指定值的话）。这个时候如果只重新编译了枚举本身，而没有编译引用枚举的地方ProjectB，那么就会出现张冠李戴的问题，因为整数值代表的枚举类型已经变了。这个问题解决的办法是创建枚举时显示指定枚举变量的值，扩展修改枚举类型时不要改变枚举变量的值。如下面的代码，添加业务类型时，将CommentRead = 4和CommentWrite = 5加入即可，而不要动以前的业务类型UserRead = 0，这样扩展类型时及时不去重新编译ProjectB，也不会出现上述问题了。

/// <summary>
/// 业务类型
/// </summary>
public enum BusinessType
{
CommentRead = 4,
CommentWrite = 5,
UserRead = 0,
UserWrite = 1,
ProductRead = 2,
ProductWrite = 3
}

问题的本质在于编译时直接用变量的值代替了变量的名称，不仅枚举类型存在这个问题，常量同样也存在该问题，如果更新了常量的值，而没用编译引用到常量的项目，那么常量值的修改对引用到它的项目来说是无效的，因此有人建议除了值固定不变的常量（如圆周率），可以用readonly代替常量。

如果不是看到类似问题的文章，这种问题很难找到答案，写出来对自己是一种提高，也希望能给遇到类似问题的朋友一些帮助。

本文链接

博客园_陈 晨

合并DataTable并排除重复数据的通用方法

巧用row_number和partition by分组取top数据

小改动大效果：记一次CPU负载高问题排查和解决

NET也不能忽略基础

<img/>标签onerror事件在IE下的bug和解决方法

表变量和临时表

动态创建WebService

网站访问量大+数据量大=>看似简单的SQL语句也会搞挂系统

"动软.Net代码生成器"的一次扩展经历

小心枚举陷阱

博客园_陈晨