WPF实现DataGrid导出CSV格式

一.首先介绍下CSV以及它和Excel的区别

逗号分隔值（Comma-Separated Values，CSV），其文件以纯文本形式存储表格数据（数字和文本），文件的每一行都是一个数据记录。每个记录由一个或多个字段组成，用逗号分隔。使用逗号作为字段分隔符是此文件格式的名称的来源，因为分隔字符也可以不是逗号，有时也称为字符分隔值。

CSV广泛用于不同体系结构的应用程序之间交换数据表格信息，解决不兼容数据格式的互通问题，一般按照传输双方既定标准进行格式定义，而其本身并无明确格式标准。

1、Excel
（1）. Excel不仅可以存储数据，还可以对数据进行操作
（2）. 任何用于解析Excel数据的编程语言库通常都会更大，更慢，更复杂
（3）. Excel导入数据时消耗更多的内存
2、CSV (即Comma Separate Values，这种文件格式经常用来作为不同程序之间的数据交互的格式。)
（1）. CSV文件在windows平台默认的打开方式是excel，但是它的本质是一个文本文件，它存储数据，但不包含格式，公式，宏等。它也被称为平面文件
（2）. CSV文件的体积更小，创建分发读取更加方便，适合存放结构化信息，比如记录的导出，流量统计等等
（3）. 导入CSV文件可以更快，而且消耗更少的内存

总结：excel中后缀为csv和xls，二者区别如下：
1、xls 文件就是Microsoft excel电子表格的文件格式。
2、csv是最通用的一种文件格式，它可以非常容易地被导入各种PC表格及数据库中

二.导出CSV的两种方式

第一种方式比较简单，但是在实际使用中会存在一定缺陷，比如当字段中有比较长的数字字段存在时，在用excel软件查看csv文件时就会变成科学技术法的表现形式。其实这个问题跟用什么语言导出csv文件没有关系。Excel显示数字时，如果数字大于12位，它会自动转化为科学计数法；如果数字大于15位，它不仅用于科学技术法表示，还会只保留高15位，其他位都变0

 

该案例是在MVVM模式下，代码量较少，大家可以根据自己的项目需求进行更改

 public ICommand TwoSpeedExportToCSV
        {
            get
            {
                return new DelegateCommand<DataGrid>((grid) =>
                {
                    SaveFileDialog objSFD = new SaveFileDialog()
                    {
                        DefaultExt = "csv",
                        Filter = "CSV Files (*.csv)|*.csv|Excel XML (*.xml)|*.xml|All files (*.*)|*.*",
                        FilterIndex = 1
                    };
                    if (objSFD.ShowDialog() == true)
                    {
                        string strFormat = objSFD.FileName;
                        grid.SelectAllCells();
                        grid.ClipboardCopyMode = DataGridClipboardCopyMode.IncludeHeader;
                        ApplicationCommands.Copy.Execute(null, grid);
                        grid.UnselectAllCells();
                        string result = (string)System.Windows.Clipboard.GetData(System.Windows.DataFormats.CommaSeparatedValue);
                        File.AppendAllText(strFormat, result, UnicodeEncoding.UTF8);
                        Clipboard.Clear();//清空粘贴板               
                        MessageBox.Show("导出成功");
                    }
                }
                );
            }

第二种方式比较通用，可以导出任何excel支持的格式

首先需要下载NPOI管理程序包，然后建立一个通用类ExcelHelper，如下：

using NPOI.HSSF.UserModel;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Windows.Controls;

namespace ElecWaterCICC.Tools
{
    public class ExcelHelper
    {
        #region 打开保存excel对话框返回文件名
        public static string SaveExcelFileDialog(string fileName)
        {
            var sfd = new Microsoft.Win32.SaveFileDialog()
            {
                DefaultExt = "xls",
                Filter = "excel files(*.xls)|*.xls|excel files(*.csv)|*.csv|All files(*.*)|*.*",
                FilterIndex = 1
            };
            sfd.FileName = fileName;
            if (sfd.ShowDialog() != true)
                return null;
            return sfd.FileName;
        }
        #endregion
        #region 打开excel对话框返回文件名
        public static string OpenExcelFileDialog()
        {
            var ofd = new Microsoft.Win32.OpenFileDialog()
            {
                DefaultExt = "xls",
                Filter = "excel files(*.xls)|*.xls|All files(*.*)|*.*",
                FilterIndex = 1
            };

            if (ofd.ShowDialog() != true)
                return null;
            return ofd.FileName;
        }
        #endregion
        #region 读excel
        public static DataTable ImportExcelFile()
        {
            DataTable dt = new DataTable();

            //打开excel对话框
            var filepath = OpenExcelFileDialog();
            if (filepath != null)
            {
                HSSFWorkbook hssfworkbook = null;
                #region//初始化信息
                try
                {
                    using (FileStream file = new FileStream(filepath, FileMode.Open, FileAccess.Read))
                    {
                        hssfworkbook = new HSSFWorkbook(file);
                    }
                }
                catch (Exception e)
                {
                    throw e;
                }
                #endregion
                var sheet = hssfworkbook.GetSheetAt(0);
                System.Collections.IEnumerator rows = sheet.GetRowEnumerator();
                for (int j = 0; j < (sheet.GetRow(0).LastCellNum); j++)
                {
                    dt.Columns.Add(Convert.ToChar(((int)'A') + j).ToString());
                }
                while (rows.MoveNext())
                {
                    HSSFRow row = (HSSFRow)rows.Current;
                    DataRow dr = dt.NewRow();
                    for (int i = 0; i < row.LastCellNum; i++)
                    {
                        var cell = row.GetCell(i);
                        if (cell == null)
                        {
                            dr[i] = "";
                        }
                        else
                        {
                            if (cell.CellType == NPOI.SS.UserModel.CellType.Numeric)
                            {
                                if (HSSFDateUtil.IsCellDateFormatted(cell))
                                {
                                    dr[i] = cell.DateCellValue;
                                }
                                else
                                {
                                    dr[i] = cell.NumericCellValue;
                                }
                            }
                            else if (cell.CellType == NPOI.SS.UserModel.CellType.Boolean)
                            {
                                dr[i] = cell.BooleanCellValue;
                            }
                            else
                            {
                                dr[i] = cell.StringCellValue;
                            }
                        }
                    }
                    dt.Rows.Add(dr);
                }
            }
            return dt;
        }
        #endregion

        #region list转datatable
        public static DataTable ListToDataTable<T>(IEnumerable<T> c)
        {
            var props = typeof(T).GetProperties();
            var dt = new DataTable();
            dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
            if (c.Count() > 0)
            {
                for (int i = 0; i < c.Count(); i++)
                {
                    ArrayList tempList = new ArrayList();
                    foreach (PropertyInfo item in props)
                    {
                        object obj = item.GetValue(c.ElementAt(i), null);
                        tempList.Add(obj);
                    }
                    dt.LoadDataRow(tempList.ToArray(), true);
                }
            }
            return dt;
        }
        #endregion

        #region 写入excel
        public static bool WriteExcel(DataTable dt, string fileName = "")
        {
            //打开保存excel对话框
            var filepath = SaveExcelFileDialog(fileName);
            if (filepath == null)
                return false;

            if (!string.IsNullOrEmpty(filepath) && null != dt && dt.Rows.Count > 0)
            {
                NPOI.HSSF.UserModel.HSSFWorkbook book = new NPOI.HSSF.UserModel.HSSFWorkbook();
                NPOI.SS.UserModel.ISheet sheet = book.CreateSheet("Sheet1");
                NPOI.SS.UserModel.IRow row = sheet.CreateRow(0);
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    row.CreateCell(i).SetCellValue(dt.Columns[i].ColumnName);
                }
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    NPOI.SS.UserModel.IRow row2 = sheet.CreateRow(i + 1);
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        row2.CreateCell(j).SetCellValue(Convert.ToString(dt.Rows[i][j]));
                    }
                }
                // 写入到客户端  
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
                {
                    book.Write(ms);
                    using (FileStream fs = new FileStream(filepath, FileMode.Create, FileAccess.Write))
                    {
                        byte[] data = ms.ToArray();
                        fs.Write(data, 0, data.Length);
                        fs.Flush();
                    }
                    book = null;
                }
            }
            return true;
        }
        #endregion
        #region DataGrid转DataTable
        public static DataTable ConvertToDataTable(System.Windows.Controls.DataGrid dataGrid)
        {
            System.Data.DataTable dt = new System.Data.DataTable();

            //获取表头
            for (int i = 0; i < dataGrid.Columns.Count; i++)
            {
                if (dataGrid.Columns[i].Visibility == System.Windows.Visibility.Visible)//只导出可见列  
                {
                    if (dataGrid.Columns[i].Header == null)
                    {
                        dt.Columns.Add(string.Empty);
                        continue;
                    }
                    dt.Columns.Add(dataGrid.Columns[i].Header.ToString());//构建表头  
                }
            }
            //获取内容
            for (int i = 0; i < dataGrid.Items.Count; i++)
            {
                int columnsIndex = 0;
                System.Data.DataRow row = dt.NewRow();
                for (int j = 0; j < dataGrid.Columns.Count; j++)
                {
                    if (dataGrid.Columns[j].Visibility == System.Windows.Visibility.Visible)
                    {

                        if (dataGrid.Items[i] != null && (dataGrid.Columns[j].GetCellContent(dataGrid.Items[i]) as TextBlock) != null)//填充可见列数据  
                        {
                            string str= (dataGrid.Columns[j].GetCellContent(dataGrid.Items[i]) as TextBlock).Text.ToString();
                            row[columnsIndex] = str;
                        }
                        else
                        {
                            row[columnsIndex] = "";
                        }
                        columnsIndex++;
                    }
                }
                dt.Rows.Add(row);
            }
            return dt;
        }
        /// <summary>
        /// DataGrid转DataTable
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dataGrid"></param>
        /// <param name="ennumber"></param>
        /// <returns></returns>
        public static DataTable ConvertToDataTable<T>(System.Windows.Controls.DataGrid dataGrid,List<T> ennumber)
        {
            System.Data.DataTable dt = new System.Data.DataTable();
            //获取表头
            for (int i = 0; i < dataGrid.Columns.Count; i++)
            {
                if (dataGrid.Columns[i].Visibility == System.Windows.Visibility.Visible)//只导出可见列  
                {
                    if (dataGrid.Columns[i].Header == null)
                    {
                        dt.Columns.Add(string.Empty);
                        continue;
                    }
                    dt.Columns.Add(dataGrid.Columns[i].Header.ToString());//构建表头  
                }
            }

            //获取内容
            foreach (var item in ennumber)
            {
                int columnsIndex = 0;
                System.Data.DataRow row = dt.NewRow();
                for (int j = 0; j < dataGrid.Columns.Count; j++)
                {
                    foreach (var type in item.GetType().GetProperties())
                    {
                        if (type.Name.Equals(dataGrid.Columns[j].SortMemberPath))
                        {
                            if (type.GetValue(item) != null)
                            {
                                string str = type.GetValue(item).ToString();
                                row[columnsIndex] = str;
                            }
                            else
                            {
                                row[columnsIndex] = "";
                            }
                            break;
                        }
                    }
                    columnsIndex++;
                }
                dt.Rows.Add(row);
            }
            return dt;
        }
        #endregion
    }
}

导出CSV 

public ICommand TwoSpeedExportToCSV
        {
            get
            {
                return new DelegateCommand<DataGrid>((grid) =>
                {
                    if (grid.Items.Count == 0)
                    {
                        MessageBox.Show("数据未加载,请查询后,在点击导出按键");
                       return;
                    }
                    List<ASMCHECKDATA_Entity> da = (grid.ItemsSource as ObservableCollection<ASMCHECKDATA_Entity>).ToList();
                    DataTable dt = ExcelHelper.ConvertToDataTable(grid, da);
                    if (dt == null)
                    {
                        MessageBox.Show("页面打开错误,请重新点击进入!");
                        return;
                    }
                    if (ExcelHelper.WriteExcel(dt, "稳态数据统计" + DateTime.Now.ToString("yyyy-MM-dd")))
                    {
                        MessageBox.Show("导出完成!");
                    }
                    else
                    {
                        MessageBox.Show("用户取消!");
                    }
                }
                );
            }
        }