CYQ.Data 轻量数据层之路 MDataTable 绑定性能优化之章(十一)

昨天jyk进群后，用Microsoft Application Center Test 对CYQ.Data 框架进行进行了一下压力测试

然后截了几张图上来，只有纯图如下：

1：使用了框架：sql 2000的分页存储过程[临时表分的页]：



2：把存储过程直接换成select语句：



3：他的框架测试结果：



4：这是测试结果了。



以下是说明：


1、DataTable ：714次/秒
2、MDataTable：559 次/秒 （简单存储过程）
3、MDataTable：500 次/秒 （完整存储过程）

简单的说就是自定义的MDataTable性能不够理想，比DataTable还差，那还自定义干什么？直接使用DataTable不就了事了？

当然了，我当时的第一想法，MDataTable是不应该比DataTable慢的，算下体积，关联的类，都比DataTable简化这么多，怎么可能比DataTable性能差呢？

还记得我在发布：CYQ.Data 轻量数据层之路 自定义MDataTable绑定续章(七) 时，在最下面的留言中，有一个测试

示例1：测试代码如下：





测试示例1


DateTime start
=
DateTime.Now;

for
(
int
i
=

; i
<

10000
; i
++
)
{
MDataTable table
=

new
MDataTable(
"
myTableName
"
);
table.Columns.Add(
"
Url
"
, SqlDbType.NVarChar);
table.Columns.Add(
"
Name
"
, SqlDbType.NVarChar);

MDataRow mdr
=
table.NewRow();
mdr[

].Value
=

" http://cyq1162.cnblogs.com/ "
;
mdr[
1
].Value
=

"
路过秋天
"
;
table.Rows.Add(mdr);
}
TimeSpan ts
=
DateTime.Now
-
start;
Response.Write(
"
MDataTable:
"
+
ts.Ticks.ToString()
+

"
<br>
"
);

DateTime start2
=
DateTime.Now;

for
(
int
j
=

; j
<

10000
; j
++
)
{
DataTable table
=

new
DataTable(
"
myTableName
"
);
table.Columns.Add(
"
Url
"
);
table.Columns.Add(
"
Name
"
);

DataRow mdr
=
table.NewRow();
mdr[

]
=

" http://cyq1162.cnblogs.com/ "
;
mdr[
1
]
=

"
路过秋天
"
;
table.Rows.Add(mdr);
}
TimeSpan ts2
=
DateTime.Now
-
start2;
Response.Write(
"
DataTable:
"
+
ts2.Ticks.ToString());

得出的结果是：


1:MDataTable:156250
2: DataTable:1562500
结论：
自定义的MDataTable比DataTable速度快10倍。

不过就在回头间，我想到了，速度慢的原因可能在其实现的绑定机制上。

于是，我在上面的测试代码中，从界面拖了两个控件，分别为之绑定控件测试：

示例2：测试代码，看两句加红标注：





测试示例2


DateTime start
=
DateTime.Now;

for
(
int
i
=

; i
<

10000
; i
++
)
{
MDataTable table
=

new
MDataTable(
"
myTableName
"
);
table.Columns.Add(
"
Url
"
, SqlDbType.NVarChar);
table.Columns.Add(
"
Name
"
, SqlDbType.NVarChar);

MDataRow mdr
=
table.NewRow();
mdr[

].Value
=

" http://cyq1162.cnblogs.com/ "
;
mdr[
1
].Value
=

null
;
table.Rows.Add(mdr);

gv1.DataSource =
table;
gv1.DataBind();

}
TimeSpan ts
=
DateTime.Now
-
start;
Response.Write(
"
MDataTable:
"
+
ts.Ticks.ToString()
+

"
<br>
"
);

DateTime start2
=
DateTime.Now;

for
(
int
j
=

; j
<

10000
; j
++
)
{
DataTable table
=

new
DataTable(
"
myTableName
"
);
table.Columns.Add(
"
Url
"
);
table.Columns.Add(
"
Name
"
);

DataRow mdr
=
table.NewRow();
mdr[

]
=

" http://cyq1162.cnblogs.com/ "
;
mdr[
1
]
=

null
;
table.Rows.Add(mdr);

gv2.DataSource
=

table;

gv2.DataBind();
}
TimeSpan ts2
=
DateTime.Now
-
start2;
Response.Write(
"
DataTable:
"
+
ts2.Ticks.ToString());

得出的结果是：


1：MDataTable:17968750
2：DataTable: 10312500
结论：
自定义的MDataTable在绑定时比DataTable慢了0.7倍左右。

虽然得之绑定时比DataTable慢，但具体慢的原因，还是得找出来的。

原因分析一：数据查询速度

第一步测试一下：返回一个MDataTable是不是比返回一个DataTable慢。

同时也怀疑是不是从SqlDataReader隐藏转换到MDataTable时，造成的性能差。

于是把框架简单修改一下，开放了SQLHelper，开放返回DataTable的方法，接着产生了以下的测试代码：

示例3：





测试示例3



string
sql
=

"
select * from Users
"
;
SQLHelper helper
=

new
SQLHelper();
DateTime start2
=
DateTime.Now;

for
(
int
j
=

; j
<

1000
; j
++
)
{
MDataTable mTable
=
helper.ExeDataReader(sql,
false
);
}
TimeSpan ts2
=
DateTime.Now
-
start2;
Response.Write(
"
MDataTable:
"

+
ts2.Ticks.ToString());

DateTime start
=
DateTime.Now;

for
(
int
i
=

; i
<

1000
; i
++
)
{
DataTable table
=
helper.ExeDataTable(sql,
false
);
}
TimeSpan ts
=
DateTime.Now
-
start;
Response.Write(
"
DataTable:
"

+
ts.Ticks.ToString()
+
"
<br>
"
);

helper.Dispose();

测试结果：


1：MDataTable:1875000
2： DataTable:2656250
结论：
直接回返自定义的MDataTable比DataTable 快0.N倍。

从以上结果看出，无论在实例化，还是在查询速度上，自定义的MDataTable都是优于DataTable的。可是结果在绑定时反而变慢了，于是继续分析。

原因分析二：绑定机制

第一步，从实现绑定机制上走，首先自定义的MDataTable走的绑定机制源自DataReader方式，和DataTable不一样，于是产生第一个想法：

用源生的SqlDataReader绑定和DataTable绑定比较，测试代码：

示例4：





测试示例4



string
sql
=

"
select * from Users
"
;
DateTime start
=
DateTime.Now;

for
(
int
i
=

; i
<

1000
; i
++
)
{
SQLHelper helper
=

new
SQLHelper();
DataTable table
=
helper.ExeDataTable(sql,
false
);
gv1.DataSource
=
table;
gv1.DataBind();
helper.Dispose();
}
TimeSpan ts
=
DateTime.Now
-
start;
Response.Write(
"
DataTable:
"

+
ts.Ticks.ToString()
+

"
<br>
"
);

DateTime start2
=
DateTime.Now;

for
(
int
j
=

; j
<

1000
; j
++
)
{
SQLHelper helper
=

new
SQLHelper();
SqlDataReader reader
=
helper.ExeDataReader(sql,
false
);
gv2.DataSource
=
reader;
gv2.DataBind();
reader.Close();
helper.Dispose();
}
TimeSpan ts2
=
DateTime.Now
-
start2;
Response.Write(
"
SqlDataReader:
"

+
ts2.Ticks.ToString());

测试结果：


1
： DataTable:
10156250

2
： SqlDataReader:
8437500

结论是：
用SqlDataReader绑定比DataTable绑定快一些。

于是，最后得出结论是：还真是我绑定代码写的有问题，导致性能比DataTable差了一点。

三：代码优化之章

既然代码写的不够好，就得优化了。于是接着研究DataReader的绑定接口的实现，发现有这么一些返回代码：







public

override

short
GetInt16(
int
i)
{

this
.ReadColumn(i);

return

this
._data[i].Int16;
}

public

override

int
GetInt32(
int
i)
{

this
.ReadColumn(i);

return

this
._data[i].Int32;
}

public

override

long
GetInt64(
int
i)
{

this
.ReadColumn(i);

return

this
._data[i].Int64;
}

瞬间给了我一些启发，那就是模拟相似的实现方式了：

新建了一个类CellValueType：

并增加所有类型属性，一开始是prop的一个一个敲，累死人了。






internal

class
CellValueType
{

public

int
Int;

public

string
String;

public

bool
Bool;

public

byte
Byte;

public

char
Char;

public

long
Long;

public
DateTime DateTime;

public

decimal
Decimal;

public

double
Double;

public

float
Float;

public
Type Type;

public
Guid Guid;

public
Int16 Int16;

public
Int32 Int32;

public
Int64 Int64;

public

short
Short;
}

接着增加方法，为属性设置值：手动敲这些代码，你说累不累人。





Set 方法



internal

void
Set(
object
value)
{

this
.Type
=
value.GetType();

switch
(Type.Name.ToLower())
{

case

"
char
"
:

this
.Char
=
(
char
)value;

break
;

case

"
boolean
"
:

this
.Bool
=
(
bool
)value;

break
;

case

"
byte
"
:

this
.Byte
=
(
byte
)value;

break
;

case

"
datetime
"
:

this
.DateTime
=
(DateTime)value;

break
;

case

"
decimal
"
:

this
.Decimal
=
(
decimal
)value;

break
;

case

"
double
"
:

this
.Double
=
(
double
)value;

break
;

case

"
guid
"
:

this
.Guid
=
(Guid)value;

break
;

case

"
int16
"
:

case

"
uint16
"
:

this
.Int16
=
(Int16)value;

break
;

case

"
int
"
:

this
.Int
=
(
int
)value;

break
;

case

"
int32
"
:

case

"
uint32
"
:

this
.Int32
=
(Int32)value;

break
;

case

"
int64
"
:

case

"
uint64
"
:

this
.Int64
=
(Int64)value;

break
;

case

"
float
"
:

case

"
single
"
:

this
.Float
=
(
float
)value;

break
;

case

"
string
"
:

this
.String
=
(
string
)value;

break
;

case

"
long
"
:

this
.Long
=
(
long
)value;

break
;

case

"
short
"
:

this
.Short
=
(
short
)value;

break
;
}
}

接着在单元格类里增加该类，并在为单元格值赋值时调用此方法：






public

class
MDataCell
{

//
...能省就省...

internal
CellValueType _CellValueType;

//
...能省就省...

#region
初始化

private

void
Init(CellStruct dataStruct,
object
value)
{
_CellValueType
=

new
CellValueType();

//
...能省就省...

}

//
...能省就省...

public

object
Value
{

get

{

return
_CellValue.Value;
}

set

{

//
...能省就省...

_CellValueType.Set(value);
}
}
}

一切就绪，于是回到MDataTable实现接口的实现之处，写下和DataReader相似的代码：







public

float
GetFloat(
int
i)
{

return
_Mdr[_Ptr][i]._CellValueType.Float;
}

public
Guid GetGuid(
int
i)
{

return
_Mdr[_Ptr][i]._CellValueType.Guid;
}

public

short
GetInt16(
int
i)
{

return
_Mdr[_Ptr][i]._CellValueType.Short;
}

改完之后，马上测试结果：

用的上面的示例2：

测试结果：


1
： MDataTable:
8906250

2
： DataTable:
11093750

结论：
MDataTable在绑定时性能终于上去了，超越DataTable了

接着又用示例1：

测试结果：


1
：MDataTable:
312500

2
：DataTable:
1718750

结论是：
原来比DataTable快10倍的差距，纯减到5倍多一点。

按理就这么算了，绑定快一点，实例化时不要那么快，也是可以接受的。

不过，还是要抓个问底，究竟是哪句代码影响了性能。

于是继续研究，采取代码注释，步步换回原来的代码测试，终于把性能杀手抓出来了：







public

string
GetDataTypeName(
int
i)
{

return
DataType.GetDbType(_Mdr[_Ptr][i]._CellStruct.SqlType.ToString()).ToString();
}

public
Type GetFieldType(
int
i)
{

return
Type.GetType(
"
System.
"

+
GetDataTypeName(i));
}

就是这两个家伙了，上面那个家伙还行，下面那个家伙就大大的不行了，Type.GetType方法，大伙自己拈着点用了。

既然抓到了真胸，那我原来的模仿存在的意义好像就不是那么明显了，只要能优化这里，那些模仿可以去掉了，同时又可以恢复原来10倍的性能差距。

当然了，同时我发现通过Value.GetType是有问题的，如果绑定的值是Null，虽然可以判断了事，不过每次对Value取值也不太稳。

于是新生方法又产生了：

为单元结构添加多一个属性，换掉整个CellValueType类。

在构造头部结构时，完成对Type的初始设置，如下：







///

<summary>

///
单元结构属性

///

</summary>

public

class
CellStruct
{

//
...能省则省...

internal
Type ValueType;

#region
构造函数

public
CellStruct(
string
columnName, System.Data.SqlDbType sqlType,
bool
isReadOnly,
bool
isCanNull,
int
maxSize, ParameterDirection paraDirection)
{

//
...能省则省...

ValueType
=
DataType.GetType(sqlType);
}

#endregion

}

同时DataType增加一内部方法用于从SqlType转到Type:[又是手动敲的，累死人罗]





GetType 方法



internal

static
Type GetType(SqlDbType sqlType)
{

switch
(sqlType)
{

case
SqlDbType.BigInt:

return

typeof
(Int64);

case
SqlDbType.Binary:

case
SqlDbType.Image:

case
SqlDbType.Timestamp:

case
SqlDbType.VarBinary:

return

typeof
(Byte);

case
SqlDbType.Bit:

return

typeof
(Boolean);

case
SqlDbType.Text:

case
SqlDbType.Char:

case
SqlDbType.NChar:

case
SqlDbType.NText:

case
SqlDbType.NVarChar:

case
SqlDbType.VarChar:

return

typeof
(String);

case
SqlDbType.SmallDateTime:

case
SqlDbType.DateTimeOffset:

case
SqlDbType.DateTime2:

case
SqlDbType.DateTime:

case
SqlDbType.Date:

return

typeof
(DateTime);

case
SqlDbType.Money:

case
SqlDbType.Decimal:

case
SqlDbType.SmallMoney:

return

typeof
(Decimal);

case
SqlDbType.Float:

return

typeof
(
double
);

case
SqlDbType.Int:

return

typeof
(
int
);

case
SqlDbType.Real:

return

typeof
(Single);

case
SqlDbType.TinyInt:

case
SqlDbType.SmallInt:

return

typeof
(Int16);

case
SqlDbType.UniqueIdentifier:

return

typeof
(Guid);

default
:

return

typeof
(
object
);
}
}

OK，至此，相关的返回取结构体的Type属性就行了，最后看测试结果：

示例1测试结果：


1:MDataTable:156250
2:DataTable: 1718750
结论：
10倍的差距速度回来了。

对示例2测试结果：


1：MDataTable:8750000
2：DataTable:11093750
结论：
速度上仍超越了DataTable，虽然没超越多少。不过比起之前慢了0.7倍左右到现在反超回来，是一大提升了。

最后结案陈词：


继续欢迎光大群众对本框架的使用与测试，本框架将与时俱进，尽情做到让使用者放心，省心。
欢迎留言讨论。

原文链接：
http://www.cnblogs.com/cyq1162/archive/2010/09/01/1814901.html