C# Comment exporter une solution DataTable vers Excel

Récemment, parce que le projet de l'entreprise nécessite que tous les journaux des opérations des utilisateurs dans le système soient transférés et sauvegardés, et considérant qu'ils devront peut-être être restaurés à l'avenir, nous avons finalement décidé de sauvegarder les données des journaux sur Excel.

Ce qui suit est tout le code de la classe Excel.cs de mon projet. Grâce à cette classe, les données du DataTable peuvent être facilement importées dans la méthode Excel.

Tout d'abord, vous devez télécharger l'assembly NPOI.dll. Le code de la classe
est le suivant :

using System; 
using NPOI.HSSF; 
using NPOI.HPSF; 
using NPOI.HSSF.UserModel; 
using NPOI.HSSF.Util; 
using NPOI.SS.UserModel; 
using System.Collections; 
using System.IO; 
using System.Data; 
namespace BackupAttach 
{ 
public class Excel 
{ 
private HSSFWorkbook _workBook; 
private ISheet _wbSheet = null; 
private DataColumnCollection _columns = null; 
private int _col = 0; //total columns 
private int _row = 0; //total rows 
private int _sheet = 0; //total sheets 
private int _sheetRowNum = 65536; //each sheet allow rows 
public Excel() 
{ 
InstanceWorkBook(); 
} 
/// <summary> 
/// 实例方法 
/// </summary> 
/// <param name="sheetRowNum">单个表单允许的最大行数</param> 
public Excel(int sheetRowNum) 
{ 
_sheetRowNum = sheetRowNum; 
InstanceWorkBook(); 
} 
/// <summary> 
/// 实例方法 
/// </summary> 
/// <param name="columns">表头</param> 
public Excel(DataColumnCollection columns) 
{ 
_columns = columns; 
InstanceWorkBook(); 
} 
private void InstanceWorkBook() 
{ 
/////cretate WorkBook 
_workBook = new HSSFWorkbook(); 
var dsi = PropertySetFactory.CreateDocumentSummaryInformation(); 
dsi.Company = "BaiyiTimes"; 
_workBook.DocumentSummaryInformation = dsi; 
////create a entry of SummaryInformation 
var si = PropertySetFactory.CreateSummaryInformation(); 
si.Subject = "Etimes Secure Document System Log Backup"; 
_workBook.SummaryInformation = si; 
} 
private DataColumnCollection GetColumns(DataColumnCollection columns) 
{ 
return columns == null || columns.Count == 0 ? _columns : columns; 
} 
private ISheet GetSheet(ISheet sheet) 
{ 
return sheet == null ? _wbSheet : sheet; 
} 
private void CreateHeader(ISheet sheet, DataColumnCollection columns) 
{ 
_columns = GetColumns(columns); 
/////create row of column 
var oRow = sheet.CreateRow(0); 
foreach (DataColumn column in _columns) 
{ 
var oCell = oRow.CreateCell(_col); 
var style1 = _workBook.CreateCellStyle(); 
style1.FillForegroundColor = HSSFColor.BLUE.index2; 
style1.FillPattern = FillPatternType.SOLID_FOREGROUND; 
style1.Alignment = HorizontalAlignment.CENTER; 
style1.VerticalAlignment = VerticalAlignment.CENTER; 
var font = _workBook.CreateFont(); 
font.Color = HSSFColor.WHITE.index; 
style1.SetFont(font); 
oCell.CellStyle = style1; 
var name = column.ColumnName; 
oCell.SetCellValue(name.ToString()); 
_col++; 
} 
///// header belong to rows 
_row++; 
} 
private void CreateHeader(ISheet sheet) 
{ 
CreateHeader(sheet, null); 
} 
public ISheet CreateSheet() 
{ 
return CreateSheet(null); 
} 
public ISheet CreateSheet(DataColumnCollection columns) 
{ 
_wbSheet = _workBook.CreateSheet((_sheet + 1).ToString()); 
CreateHeader(_wbSheet, columns); 
_sheet++; 
return _wbSheet; 
} 
public void SetRowValue(DataRowCollection rows, ISheet sheet) 
{ 
_wbSheet = GetSheet(sheet); 
foreach (DataRow row in rows) 
{ 
SetRowValue(row); 
} 
} 
public void SetRowValue(DataRowCollection rows) 
{ 
SetRowValue(rows, null); 
} 
public void SetRowValue(DataRow row) 
{ 
// create a new sheet 
if (_row % _sheetRowNum == 0) 
{ 
CreateSheet(); 
} 
var oRow = _wbSheet.CreateRow(_row % _sheetRowNum); 
var obj = string.Empty; 
var cell = 0; 
foreach (DataColumn column in _columns) 
{ 
obj = row[column.ColumnName].ToString(); 
oRow.CreateCell(cell).SetCellValue(obj); 
cell++; 
} 
_row++; 
} 
public void SetProtectPassword(string password, string username) 
{ 
_workBook.WriteProtectWorkbook(password, username); 
} 
public void SaveAs(string filePath) 
{ 
if (File.Exists(filePath)) File.Delete(filePath); 
var file = new FileStream(filePath, FileMode.Create); 
_workBook.Write(file); 
file.Close(); 
} 
} 
}

Ce qui suit est une petite référence de démonstration :

public void DataTableToExcel(DataTable dt,string path) 
{ 
//instance excel object 
//Excel excel = new Excel(65536); 
Excel excel = new Excel(); 
//create a sheet 
excel.CreateSheet(dt.Columns); 
//write value into rows 
//excel.SetRowValue(dt.Rows); 
foreach (DataRow row in dt.Rows) 
{ 
excel.SetRowValue(row); 
} 
// set excel protected 
excel.SetProtectPassword("etimes2011@", "baiyi"); 
// save excel file to local 
excel.SaveAs(path); 
}

Inconvénients : Si la quantité de données à importer dans Excel est importante (des centaines de milliers ou des millions de lignes), tout mettre dans le DataTable en même temps peut consommer beaucoup de mémoire. importés à chaque fois ne doivent pas dépasser 1 000 éléments, les données peuvent être importées dans Excel via une requête de pagination.

Avantages : Chaque formulaire de la version 1997-2003 de xls ne prend en charge qu'un maximum de 65 536 lignes, et 2010 peut prendre en charge 1 048 576 lignes. Étant donné que les versions installées sur le client sont différentes, chaque formulaire d'objet Excel prend en charge un. maximum de 65536 lignes. , lorsque le formulaire atteint le nombre maximum de lignes, un nouveau formulaire sera automatiquement créé à l'intérieur de l'objet Excel. Vous n'avez pas besoin d'en tenir compte lors de l'écriture de données dans Excel, ce qui est plus pratique lors de l'appel de

Pour plus d'articles liés au C# sur la façon d'exporter des solutions DataTable vers Excel, veuillez faire attention au site Web PHP chinois !