博客园_专注，专业，高效

电子商务后台系统重构总结

2011-12-29T13:44:00Z

在这里记录一下重构电子商务后台系统的一些经验。

-- James Fu

统一管理类似会员等级，订单状态，订单类型等公共资源
不要过分应用ajax,比如不要在页面加载完成后又发起一个ajax请求加载数据
不要在页面中写大量JS代码，更不要在JS中夹杂着业务。很多事情尽量在后端统一处理好，这样后期修改会很清晰。
不要过分封装。在刚完成的重构项目中既存在web form应用又存在mvc应用。web form过分封装了服务端控件，导致性能差，给开发人员带来了新的学习任务。mvc应用封装了大量jS工具，导致JS代码庞大，不易于维护。
项目中定义了多个DTO,有ViewObject,DataContract,Entity，实体之间又在用Transformer来回转换，实在是痛苦。建议将DataContract和Entity合为一体，尽量保持它的单一性。在前端定义ViewObject使用它。比如：
public class SOViewObject
{
public SOMsg Model { get; set; }
public string SOTypeDesc
{
get
{
return SOCommon.GetSOTypeDesc(Model.SOType);
}
}
}

6. <未完>

本文链接

SQL Server表分区(一):基础知识和实现方式

2011-06-30T15:20:00Z

1、什么是表分区？
SQL Server使用三种不同类型的文件存储数据，它们分别是.mdf、.ndf和.ldf。主要数据存储在
.mdf文件中，比如表，索引，存储过程等。.ndf文件也用于储存这些数据。.ldf文件用于存储操作日志。
表默认存储在.mdf文件中。更新表时SQL Server会对表锁。那么其它的操作必须等待正在更新操作完成。
如果一个表很大，那么无论是查询操作还是更新操作，性能都会很差。如果将表分别存储在物理上独立但逻辑上连续的
分区中，那么SQL Server可以大幅优化查询操作和更新操作的性能。

2、如何实现表分区？
1)确定分区策略，即划分数据的逻辑规则。比如将整形值小于100的数据放在一个分区上，将大于等于100的数据放在第二个
分区上，等等。
SQL Server中的使用分区函数来实现分区策略：

CREATE PARTITION FUNCTION PF_Order(DATETIME)
AS RANGE RIGHT FOR VALUES
('20090101','20100101','20110101')

2)确定分区存储架构，即划分数据的物理存储规则。最终分区可以存储在主文件组，即.mdf文件中，也可以存储在非主文件组，
即.ndf文件中。
SQL Server中的使用分区架构来实现分区存储架构：

CREATE PARTITION SCHEME PS_Order
AS PARTITION PF_Order
TO ([FG1],[FG2],[FG3],[FG4])

3）将表创建在分区存储架构上，并指定使用哪一列做为划分数据的依据。注意做为划分数据依据的列必须在聚集索引中
在更新数据时，SQL Server首先使用列的数据做为参数调用分区函数确定应该将该数据存储在哪个文件组（逻辑分区），
然后将数据写入文件组对应的物理文件中。

SQL Server中创建分区表:

CREATE TABLE dbo.[Order]
(
OrderID BIGINT IDENTITY(1,1),
OrderDate DATETIME NOT NULL,
CONSTRAINT PK_Order_OrderID_OrderDate PRIMARY KEY CLUSTERED(OrderID,OrderDate)
)
ON PS_Order(OrderDate)

下面是详细的示例代码：

--表分区测试代码
USE [master]
GO

--创建具有多个文件组的测试数据库
IF EXISTS(SELECT 1 FROM sys.databases WHERE [name]=N'TestTablePartitionDB')
BEGIN
DROP DATABASE [TestTablePartitionDB]
END

CREATE DATABASE [TestTablePartitionDB]
ON PRIMARY
(
Name='PrimaryFG',
FileName='D:\Test\TablePartition\TestTablePartitionDB.mdf',
Size=5,
FileGrowth=1
),
FILEGROUP [FG1]
(
Name='FG1',
FileName='D:\Test\TablePartition\FG1.ndf',
Size=5,
FileGrowth=1
),
FILEGROUP [FG2]
(
Name='FG2',
FileName='D:\Test\TablePartition\FG2.ndf',
Size=5,
FileGrowth=1
),
FILEGROUP [FG3]
(
Name='FG3',
FileName='D:\Test\TablePartition\FG3.ndf',
Size=5,
FileGrowth=1
),
FILEGROUP [FG4]
(
Name='FG4',
FileName='D:\Test\TablePartition\FG4.ndf',
Size=5,
FileGrowth=1
)

USE TestTablePartitionDB
GO

--创建分区函数
CREATE PARTITION FUNCTION PF_Order(DATETIME)
AS RANGE LEFT FOR VALUES
('20090101','20100101','20110101')

--创建分区架构
CREATE PARTITION SCHEME PS_Order
AS PARTITION PF_Order
TO([FG1],[FG2],[FG3],[FG4])

--创建分区表
CREATE TABLE dbo.[Order]
(
OrderID BIGINT IDENTITY(1,1),
OrderDate DATETIME NOT NULL,
CONSTRAINT PK_Order_OrderID_OrderDate PRIMARY KEY CLUSTERED(OrderID,OrderDate)
)
ON PS_Order(OrderDate)

--测试数据的逻辑分区是哪个
SELECT $PARTITION.PF_Order('20090101')

--测试分区表的分区情况
SELECT partition_number,rows
FROM sys.partitions
WHERE [object_id]=object_id(N'dbo.[Order]')

--Drop index MyTable_IXC on MyTable with (Move To [Data Partition Scheme] (ID) )

本文链接

BatchFileProcessing(3)-使用SSB与数据库通信

2011-04-18T05:33:00Z

在上一节，我们已经将数据从xls,csv,txt等文件中的解析出来，进行必须的数据验证，
然后将正确的数据以XML格式保存到磁盘，并将事务型数据更新到DB，
比如生成的磁盘文件名，CheckResult,CheckMemo等。
我们再一起回顾下数据库表设计：

USE SSB3
GO

CREATE TABLE [BatchInventoryQueue]
(
TransactionNumber INT IDENTITY(1,1) NOT NULL,
BatchFileID INT NOT NULL,
RowIndex INT NOT NULL,
ItemNumber INT NOT NULL,
[FileName] NVARCHAR(256) NULL,
HasCheck CHAR(1) NULL,
CheckResult CHAR(1) NULL,
CheckMemo NVARCHAR(2000) NULL,
HasSendSSB CHAR(1) NULL, --是否尝试发送过SSB
SSBSendResult CHAR(1) NULL,--发送SSB是否成功
SSBMemo NVARCHAR(2000) NULL,--SSB处理结果
CONSTRAINT PK_TransactionNumber_BatchInventoryQueue PRIMARY KEY CLUSTERED
(
TransactionNumber ASC
)
)

下面我们要将正确的数据以XML格式发送到数据库中。因为我们面临的数据量非常大，
所以我们需要考虑负载均衡，比如多台服务器部署。那么就可能会面临数据冲突的问题。
我这里的情况是要求多台服务器部署，那么如何给服务器分数据，又不造成冲突呢？
方案一：用表的主键TransactionNumber与服务器数据取模

1 SELECT TOP(@BatchSize) TransactionNumber,
2 [FileName]
3 FROM dbo.BatchInventoryQueue
4 WHERE HasCheck='Y' AND CheckResult='S'
5 AND [FileName] IS NOT NULL
6 AND HasSendSSB IS NULL AND TransactionNumber%@Throtting=@TrottingMod

优点：实现简单。
缺点：如果其中一台服务器失败，那么应该属于它处理的数据将一直得不到处理。
方案二：结合SQL Server的锁特性，在查询数据时避免冲突如下：

1 UPDATE TOP(@BatchSize) dbo.BatchInventoryQueue
2 SET HasSendSSB='I'--inprocessing
3 OUTPUT DELETED.TransactionNumber,
4 DELETED.[FileName]
5 WHERE HasCheck='Y' AND CheckResult='S'
6 AND [FileName] IS NOT NULL
7 AND HasSendSSB IS NULL

将HasSendSSB更新为I,标示正在发送。由于在更新数据时，进程会获取UPDLOCK,那么下
一个服务器再查询数据时就必须等待直到第一个进程更新完毕。并发执行情况下，难免会有问题，
因此需要考虑容错机制。即用另一个Job定时监视(SSBSendResult IS NULL OR SSBSendResult='N')
AND HasSendSSB='I'的数据，并将状态清空(SET HasSendSSB=NULL,SSBSendResult=NULL),
等待程序下次再次处理。不过这种情况应该非常少。

1 UPDATE dbo.BatchInventoryQueue
2 SET HasSendSSB=NULL,
3 SSBSendResult=NULL
4 WHERE (SSBSendResult IS NULL OR SSBSendResult='N')
5 AND HasSendSSB='I'

接着我们要生成SSBMessage,这里我使用VTemplate模版引擎来生成.代码如下：
SSBMessageBase:

1 public abstract class SSBMessageBase
2 {
3     public string Subject { get; set; }
4
5     public string FromService { get; set; }
6
7     public string ToService { get; set; }
8
9     public SSBMessageHead Head { get; set; }
10 }

SSBMessageHead:

1 public class SSBMessageHead
2 {
3 public string Action { get; set; }
4
5 public string TransactionCode { get; set; }
6 }

SSBMessageFromFile:

1 public class SSBMessageFromFile : SSBMessageBase
2 {
3 public string FileName { get; set; }
4 }

VTemplate:

1 <vt:template>
2 <Publish>
3 <Subject>{$:ssb.Subject}/Subject>
4 <FromService>{$:ssb.FromService}</FromService>
5 <ToService>{$:ssb.ToService}</ToService>
6 <Message>
7     <Head>
8         <Action>{$:ssb.Action}</Action>
9         <TransactionCode>{$:ssb.TransactionCode}</TransactionCode>
10     </Head>
11     <Body>
12     <vt:output file="$ssb.FileName" charset="utf-8" />
13     </Body>
14 </Message>
15 </Publish>
16 </vt:template>

SSBUtility:

1 public class SSBUtility
2 {
3     private string VtSSBMessage(SSBMessageBase ssb)
4     {
5         string fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,@"Templates\SSB.vt");
6
7         TemplateDocument doc =new TemplateDocument(fileName, Encoding.UTF8);
8         doc.SetValue("ssb", ssb);
9
10         StringBuilder sb = new StringBuilder();
11         StringWriter sw = new StringWriter(sb);
12         doc.Render(sw);
13         sw.Close();
14
15         return sb.ToString();
16     }
17
18     public void SendSSB(SSBMessageBase ssb)
19     {
20         string msg = VtSSBMessage(ssb);
21         using (SqlConnection conn = new SqlConnection(JobConfigs.SSBConnectionString))
22         {
23             using (SqlCommand cmd = new SqlCommand())
24             {
25                 cmd.Connection = conn;
26                 cmd.CommandType = CommandType.StoredProcedure;
27                 cmd.CommandText = JobConfigs.SSBSendProc;//dbo.[UP_Send_Inventory]
28                 SqlParameter p = new SqlParameter("@Message", SqlDbType.Xml);
29                 p.Value = msg;
30                 cmd.Parameters.Add(p);
31                 conn.Open();
32                 cmd.ExecuteNonQuery();
33                 conn.Close();
34             }
35         }
36     }
37 }

再接着就是SSB创建部分，下面列举代码示例：

  1 USE [master]
  2 GO
  3
  4 IF EXISTS(SELECT * FROM sys.databases where [name]='SSB')
  5     DROP DATABASE SSB
  6
  7 CREATE DATABASE SSB
  8 GO
  9
10 --enable service broker on database
11 ALTER DATABASE SSB
12 SET TRUSTWORTHY ON
13 GO
14
15 USE SSB
16 GO
17
18 --create a test table
19 CREATE TABLE dbo.Inventory
20 (
21 [ItemNumber] INT IDENTITY(1,1) PRIMARY KEY,
22 [Inventory] INT NOT NULL
23 )
24
25 INSERT INTO dbo.Inventory([Inventory])
26 VALUES(1)
27
28 GO
29
30 --create message type and contract
31 CREATE MESSAGE TYPE [Message_Type_Inventory]
32 VALIDATION = WELL_FORMED_XML;
33
34 CREATE CONTRACT [Contract_Inventory]
35 (
36 [Message_Type_Inventory] SENT BY INITIATOR
37 )
38 GO
39
40 --create queue, send service and receive
41 CREATE QUEUE [Queue_Inventory]
42 WITH STATUS=ON,
43 RETENTION=OFF;
44
45 CREATE SERVICE [Service_Send_Inventory]
46 ON QUEUE [Queue_Inventory]([Contract_Inventory])
47 GO
48
49 CREATE SERVICE [Service_Receive_Inventory]
50 ON QUEUE [Queue_Inventory]([Contract_Inventory])
51 GO
52
53 --receive procedure
54 CREATE PROCEDURE dbo.[UP_Receive_Inventory]
55 AS
56 BEGIN
57     SET NOCOUNT ON;
58     DECLARE @ConversionHandle UNIQUEIDENTIFIER,
59         @MessageType SYSNAME,
60         @Message XML,
61         @ItemNumber CHAR(50),
62         @Inventory INT
63
64     WHILE(1=1)
65     BEGIN
66         WAITFOR(
67         RECEIVE TOP(1) @ConversionHandle=conversation_handle,
68                 @MessageType=message_type_name,
69                 @Message=CAST(message_body AS XML)
70             FROM [Queue_Inventory]
71         ),TIMEOUT 1000
72         IF(@@ROWCOUNT=0)
73             BREAK;
74
75         SELECT @ItemNumber=@Message.value('(/Publish/Message/Body/Inventory/ItemNumber/text())[1]','INT'),
76             @Inventory=@Message.value('(/Publish/Message/Body/Inventory/Inventory/text())[1]','INT')
77
78         UPDATE dbo.Inventory
79         SET Inventory=@Inventory
80         WHERE ItemNumber=@ItemNumber
81     END
82 END
83 GO
84
85 --activate queue
86 ALTER QUEUE [Queue_Inventory]
87 WITH ACTIVATION
88 (
89 PROCEDURE_NAME=[UP_Receive_Inventory],
90 MAX_QUEUE_READERS=5,
91 EXECUTE AS OWNER
92 )
93 GO
94
95 --send procedure
96 CREATE PROCEDURE dbo.[UP_Send_Inventory]
97 (
98     @Message XML
99 )
100 AS
101 BEGIN
102     SET NOCOUNT ON;
103     DECLARE @ConversationHandle UNIQUEIDENTIFIER
104
105     BEGIN DIALOG CONVERSATION @ConversationHandle
106     FROM SERVICE [Service_Send_Inventory]
107     TO SERVICE 'Service_Receive_Inventory'
108     ON CONTRACT [Contract_Inventory]
109     WITH ENCRYPTION = OFF;
110
111     SEND ON CONVERSATION @ConversationHandle
112     MESSAGE TYPE [Message_Type_Inventory](@Message)
113
114     END CONVERSATION @ConversationHandle WITH CLEANUP;
115 END
116 GO
117
118 --test data
119 DECLARE @Message XML
120 SELECT @Message='
121 <Publish>
122 <Subject>BatchInventory</Subject>
123 <FromService>Service_Send_Inventory</FromService>
124 <ToService>Service_Receive_Inventory</ToService>
125 <Message>
126     <Head>
127         <Action>UpdateInventory</Action>
128         <TransactionCode>123</TransactionCode>
129     </Head>
130     <Body>
131         <Inventory>
132             <ItemNumber>1</ItemNumber>
133             <Inventory>200</Inventory>
134         </Inventory>
135     </Body>
136 </Message>
137 </Publish>'
138
139 SELECT * FROM dbo.[Inventory]
140 --send
141 EXEC dbo.[UP_Send_Inventory] @Message
142
143 WAITFOR DELAY '00:00:30'
144 SELECT * FROM Inventory

本文链接

BatchFileProcessing(2)--实现之解析文件

2011-04-05T01:41:00Z

前一篇写到BatchFileProcessing的流程设计,这篇总结下解析文件的实现。

目前我的产品支持用户上传excel,csv,tab delimited等三种文件格式，鉴于office com组件性能太差，所以我们购买了aspose cells组件。下面我们以批量更新商品库存为例，阐述一下解析文件的实现。

当我们从数据库读取到尚未处理的用户上传文件后，我们会将它下载到服务器磁盘上，然后开始解析。

文件级别的检查下包括以下几项：

（1）文件是否可以正常打开，如果不能正常打开，记录异常并通知客户。

（2）文件中的关键列是否有缺失，如果有缺失，记录异常并通知客户。

（3）文件中的列是否有重复，如果有重复，记录异常并通知客户。

（4）文件中是否有未在模版中未定义的列，如果有未在模版中未定义的列，记录异常并通知客户。

批量更新商品库存的业务检查下包括以下几项：

（1）商品编号是否提供，如果没有提供，记录异常到数据库。

（2）商品库存是否提供，如果没有提供，使用默认值零;如果提供了，验证是否在有效的范围内，比如0~999999，如果不合法，记录异常到数据库。

用 Aspose Cells组件读取数据：

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 using Aspose.Cells;
  6
  7 namespace BatchFile.Jobs.FileParsers
  8 {
  9     public class AsposeCellParser : IExcelParser
10     {
11         private string m_fileName;
12         private string m_fileExt;
13         private FileFormatType m_fileFormatType;
14         private Workbook m_workbook;
15         private Worksheet m_worksheet;
16
17         public AsposeCellParser(string fileName, string fileExt)
18         {
19             m_fileName = fileName;
20             m_fileExt = fileExt;
21             if (FileExtType.IsCSV(m_fileExt))
22             {
23                 m_fileFormatType = FileFormatType.CSV;
24             }
25             else if (FileExtType.IsExcel2007(m_fileExt))
26             {
27                 m_fileFormatType = FileFormatType.Excel2007Xlsx;
28             }
29             else if (FileExtType.IsExcel2003(m_fileExt))
30             {
31                 m_fileFormatType = FileFormatType.Excel2003;
32             }
33             else if (FileExtType.IsTabDelimited(m_fileExt))
34             {
35                 m_fileFormatType = FileFormatType.TabDelimited;
36             }
37             else
38             {
39                 throw new NotSupportedException(string.Format("File extension({0}) cannot be supported.", fileExt));
40             }
41         }
42
43         #region IExcelParser
44
45         public string ExcelFile
46         {
47             get { return m_fileName; }
48         }
49
50         public int RowCount
51         {
52             get { return m_worksheet.Cells.MaxDataRow; }
53         }
54
55         public int ColumnCount
56         {
57             get { return m_worksheet.Cells.MaxDataColumn; }
58         }
59
60         public object GetCellValue(int row, int col)
61         {
62             return m_worksheet.Cells[row, col].Value;
63         }
64
65         public void ActiveWorksheet(int activeWorksheetIndex)
66         {
67             if (activeWorksheetIndex < 0 || activeWorksheetIndex >= m_workbook.Worksheets.Count)
68             {
69                 throw new ArgumentOutOfRangeException("Worksheet index is out of range.");
70             }
71             m_worksheet = m_workbook.Worksheets[activeWorksheetIndex];
72         }
73
74         public void ActiveWorksheet(string activeWorksheetName)
75         {
76             if (string.IsNullOrWhiteSpace(activeWorksheetName))
77             {
78                 throw new ArgumentException("Worksheet name cannot be null or empty.");
79             }
80             m_worksheet = m_workbook.Worksheets[activeWorksheetName];
81         }
82
83         public void OpenFile()
84         {
85             m_workbook = new Workbook();
86             m_workbook.ConvertNumericData = false;
87             m_workbook.Open(m_fileName, m_fileFormatType);
88             m_worksheet = m_workbook.Worksheets[0];
89         }
90
91         public void OpenFile(int activeWorksheetIndex)
92         {
93             OpenFile();
94             ActiveWorksheet(activeWorksheetIndex);
95         }
96
97         public void OpenFile(string activeWorksheetName)
98         {
99             OpenFile();
100             ActiveWorksheet(activeWorksheetName);
101         }
102
103         #endregion
104     }
105 }

文件检查与解析

  1  public void Process()
  2         {
  3             m_parser = new AsposeCellParser(m_batchInventoryFile.FileName, m_fileExt);
  4
  5             //open file
  6             try
  7             {
  8                 m_parser.OpenFile();
  9             }
10             catch
11             {
12                 EmailUtil.Send(m_batchInventoryFile.UserEmail, Consts.Batch_Inventory_File_Can_Not_Open, "File you uploaded cannot be open.");
13                 return;
14             }
15
16             //resolve headers
17             var dictMapping = ConfigManager.BatchFileConfig.BatchInventory.InventoryPropertyMappingDict;
18             List<ExcelHeaderModel> headerList = new List<ExcelHeaderModel>();
19             List<string> headerNameList = new List<string>();
20             int rowIndex = 0;
21             int colIndex = 0;
22             for (; colIndex < m_parser.ColumnCount; colIndex++)
23             {
24                 string headerName = m_parser.GetCellValue(rowIndex, colIndex).ToString().Trim();
25                 ExcelHeaderModel header = new ExcelHeaderModel();
26                 header.ColumnIndex = colIndex;
27                 header.HeaderName = headerName;
28                 header.IsDuplicated = headerNameList.Contains(headerName);
29
30                 headerList.Add(header);
31                 headerNameList.Add(headerName);
32             }
33
34             //check missing key column or not
35             List<string> lostKeyList = new List<string>();
36             foreach (var key in dictMapping.Keys)
37             {
38                 var mapping = dictMapping[key];
39                 if (mapping.IsKey
40                     && !headerNameList.Contains(mapping.HeaderName))
41                 {
42                     lostKeyList.Add(mapping.HeaderName);
43                 }
44             }
45             if (lostKeyList.Count > 0)
46             {
47                 string keys = lostKeyList[0];
48                 for (int i = 1; i < lostKeyList.Count; i++)
49                 {
50                     keys += string.Format(",{0}", lostKeyList[i]);
51                 }
52
53                 EmailUtil.Send(m_batchInventoryFile.UserEmail,
54                     Consts.Batch_Inventory_File_Missing_Key,
55                     string.Format("File you uploaded is missing key(s) {0}.", keys));
56                 return;
57             }
58
59             //check exist duplicate columns or not
60             var duplicateColumnList = headerList.FindAll(h => h.IsDuplicated);
61             if (duplicateColumnList.Count > 0)
62             {
63                 string duplicateColumns = duplicateColumnList[0].HeaderName;
64                 for (int i = 1; i < duplicateColumnList.Count; i++)
65                 {
66                     duplicateColumns += string.Format(",{0}", duplicateColumnList[i].HeaderName);
67                 }
68                 EmailUtil.Send(m_batchInventoryFile.UserEmail,
69                    Consts.Batch_Inventory_File_Having_Duplicated_Column,
70                    string.Format("File you uploaded has duplicated column(s) {0}.", duplicateColumns));
71                 return;
72             }
73
74             //check exist undefined columns or not
75             var undefinedColumnList = headerList.FindAll(h => !h.IsTemplateDefined);
76             if (undefinedColumnList.Count > 0)
77             {
78                 string undefinedColumns = undefinedColumnList[0].HeaderName;
79                 for (int i = 1; i < undefinedColumnList.Count; i++)
80                 {
81                     undefinedColumns += string.Format(",{0}", undefinedColumnList[i].HeaderName);
82                 }
83                 EmailUtil.Send(m_batchInventoryFile.UserEmail,
84                    Consts.Batch_Inventory_File_Having_Undefined_Column,
85                    string.Format("File you uploaded has undefined column(s) {0}.", undefinedColumns));
86                 return;
87             }
88
89             //mapping header according to configuration
90             foreach (var header in headerList)
91             {
92                 if (dictMapping.Keys.Contains(header.HeaderName))
93                 {
94                     header.IsTemplateDefined = true;
95                     var mapping = dictMapping[header.HeaderName];
96                     header.IsKey = mapping.IsKey;
97                     header.IsTransactional = mapping.IsTransactional;
98                     header.PropertyName = mapping.PropertyName;
99                     header.DataType = mapping.DataType;
100                     header.DefaultValue = mapping.DefaultValue;
101                     header.ColumnName = mapping.ColumnName;
102                     header.IsSSBNode = mapping.IsSSBNode;
103                 }
104             }
105
106             //check and extract business data
107             if (!Directory.Exists(ConfigManager.BatchFileConfig.BatchInventory.File2Dir))
108             {
109                 Directory.CreateDirectory(ConfigManager.BatchFileConfig.BatchInventory.File2Dir);
110             }
111             var partitionList = Partitioner.Create(1, m_parser.RowCount + 1);
112             Parallel.ForEach(partitionList, (p, loopState) =>
113                 {
114                     DataTable dt = CreateDataTable(headerList);
115                     for (int i = p.Item1; i < p.Item2; i++)
116                     {
117                         DataRow dr = dt.NewRow();
118                         XElement xNode = new XElement(ConfigManager.BatchFileConfig.BatchInventory.RootPropertyName);
119                         List<string> rowErrorList = new List<string>();
120
121                         foreach (var header in headerList)
122                         {
123                             object value = null;
124                             string strValue = string.Empty;
125                             if (header.IsKey || header.IsTransactional || header.IsSSBNode)
126                             {
127                                 value = m_parser.GetCellValue(i, header.ColumnIndex);
128                                 strValue = value.ToString().Trim();
129                                 if (string.IsNullOrEmpty(strValue))
130                                 {
131                                     strValue = header.DefaultValue;
132                                 }
133                                 //find property's validator and perform validation
134                                 if (header.IsTemplateDefined)
135                                 {
136                                     var property = dictMapping[header.HeaderName];
137                                     if (!PropertyValidator.Validate(property.Validator, strValue))
138                                     {
139                                         rowErrorList.Add(string.Format(property.Validator.Tips, property.PropertyName));
140                                     }
141                                 }
142                             }
143                             if (header.IsTransactional)
144                             {
145                                 dr[header.ColumnName] = value;
146                             }
147                             if (header.IsSSBNode)
148                             {
149                                 xNode.Add(new XElement(header.PropertyName, new XCData(strValue)));
150                             }
151                         }
152
153                         dr["BatchFileID"] = m_batchInventoryFile.TransactionNumber;
154                         dr["RowIndex"] = i.ToString();
155                         if (rowErrorList.Count == 0)
156                         {
157                             string fileName = i.ToString() + ".xml";
158                             string filePath = Path.Combine(ConfigManager.BatchFileConfig.BatchInventory.File2Dir, fileName);
159                             File.WriteAllText(filePath, xNode.ToString());
160                             dr["FileName"] = fileName;
161                             dr["CheckResult"] = Consts.Success;
162                         }
163                         else
164                         {
165                             dr["CheckResult"] = Consts.Failed;
166                             XElement xNodeCheckMemo = new XElement("CheckMemoList", from error in rowErrorList
167                                                                                 select new XElement("CheckMemo", error));
168                             dr["CheckMemo"] =xNodeCheckMemo.ToString();
169                         }
170                         dr["HasCheck"] = Consts.Yes;
171                         dt.Rows.Add(dr);
172
173                         if (dt.Rows.Count == ConfigManager.BatchFileConfig.BatchInventory.BatchSize)
174                         {
175                             //write to DB
176                             SQLHelper.BulkCopy(dt);
177                             dt.Rows.Clear();
178                         }
179                     }
180
181                     //process the last batch
182                     if (dt.Rows.Count > 0)
183                     {
184                         //write to DB
185                         SQLHelper.BulkCopy(dt);
186                         dt.Rows.Clear();
187                     }
188                 });
189         }
190
191         private DataTable CreateDataTable(List<ExcelHeaderModel> headerList)
192         {
193             DataTable dt = new DataTable(ConfigManager.BatchFileConfig.BatchInventory.DataTableName);
194             foreach (var header in headerList)
195             {
196                 if (header.IsTransactional)
197                 {
198                     dt.Columns.Add(header.ColumnName, Type.GetType(header.DataType));
199                 }
200             }
201             dt.Columns.Add("BatchFileID", typeof(int));
202             dt.Columns.Add("RowIndex", typeof(int));
203             dt.Columns.Add("FileName", typeof(string));
204             dt.Columns.Add("HasCheck", typeof(string));
205             dt.Columns.Add("CheckResult", typeof(string));
206             dt.Columns.Add("CheckMemo", typeof(string));
207
208             return dt;
209         }

为了提高文件解析的性能使用了多线程以及SqlBulkCopy等技术。下面是SQLHelper的定义：

1 public static class SQLHelper
2     {
3         private static string m_connectionString = ConfigurationManager.ConnectionStrings["MSSQL"].ConnectionString;
4         public static string ConnectionString
5         {
6             get
7             {
8                 return m_connectionString;
9             }
10         }
11
12         public static void BulkCopy(DataTable dt, string destTableName, List<SqlBulkCopyColumnMapping> columnMappingList, int timeoutSeconds = 1200)
13         {
14             using (SqlConnection conn = new SqlConnection(m_connectionString))
15             {
16                 conn.Open();
17                 SqlTransaction trans = conn.BeginTransaction(IsolationLevel.ReadCommitted, "Bulk copy batch data");
18                 SqlBulkCopy b = new SqlBulkCopy(conn, SqlBulkCopyOptions.Default, trans);
19                 b.BulkCopyTimeout = timeoutSeconds;
20                 b.DestinationTableName = destTableName;
21                 if (columnMappingList != null)
22                 {
23                     foreach (var colMapping in columnMappingList)
24                     {
25                         b.ColumnMappings.Add(colMapping);
26                     }
27                 }
28                 b.WriteToServer(dt);
29                 trans.Commit();
30                 b.Close();
31                 conn.Close();
32             }
33         }
34
35         public static void BulkCopy(DataTable dt)
36         {
37             List<SqlBulkCopyColumnMapping> columnMappingList = new List<SqlBulkCopyColumnMapping>();
38             foreach (DataColumn col in dt.Columns)
39             {
40                 columnMappingList.Add(new SqlBulkCopyColumnMapping
41                 {
42                     SourceColumn = col.ColumnName,
43                     DestinationColumn = col.ColumnName
44                 });
45             }
46             BulkCopy(dt, dt.TableName, columnMappingList);
47         }
48     }

本文链接

[基础知识]巧用项目生成事件属性自动打包

2011-03-29T23:29:00Z

.net项目有两个生成事件：预先生成事件和后期生成事件。如下截图：

在这两个事件中我们可以实现我们的一些与编译相关的需求，比如编译完成后将某些文件打包并传输到发布服务器上等。

这里要介绍的一个应用案例如下：我们发布Job的流程是将Debug或Release重命名为Bin，然后将Bin目录和App.config

压缩成zip包。

第一步：在预先生成事件中清除上次打包的文件和目录(如果有的话),包括删除文件夹$(ProjectDir)bin\bin，

删除文件$(ProjectDir)bin\app.config，删除文件$(ProjectDir)bin\Jobs.zip。代码如下：

   1: if exist "$(ProjectDir)bin\bin" rd /S /Q "$(ProjectDir)bin\bin"   2: if exist "$(ProjectDir)bin\app.config" del /F /Q "$(ProjectDir)bin\app.config"   3: if exist "$(ProjectDir)bin\Jobs.zip" del /Q "$(ProjectDir)bin\Jobs.zip"

第二步：在后期生成事件中创建文件夹$(ProjectDir)bin\bin，拷贝生成输出到文件夹$(ProjectDir)bin\bin，拷贝文件

$(ProjectDir)app.config到文件夹$(ProjectDir)bin\bin，如果存在7z.exe那么就将文件夹$(ProjectDir)bin\bin和文件

$(ProjectDir)bin\bin\app.config压缩成zip文件$(ProjectDir)bin\Jobs.zip。代码如下：

   1: mkdir "$(ProjectDir)bin\bin"   2: xcopy /E /Y "$(TargetDir)*.*" "$(ProjectDir)bin\bin"   3: copy /Y "$(ProjectDir)app.config" "$(ProjectDir)bin"   4: if exist "%ProgramFiles%\7-Zip\7z.exe" (   5: "%ProgramFiles%\7-Zip\7z.exe"  a -r "$(ProjectDir)bin\Jobs.zip" "$(ProjectDir)bin\bin" "$(ProjectDir)bin\app.config"   6: )
 

输出示例：

搞定。哎呀，动动脑筋，总有好办法解决问题的。这样，就不用再手动重复的重命名文件夹，压缩文件了。

本文链接

BatchFileProcessing--流程设计

2011-03-22T14:46:00Z

最近在研究Excel数据处理，感觉能面对大数据量的挑战是一件很愉悦的事情，:)下面是批量创建商品处理流程设计图：

一个商品会包含很多属性，比如商品编号，商品名，商品简介，单价，库存，图片（图片链接，多个链接用逗号分隔）等。如何用UI引导用户创建商品见我的另一篇文章”企业应用之分多步创建商品”。我们可以用Excel中的一行来描述一个商品，比如：

流程设计：

1) 用户上传Excel文件到FTP

2) 程序下载Excel文件到本地

3）检查Excel文件，看是否有格式错误，版本号支持等错误，如果有即时通知用户

4）检查Excel文件通过后循环将每一行数据提取出来，将行号，文件号，业务检查（比如ItemName,UnitPrice,Inventory等必填，Inventory必须大于零等）结果等事务型数据存储到数据库，如果没有任何业务异常将业务数据以XML实例的形式存储到磁盘上，等待处理。

5）循环处理第四步产生的XML实例，用以逗号分隔的图片链接下载图片，将图片放大缩小成预定义的各种格式，然后上传到图片服务器并得到真实可访问的图片链接，用以写入数据库。图片处理完成后，将业务数据写入数据库。

6）创建一批（比如总量的三分之一）商品完成后，即时通知用户当前处理进度。

为了得到好的性能可以引入多线程机制。具体实现后面再单独讨论。:)

本文链接

企业级软件开发需要什么样的框架？

2011-03-03T08:14:00Z

导读

1.企业级软件开发流程

2.什么是框架以及为什么要开发框架

企业级软件开发流程

1）领域建模

分析领域特定的问题。比如赶集网这一分类信息网站，她的定位是解决都市人寻求房屋出租、二手房、二手车、二手物品交易、求职招聘等生活信息的需求的。在领域建模阶段要解决的就是这个软件的定位问题，做什么不做什么。

这一阶段由高层领导，市场销售及系统分析师等完成。
2）平台技术选择

技术选型，比如用什么平台/架构(.net,j2ee,php,python等等)开发，采用什么服务器托管等。

这一阶段由系统高层领导，系统分析师及系统架构师等完成。
3）解决方案

根据选定的平台技术等给出一个可行的解决方案，说明系统会使用什么样的部署结构等。

这一阶段由系统分析师及系统架构师等完成。
4）需求分析

市场技术的可行性已经确定，接下来就是把做什么具体化了。把每一个功能模块及非功能性需求罗列出来。

这一阶段由市场销售，系统分析师，产品经理，用户体验师，测试工程师等完成。
5）技术实现

需求已经明确，接下来就是设计与实现了。除了实现系统的特定功能外，我们还要实现系统用户的验证与授权，系统日志与异常处理，发邮件与用户交互等。这一部分就是企业级软件开发中可以复用的切入点，也是和我们系统架构师，软件工程师的工作密切相关的部分。

这一阶段由系统架构师，开发经理，软件工程师等完成。
6）集成测试

在预设的软硬件环境下，测试系统是否很好地满足了用户的需求。

这一阶段由软件工程师，测试工程师等完成。
7）验收测试

将系统交由用户或用户代表使用。可能会根据反馈进行一定的修改等。

这一阶段由产品经理，用户或用户代表，软件工程师，测试工程师等完成。
8）交付

实际交给用户运营与使用。

这一阶段由市场销售，技术代表，用户等完成。
9) 维护

根据用户实际使用中给出的反馈或提出的新需求等修改系统。

这一阶段几乎是上面1-8的迭代过程。

什么是框架？

一个框架是在一个给定的问题领域内，一个应用程序的一部分设计与实现。

框架中要包含什么？

框架中应该提供通用的功能与实现，比如用户验证与授权，日志与异常处理，缓存策略与实现，发送邮件，定时数据处理（Jobs），数据访问策略与实现,多语言支持，通用UI组件等。

为什么要开发框架？

较大的软件开发公司都有自己的框架，因为框架中积累了很多通用的功能，可以直接复用。采用框架可以规范开发人员的设计与代码，有利于在一个项目内多人协同工作，一致性好，可维护性好。这样就可以提高质量，缩短开发周期，进而也就提高了生产率，降低了开发费用。

我如何做框架？

我的经验告诉我，开发框架一定要遵循简单封装，决不能过度设计。

本文链接

拥抱重构

2011-02-20T08:30:00Z

惧怕重构
提到让你重构一个功能模块，提到让你去修改一个别人的bug,阅读别人的代码，你第一反应是什么？惧怕？想骂人？面对一个代码垃圾场，我想大家都会有些不安，尤其是面对测试团队，上线的压力。

重构需要勇气

面对一个代码垃圾场，光抱怨是没用的。需要鼓起勇气去面对重构。

如何实施重构

首先，需要大家思考以下一些问题：

1）代码垃圾场是如何形成的？

团队中有很多菜鸟？团队执行力不强？团队管理跟不上？企业文化问题？其实一个代码垃圾场的形成和这些都有关。试问一个新人在没有培训和老员工带领的情况下如何写出基于本企业框架等的规范代码？一个团队没有形成结对，review代码，控制质量的意识如何走向卓越？一个企业不重视技术人员福利待遇，如何能招募和留住优秀的员工？一个终日想着加薪，而自己技术水平和做事能力却半斤八量，却始终没有想着做好本职工作的员工就是代码垃圾场的主力制造者。

2）重构实践方法

a)把握全局，先了解业务

b)深入理解团队基于的开发平台

c)阅读代码，清除冗余代码，重构变量名等，删除不一致或无效的注释，补写注释，为下一步做准备

d)将通用的代码块提升为方法

e)小步前进，随时测试

在一次重构之后应该牢记的最佳实践：

1）每个程序员都应该不断加强自己的编程思想，注重编程质量

2）重构要随时进行

3）避免过度设计。模式是把双刃剑。举例来说，比如权限验证，在开发环境我们一般用Mock实现，在实际测试环境我们用真实实现，这里我感觉用一个简单的if-else胜过使用Providers模式，因为这个场景太简单了，而且可预期，要么真实实现，要么Mock实现。

下面记录下我最近重构或review代码时发现的一些问题：

1.对ADO.net基础理解不透，或者是对业务理解不透

比如ExecuteScalar，我们在查询数据库中的单个值时就常用这个方法。但是有两点要注意：

a)如果查询的记录不存在，则返回null

b)如果查询的记录存在，但在数据库中是null,则返回DBNull.Value

因此我们在使用时要结合业务做容错处理，比如在不存在或存在为DBNull.Value时就可以配置默认值等。如下：

//step0:CoreData default value is string.empty
string coreData = string.Empty;
//step1:read CoreData
object result = SQLiteHelper.ExcuteScalar("SELECT CoreData FROM TestTable LIMIT 1");
if (result != null && result != System.DBNull.Value)
{
coreData = result.ToString();
}
//step2:processing CoreData

2.对值类型和引用类型理解不够，也可以说对代码容错处理过度

下面是一同事的代码断：int selectedIndex = 0if (selectedIndex != null) {}

3.下面这个就是容错处理不够，主要是同事不了解发布的过程。发布时可能忘记加相关的配置项的哦。如果在配置文件中一时忘记配置，就势必要遇到NullReferenceException. App.config
<?xml version="1.0" encoding="utf-8" ?> <configuration> <connectionStrings> <add name="SQLite.ConnectionString" connectionString="Data Source={0}ECMarketPlace.db;Version=3;New=False;Connection Timeout=3;Compress=True;Cache Size=1024;" providerName="System.Data.SQLite"/> </connectionStrings> <appSettings>  </appSettings> </configuration>

C#(容错处理不够)

//get release config string isRelease = ConfigurationManager.AppSettings["IsRelease"]; if (isRelease.ToUpper() == "Y") { //processing release logic }C#(适当的容错处理)

//get release config string isReleaseConfig = ConfigurationManager.AppSettings["IsRelease"]; string isRelease = isReleaseConfig == null? "N" : isReleaseConfig.ToUpper(); if (isRelease == "Y") { //processing release logic }

4.约定优于配置

对于百年就不得变的模版名字就不用写在配置文件中了。

5.在构造SSB消息时，最好不要用Serialization的方式。这是因为重构随时在进行，一个属性名有一天不小时被别人重构了，在序列化出来的XML消息中自然就变了，但是在处理SSB消息的存储过程中XPath路径没变，当然就取不到参数值了。建议用System.Xml.Linq.XElement构造SSB消息。示例如下：
const string DECIMAL_FORMAT = "F2";
static XCData XCData(string value)
{
    return new XCData(value != null ? value.Trim() : string.Empty);
}
static string SSBMessageNode_ProductList(List<Product> products)
{
    XElement result = new XElement("ProductList");
    if (products != null)
    {
        foreach (var p in products)
        {
            result.Add(new XElement("Product",
                    new XElement("ID", p.ID.ToString()),
                    new XElement("Name", XCData(p.Name)),
                    new XElement("Url", XCData(p.Url)),
                    new XElement("SellPrice", p.SellPrice.ToString(DECIMAL_FORMAT)),
                    new XElement("Inventory", p.Inventory.ToString())
                    ));
        }
    }

    return result.ToString();
}

使用方法：
List<Product> products = new List<Product>();
products.Add(new Product
{
    ID=1,
    Name = "格兰仕怡宝系列大1P壁挂式家用冷暖光波空调KFR-26GW/DLP7-130<1>",
    Url = "http://www.360buy.com/product/213683.html",
    SellPrice=3699.12M,
    Inventory=9999
});

string ssbMessageNode_ProductList = SSBMessageNode_ProductList(products);

输出结果示例：

<ProductList> <Product> <ID>1</ID> <Name><![CDATA[格兰仕怡宝系列大1P壁挂式家用冷暖光波空调KFR-26GW/DLP7-130<1>]]></Name> <Url><![CDATA[http://www.360buy.com/product/213683.html]]></Url> <SellPrice>3699.12</SellPrice> <Inventory>9999</Inventory> </Product> </ProductList>

嗯，先总结到这里。谢谢。:)

本文链接

MaintainUserRole, 一个功能的实现方法

2011-02-16T14:47:00Z

在系统开发中，经常会遇到像下面这种场景的功能模块：管理用户的角色，在界面上显示所有Active的角色，如果用户有这个角色在界面上标示出来，比如CheckBox勾中，如下图。

这里会涉及三个表，User,Role,UserRoleRelation.

DECLARE @UserID INT
SELECT @UserID=1
;WITH CTE_UserRole(RoleID) AS
(
SELECT RoleID
FROM dbo.BasicUserRoleRelation WITH(NOLOCK)
WHERE UserID=@UserID
)
SELECT a.RoleID
    ,a.RoleName
    ,CAST(CASE WHEN b.RoleID IS NULL THEN 0
            ELSE 1
            END AS BIT) AS IsChecked
FROM dbo.[BasicRole] a WITH(NOLOCK)
LEFT OUTER JOIN CTE_UserRole b WITH(NOLOCK)
ON a.RoleID=b.RoleID
WHERE a.[Status]='A'

查询结果：

再用ORM等映射到对象列表，然后在UI端绑定即可。

本文链接

T-SQL经验总结

2011-01-11T13:12:00Z

在庞大的业务系统背后，一定有数据库管理系统的支持。在现代以数据为中心的开发时代，SQL编程也显得尤为重要。下面总结下我最近SQL编程的一些经验：

1.SELECT查询要列出所有要查询的字段

2.注意UNION和UNION ALL的区别,在IN，OR，UNION ALL这三种方案中，UNION ALL的执行效率是最高的。

3.视图定义要尽量简单，最好不要包含业务逻辑。比如：在业务系统中，单据会有多种状态，那么在系统与系统交互的过程中，可能两边的状态码定义的不同，那么就需要映射。在这种场景下，强烈建议这种映射不要放在视图定义或SQL查询中，因为这会降低查询的性能。

4.表变量与临时表的选择。表变量会将数据存储在数据库服务的内存中，临时表会将数据存储在数据库服务器的磁盘上，会产生I/O，因此临时表消耗资料要多些，性能显示要差些。一般来说，建议采用表变量。如果数据量大（选取的字段多，有大字段，数据条目超过10W），又要连续使用多次的，建议用临时表。

5.在表变量上设计主键是有百益而无一害的，临时表上更应该设计主键了。设计主键主要是让数据有序存储，提高查询性能。

6.要把握INNER JOIN和LEFT/RIGHT JOIN的区别。选择好了可以使SQL很简洁高效。

7.EXISTS的效率比IN要好十倍的样子。下面三个版本的效果，V1<V2<V3。

--V1
DELETE FROM dbo.Master
WHERE TransactionNumber IN
(
SELECT OriginalTransactionNumber FROM dbo.MasterHistory WITH(NOLOCK)
)

--V2
DELETE FROM dbo.Master
WHERE EXISTS
(
SELECT 1 FROM dbo.MasterHistory b WITH(NOLOCK)
WHERE b.OriginalTransactionNumber=TransactionNumber
)

--V3
DELETE a
FROM dbo.Master a
INNER JOIN dbo.MasterHistory b WITH(NOLOCK)
ON a.TransactionNumber=b.OriginalTransactionNumber

8.WHERE筛选子句要以选择性高的放在前面，选择性低或没有选择性的放在后面。JOIN … ON中的连接条件中要避免左右两边字段的类型转换，比如a.ItemNumber是NCHAR(25),而b.ItemNumber是VARCHAR(25),这样会严重影响性能。解决方案是，一在设计阶段注意规范，二是可以临时在JOIN … ON子句中做显式类型转换。另外，WHERE是筛选子句，JOIN … ON是连接语句，把筛选子句写在JOIN … ON上与写在WHERE后面没有区别，但是感觉两者职责不分，代码不够幽雅。

先写到这里，以后有更多经验，心得再来更新。如果你有更多经验，不妨民分享于我。谢谢。

本文链接