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

     前一篇写到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      }