Doridori C# 강의 2) 46. Excel 다루기 (Excel Export)

======================================================

안녕하세요 Doridori 입니다.

이번에도 참 오래 걸렸네요 ^^;;

이번에는 프로젝트 마무리 시기가 되어 바쁘다 보니 쉽지가 않네요;; 

시간보다도 정신적으로 쉽지 않은 듯 합니다.

하지만 블로그도 그렇고 유튜브도 그렇고 꾸준히 댓글 남겨 주시는 분들 덕분에 힘을 내고 있습니다. 

저도 열심히 준비 해서 생각한 부분까지는 완료 하도록 하겠습니다.

다들 화이팅 하시죠!!

======================================================

46. Excel 다루기 (Excel Export)

 

 

Source UI) (45강 전체 Source 사용)

Soruce 전체) Study_46_Excel Export (WordSearch_add).zip

교재) 46. Excel 다루기 (Excel Export).pdf

이번 강의 내용은 지난번 DB에서 이어지는 Excel Export에 관한 내용 입니다. 

프로젝트를 하다보면 꼭 필요한 기능이라고 할 수 있습니다. 

원래는 Excel 다루는 전체를 진행 하려고 했으나 Excel 연결 하는 방법이라던지 저장하는 방법만으로도 시간이 많이 필요 해서 Export를 진행 하는 방법들의 장단점이라던지 차이점 위주로 진행 하였습니다. 

(API를 사용 할 경우 외부에서 정의해 놓은 내용들을 가져다 사용하기 때문에 코드의 경우는 구글링 해서 사용해도 무방하고 어떤식으로 사용되는지 동작하는지를 알아보는 형태로 진행이 될것 같습니다. )

저는 다른분들이 조금더 쉽게 복사해서 사용 할 수 있도록 진행 하려고 하였습니다. 

지난 강의 내용을 Export 하는 형태로 작성 하였기 때문에 지난강의 전체코드와 DB를 지고 시작 하시면 될것 같습니다. 

강의)

이번에는 UI도 없고 내용이 별로 없어서 빨리 하겠다 싶었는데 안되나 봅니다. ^^;;;

요즘 드는 생각인데 지금 하고 있는 유튜브를 마무리하고 나면 기존에 올렸던 내용들을 편집해서 축약 하는 형태로 Lite Ver.을 따로 만드는 작업을 진행 해 볼까 싶기도 하네요 ㅜㅠ;;

(요즘 외롭나... 혼자 말이 많아지네요 ㅋㅋㅋ)

Source)

코드는 Main에서 호출 하는 부분, 그리고 Excel Export를 하기 위한 Class 부분만 올려 놓았습니다. 

지난 강의 코드와 합해서 보시면 될것 같습니다. 

(이 외 부분은 수정 한부분이 없습니다. ^^)

- Main

        /// <summary>
        /// Excel Export 진행
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExport_Click(object sender, EventArgs e)
        {
            SFDialog.InitialDirectory = Application.StartupPath;
            SFDialog.FileName = "*.xls";
            SFDialog.Filter = "xls files (*.xls)|*.elx|All files (*.*)|*.*";
 
            if(SFDialog.ShowDialog() == DialogResult.OK)
            {
                ExcelExe excel = new ExcelExe();
                
                string strFilePath = SFDialog.FileName;
                DataTable dt = dgData.DataSource as DataTable;
 
                ExcelExe.enExportType enType = ExcelExe.enExportType.EXCEL_COM;
                //ExcelExe.enExportType enType = ExcelExe.enExportType.OLEDB_EXCEL;
                //ExcelExe.enExportType enType = ExcelExe.enExportType.CSV_STREAM;
 
                string strRet = excel.ExcelExport(strFilePath, dt, enType);
                MessageBox.Show(strRet);
 
            }
        }

- ExcelExe

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
using System.Data.OleDb;
using System.IO;
 
namespace WordSearch
{
    class ExcelExe
    {
        /// <summary>
        /// Export 관련 Excel Type
        /// </summary>
        public enum enExportType
        {
            EXCEL_COM,
            OLEDB_EXCEL,
            CSV_STREAM,
        }
 
 
        public string ExcelExport(string SaveFilePath, DataTable dt, enExportType ExportType)
        {
            string strRet = null;
 
            switch (ExportType)
            {
                case enExportType.EXCEL_COM:
                    strRet = SaveExcel_COMAPI(SaveFilePath, dt);
                    break;
                case enExportType.OLEDB_EXCEL:
                    strRet = SaveExcel_OLEDB(SaveFilePath, dt);
                    break;
                case enExportType.CSV_STREAM:
                    strRet = SaveExcel_CSV(SaveFilePath, dt);
                    break;
                default:
                    strRet = "Code에서 Export Type이 잘못 지정 되었습니다.";
                    break;
            }
 
            return strRet;
        }
 
 
 
 
 
        #region Excel Com API 사용
        private string SaveExcel_COMAPI(string SaveFilePath, DataTable dt)
        {
            string strRet = null;
 
            //Microsoft.Office.Interop.Excel.Application
            Excel.Application excelApp = null;
            Excel.Workbook wb = null;
            Excel.Worksheet ws = null;
 
            try
            {
                // Excel 첫번째 워크시트 가져오기                
                excelApp = new Excel.Application();
                wb = excelApp.Workbooks.Add();
                ws = wb.Worksheets.get_Item(1) as Excel.Worksheet;
 
                // 데이타 넣기
                /*
                for (int iRow = 0; iRow < dt.Rows.Count; iRow++)
                {
                    DataRow dr = dt.Rows[iRow];

                    for (int iColumn = 0; iColumn < dr.ItemArray.Length; iColumn++)
                    {
                        ws.Cells[iRow + 1, iColumn + 1] = dr.ItemArray[iColumn];   // (Colunm, Row)
                    }
                }
                */
 
                int iRow = 1;
                foreach (DataRow dr in dt.Rows)
                {
                    int iColumn = 1;
                    foreach (var vitem in dr.ItemArray)
                    {
                        ws.Cells[iRow, iColumn] = vitem;   // (Colunm, Row)
                        iColumn++;
                    }
                    iRow++;
                }
 
                // 엑셀파일 저장
                wb.SaveAs(SaveFilePath, Excel.XlFileFormat.xlWorkbookNormal);
                wb.Close(true);
                excelApp.Quit();
 
                strRet = "Excel Export Success!!!";
            }
            catch (Exception ex)
            {
                strRet = $"Excel Export Failed : {ex.ToString()}";
            }
            finally
            {
                // Clean up
                ReleaseExcelObject(ws);
                ReleaseExcelObject(wb);
                ReleaseExcelObject(excelApp);
            }
            return strRet;
        }
 
        // 생성한 Object를 삭제 함
        private void ReleaseExcelObject(object obj)
        {
            try
            {
                if (obj != null)
                {
                    Marshal.ReleaseComObject(obj);
                    obj = null;
                }
            }
            catch (Exception ex)
            {
                obj = null;
                throw ex;
            }
            finally
            {
                GC.Collect();
            }
        }
        #endregion
 
 
 
        #region OleDB 사용
 
        /// <summary>
        /// OLEDB를 사용해서 Excel Export를 진행
        /// </summary>
        private string SaveExcel_OLEDB(string FilePath, DataTable dt)
        {
            try
            {
                string ExcelOleDbConnectionStringTemplate = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties=\"Excel 8.0;HDR=YES\";";
 
                string createTableWithHeaderScript = GenerateCreateTableCommand(dt);
 
                using (var conn = new OleDbConnection(String.Format(ExcelOleDbConnectionStringTemplate, FilePath)))
                {
                    if (conn.State != ConnectionState.Open)
                    {
                        conn.Open();
                    }
 
                    OleDbCommand cmd = new OleDbCommand(createTableWithHeaderScript, conn);
                    cmd.ExecuteNonQuery();
 
                    foreach (DataRow dataExportRow in dt.Rows)
                    {
                        AddNewRow(conn, dataExportRow);
                    }
                }
 
                return "Excel Export Success!!!";
            }
            catch (Exception ex)
            {
                return $"Excel Export Failed : {ex.ToString()}";
            }
        }
 
 
        //Row 입력
        private static void AddNewRow(OleDbConnection conn, DataRow dataRow)
        {
            string insertCmd = GenerateInsertRowCommand(dataRow);
 
            using (OleDbCommand cmd = new OleDbCommand(insertCmd, conn))
            {
                AddParametersWithValue(cmd, dataRow);
                cmd.ExecuteNonQuery();
            }
        }
 
        /// <summary>
        /// Row 기준으로 입력 할 Insert Query Command를 생성
        /// </summary>
        private static string GenerateInsertRowCommand(DataRow dataRow)
        {
            var stringBuilder = new StringBuilder();
            var columns = dataRow.Table.Columns.Cast<DataColumn>().ToList();
            var columnNamesCommaSeparated = string.Join(",", columns.Select(x => x.Caption));
            var questionmarkCommaSeparated = string.Join(",", columns.Select(x => "?"));
 
            stringBuilder.AppendFormat("INSERT INTO [{0}] (", dataRow.Table.TableName);
            stringBuilder.Append(columnNamesCommaSeparated);
            stringBuilder.Append(") VALUES(");
            stringBuilder.Append(questionmarkCommaSeparated);
            stringBuilder.Append(")");
            return stringBuilder.ToString();
        }
 
        /// <summary>
        /// 값을 가진 변수를 추가
        /// </summary>
        private static void AddParametersWithValue(OleDbCommand cmd, DataRow dataRow)
        {
            var paramNumber = 1;
 
            for (int i = 0; i <= dataRow.Table.Columns.Count - 1; i++)
            {
                if (!ReferenceEquals(dataRow.Table.Columns[i].DataType, typeof(int)) && !ReferenceEquals(dataRow.Table.Columns[i].DataType, typeof(decimal)))
                {
                    cmd.Parameters.AddWithValue("@p" + paramNumber, dataRow[i].ToString().Replace("'", "''"));
                }
                else
                {
                    object value = GetParameterValue(dataRow[i]);
                    OleDbParameter parameter = cmd.Parameters.AddWithValue("@p" + paramNumber, value);
                    if (value is decimal)
                    {
                        parameter.OleDbType = OleDbType.Currency;
                    }
                }
 
                paramNumber = paramNumber + 1;
            }
        }
 
        /// <summary>
        /// OLEDB 형으로 변경
        /// </summary>
        private static object GetParameterValue(object value)
        {
            if (value is string)
            {
                return value.ToString().Replace("'", "''");
            }
            return value;
        }
 
        // Table Header를 가지고 Table 생성
        private string GenerateCreateTableCommand(DataTable tableDefination)
        {
            StringBuilder stringBuilder = new StringBuilder();
            bool firstcol = true;
 
            stringBuilder.AppendFormat("CREATE TABLE [{0}] (", tableDefination.TableName);
 
            foreach (DataColumn tableColumn in tableDefination.Columns)
            {
                if (!firstcol)
                {
                    stringBuilder.Append(", ");
                }
                firstcol = false;
 
                string columnDataType = "CHAR(255)";
 
                switch (tableColumn.DataType.Name)
                {
                    case "String":
                        columnDataType = "CHAR(255)";
                        break;
                    case "Int32":
                        columnDataType = "INTEGER";
                        break;
                    case "Decimal":
                        columnDataType = "CURRENCY";
                        break;
                }
 
                stringBuilder.AppendFormat("{0} {1}", tableColumn.ColumnName, columnDataType);
            }
            stringBuilder.Append(")");
 
            return stringBuilder.ToString();
        }
 
        #endregion
 
 
 
        #region CSV
        private string SaveExcel_CSV(string FilePath, DataTable dt)
        {
            try
            {
                var lines = new List<string>();
 
                string[] columnNames = dt.Columns.Cast<DataColumn>().
                                                  Select(column => column.ColumnName).
                                                  ToArray();
 
                var header = string.Join(",", columnNames);
                lines.Add(header);
 
                var valueLines = dt.AsEnumerable()
                                   .Select(row => string.Join(",", row.ItemArray));
                lines.AddRange(valueLines);
                
                //File.WriteAllLines("Excel.csv", lines);
                File.WriteAllLines(FilePath, lines, Encoding.UTF8);
                return "Excel Export Success!!!";
            }
            catch (Exception ex)
            {
                return $"Excel Export Failed : {ex.ToString()}";
            }
        }
        #endregion
 
 
 
    }
}