[C# 윈폼] C# XML 파싱 후, XML 데이터 MSSQL 테이블에 저장하기

안녕하세요.

 

오늘은 C# 윈폼에서 XML 파싱 후, XML 데이터를 MSSQL 데이터베이스에 한 테이블에 저장하는 방법에 대해서 알려 드리려고 합니다.

 

이전에, XML 파싱 해서 해당 데이터를 DataGridView 컨트롤에 데이터바인딩 해서 보여주는 방법에 대해서 글을 포스팅 한적이 있었는데요.

 

그 포스팅에서 조금 더 응용하여 DB 연동까지 추가해서 XML 데이터를 DB에 저장시키는 방법도 소스코드로 어떻게 하는지 보여 드리도록 하겠습니다.

 

이전 XML 관련 포스팅

2020/12/15 - [C#/Windows Form] - [C# 윈폼] 윈폼 XML 파일 읽고 해당 데이터 DataGridView에 보여주기

 

다른 부연 설명은 없이 소스코드로 보여드린다는 점 참고해 주세요!

 

그럼 아래와 같이 먼저 빈 윈폼 프로젝트를 생성해 주시고 아래와 같이 각종 컨트롤들을 배치해 주시기 바랍니다.

 

윈폼 프로젝트 생성 및 각종 컨트롤 배치

 

위와 같이 Label, TextBox, Button, DataGridView 컨트롤을 배치해 주시기 바랍니다.

 

그리고 나서 이제 아래와 같이 여러가지의 클래스들이 필요한데요.

 

하나씩 생성해서 해당 소스코드를 그대로 따라 작성해 주시기 바랍니다.

 

 

Config.ini

 
[DATABASE]
IP=DESKTOP-OC6SJV6\BEOMBEOMJOJO
USER=test
PWD=1234
DB_NAME=BEOMBEOMJOJO

ini 파일은 데이터베이스 접속 연결에 필요한 정보를 사전에 미리 정의해서 해당 내용을 읽어서 그 내용을 이용하려고 만든 파일입니다.

 

해당 파일은 만드시고 “속성” 에서 필히 출력 디렉터리에 복사를 “항상 복사” 로 설정해 주셔야 합니다!!

 

FileManager.cs

using System;
using System.Runtime.InteropServices;
using System.Text;
 
namespace XML_Parser
{
    public delegate void UpdateConfigEventHandler();
 
    public class FileManager
    {
        public static String FileName
        {
            get { return _fileName; }
            set { _fileName = value; }
        }
 
        private static String _fileName = String.Empty;
 
        /// <summary>
        /// 파일 내 특정 key 에 해당하는 value 를 읽어서 반환하는 메서드
        /// </summary>
        /// <param name="section"></param>
        /// <param name="key"></param>
        /// <param name="def"></param>
        /// <param name="retval"></param>
        /// <param name="size"></param>
        /// <param name="filePath"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        private static extern int GetPrivateProfileString(String section, String key, String def, StringBuilder retval, int size, String filePath);
 
        /// <summary>
        /// 파일 내 특정 key 에 해당하는 value 에 값을 저장하는 메서드
        /// </summary>
        /// <param name="section"></param>
        /// <param name="key"></param>
        /// <param name="val"></param>
        /// <param name="filePath"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        private static extern long WritePrivateProfileString(String section, String key, String val, String filePath);
 
        /// <summary>
        /// GetPrivateProfileString() 메서드를 호출하는 메서드
        /// </summary>
        /// <param name="section"></param>
        /// <param name="key"></param>
        /// <param name="defValue"></param>
        /// <returns></returns>
        public static String GetValueString(String section, String key, String defValue)
        {
            StringBuilder temp = new StringBuilder(255);
            GetPrivateProfileString(section, key, defValue, temp, 255, _fileName);
            return temp.ToString();
        }
 
        /// <summary>
        /// WritePrivateProfileString() 메서드를 호출하는 메서드
        /// </summary>
        /// <param name="Section"></param>
        /// <param name="Key"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public static long SetValue(String Section, String Key, String Value)
        {
            long result = WritePrivateProfileString(Section, Key, Value, _fileName);
            return result;
        }
 
        /// <summary>
        /// 사용하지 않는 메서드
        /// </summary>
        /// <param name="section"></param>
        /// <param name="key"></param>
        /// <param name="defValue"></param>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static String GetValueString(String section, String key, String defValue, String filePath)
        {
            StringBuilder temp = new StringBuilder(255);
            GetPrivateProfileString(section, key, defValue, temp, 255, filePath);
            return temp.ToString();
        }
 
        /// <summary>
        /// 사용하지 않는 메서드
        /// </summary>
        /// <param name="Section"></param>
        /// <param name="Key"></param>
        /// <param name="Value"></param>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static long SetValue(String Section, String Key, String Value, String filePath)
        {
            long result = WritePrivateProfileString(Section, Key, Value, filePath);
            return result;
        }
    }
}
 
 

이 클래스는 Config.ini 파일의 내용을 읽어서 그 내용을 다룰 수 있게 해주는 클래스입니다.

 

MssqlManager.cs

using System;
using System.Data;
using System.Data.SqlClient;
using System.Runtime.InteropServices;
 
namespace XML_Parser
{
    public sealed class MssqlManager
    {
        private enum ExcuteResult { Fail = -2, Success = -1 };
 
        public string ConnectionString = string.Empty;
 
        public string IP { get; private set; }
        public string LastException { get; private set; }
 
        public SqlConnection Connection { get; private set; }
 
        private static MssqlManager instance;
 
        public static MssqlManager Instance
        {
            get
            {
                if (instance == null) instance = new MssqlManager();
 
                return instance;
            }
        }
 
        private SqlCommand _sqlCmd = null;
 
        public MssqlManager()
        {
            _sqlCmd = new SqlCommand();
        }
 
        public bool GetConnection()
        {
            try
            {
                if (ConnectionString == string.Empty)
                    SetConnectionString();
 
                Connection = new SqlConnection(ConnectionString);
 
                Connection.Open();
            }
            catch (Exception ex)
            {
                LastException = ex.ToString();
 
                return false;
            }
 
            if (Connection.State == ConnectionState.Open)
                return true;
            else
                return false;
        }
 
        public int ExecuteNonQuery(string query)
        {
            lock (this)
            {
                return Execute_NonQuery(query);
            }
        }
 
        public bool HasRows(string query)
        {
            lock (this)
            {
                SqlDataReader result = ExecuteReader(query);
 
                return result.HasRows;
            }
        }
 
        public SqlDataReader ExecuteReaderQuery(string query)
        {
            lock (this)
            {
                SqlDataReader result = ExecuteReader(query);
 
                return result;
            }
        }
 
        public DataSet ExecuteDsQuery(DataSet ds, string query)
        {
            ds.Reset();
 
            lock (this)
            {
                //dbLoger.WriteLog(LogType.Inform, string.Format("ExecuteDsQuery - {0}", query));
 
                return ExecuteDataAdt(ds, query);
            }
        }
 
        public DataSet ExecuteProcedure(DataSet ds, string procName, params string[] pValues)
        {
            lock (this)
            {
                return ExecuteProcedureAdt(ds, procName, pValues);
            }
        }
 
        public void CancelQuery()
        {
            _sqlCmd.Cancel();
        }
 
        public void Close()
        {
            Connection.Close();
        }
 
        #region private..........................................................
 
        [DllImport("wininet.dll")]
        private extern static bool InternetGetConnectedState(out int Description, int ReservedValue);
 
        private bool CheckConnection()
        {
            bool result = true;
 
            if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable() == false)
            {
                this.LastException = "네트워크 연결이 끊어졌습니다.";
                System.Windows.Forms.MessageBox.Show(this.LastException, "Error");
                result = false;
            }
            else if (this.Connection == null || this.Connection.State == ConnectionState.Closed)
            {
                result = this.GetConnection();
            }
 
            return result;
        }
 
        private void SetConnectionString()
        {
            string ip = FileManager.GetValueString("DATABASE", "IP", "");
            string user = FileManager.GetValueString("DATABASE", "USER", "");
            string pwd = FileManager.GetValueString("DATABASE", "PWD", "");
            string dbName = FileManager.GetValueString("DATABASE", "DB_NAME", "");
 
            string dataSource = string.Format(@"Data Source={0};Database={1};User Id={2};Password={3}", ip, dbName, user, pwd);
 
            this.IP = ip;
            this.ConnectionString = dataSource;
        }
 
        private int Execute_NonQuery(string query)
        {
            int result = (int)ExcuteResult.Fail;
 
            try
            {
                _sqlCmd = new SqlCommand
                {
                    Connection = this.Connection,
                    CommandText = query
                };
                result = _sqlCmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                LastException = ex.ToString();
 
                if (CheckConnection() == false)
                    return result;
            }
 
            return result;
        }
 
        private SqlDataReader ExecuteReader(string query)
        {
            SqlDataReader result = null;
 
            try
            {
                _sqlCmd = new SqlCommand
                {
                    Connection = this.Connection,
                    CommandText = query
                };
                result = _sqlCmd.ExecuteReader();
            }
            catch (Exception ex)
            {
                LastException = ex.ToString();
 
                if (CheckConnection() == false)
                    return result;
            }
 
            return result;
        }
 
        private DataSet ExecuteDataAdt(DataSet ds, string query)
        {
            try
            {
                SqlDataAdapter cmd = new SqlDataAdapter
                {
                    SelectCommand = _sqlCmd
                };
                cmd.SelectCommand.Connection = this.Connection;
                cmd.SelectCommand.CommandText = query;
                cmd.Fill(ds);
            }
            catch (Exception ex)
            {
                LastException = ex.Message.ToString();
 
                if (CheckConnection() == false)
                    return null;
            }
 
            return ds;
        }
 
        private DataSet ExecuteProcedureAdt(DataSet ds, string query, params string[] values)
        {
            try
            {
                SqlDataAdapter adapter = new SqlDataAdapter
                {
                    SelectCommand = _sqlCmd
                };
                adapter.SelectCommand.CommandText = query;
                adapter.SelectCommand.CommandType = CommandType.StoredProcedure;
                adapter.SelectCommand.Connection = this.Connection;
 
                for (int i = 0; i < values.Length; ++i)
                {
                    adapter.SelectCommand.Parameters.Add(values[i]);
                    //adapter.SelectCommand.Parameters.Add("params", values[i]);
                }
 
                adapter.Fill(ds);
 
                return ds;
            }
            catch (Exception ex)
            {
                this.LastException = ex.ToString();
 
                if (CheckConnection() == false)
                    return null;
            }
 
            return ds;
        }
 
        #endregion private..................................................................
    }
}
 
 

이 클래스는 DB 연결에 필요한 내용을 정의한 클래스 입니다. 참고로 데이터베이스는 MSSQL을 이용하였습니다.

 

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace XML_Parser
{
    static class Program
    {
        /// <summary>
        /// 해당 애플리케이션의 주 진입점입니다.
        /// </summary>
        [STAThread]
        static void Main()
        {
            // Config
            string configFile = "Config.ini";
            FileManager.FileName = $"{Environment.CurrentDirectory}\\{configFile}";
 
            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
            Application.ThreadException += Application_ThreadException;
 
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
 
        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            MessageBox.Show(e.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
 
        private static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
        {
            MessageBox.Show(e.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
}
 

프로그램 처음 만들 때 자동으로 생성되는 클래스이면서, 여기서 사전에 Config.ini 파일의 내용을 읽어올 예정 입니다.

 

Singleton.cs

using System;
 
namespace XML_Parser
{
    public class Singleton<T> where T : class, new()
    {
        private static readonly object _syncobj = new object();
        private static volatile T _instance = null;
        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_syncobj)
                    {
                        if (_instance == null)
                        {
                            _instance = new T();
                        }
                    }
                }
                return _instance;
            }
        }
 
        public delegate void ExceptionEventHandler(string LocationID, Exception ex);
    }
}
 

DB 연결은 단일체 패턴을 사용하여 객체를 다룰것이라서 그거에 필요한 내용을 정의한 클래스 입니다.

 

Student.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace XML_Parser
{
    public class Student
    {
        /// <summary>
        /// 학생 이름
        /// </summary>
        public string Name { get; set; }
 
        /// <summary>
        /// 학생 나이
        /// </summary>
        public int Age { get; set; }
 
        /// <summary>
        /// 학생 성적
        /// </summary>
        public string Grade { get; set; }
 
        /// <summary>
        /// 학생 학과
        /// </summary>
        public string Major { get; set; }
    }
}
 

학생의 정보를 정의한 클래스 입니다.

 

MainForm.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace XML_Parser
{
    public partial class Form1 : Form
    {
        public List<Student> stuList = new List<Student>();
 
        //Connect to DB
        private BackgroundWorker ConnectWorker = null;
 
 
        public Form1()
        {
            InitializeComponent();
 
            //이벤트 선언
            InitEvent();
        }
 
        /// <summary>
        /// 각종 이벤트 선언 메서드
        /// </summary>
        private void InitEvent()
        {
            this.Load += MainForm_Load;
            this.uiBtn_Load.Click += uiBtn_Load_Click;
            this.uiBtn_Parse.Click += uiBtn_Parse_Click;
            this.uiBtn_Insert.Click += uiBtn_Insert_Click;
        }
 
        private void MainForm_Load(object sender, EventArgs e)
        {
            ConnectDB();
            Data_View_Design();
        }
 
        private void uiBtn_Load_Click(object sender, EventArgs e)
        {
            GetOpenFile();
        }
 
        /// <summary>
        /// Connect to DB 
        /// </summary>
        private void ConnectDB()
        {
            if (this.ConnectWorker == null)
            {
                this.ConnectWorker = new BackgroundWorker();
                this.ConnectWorker.DoWork += ConnectWorker_DoWork;
                this.ConnectWorker.RunWorkerCompleted += ConnectWorker_RunWorkerCompleted;
            }
 
            this.ConnectWorker.RunWorkerAsync();
        }
 
        /// <summary>
        /// Try to connect DB
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ConnectWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            while (true)
            {
                try
                {
                    if (MssqlManager.Instance.GetConnection() == true)
                        break;
 
                    Thread.Sleep(1000);
                }
                catch { }
            }
        }
 
        private void ConnectWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            uiBtn_Parse.Invoke(new MethodInvoker(delegate ()
            {
                //uiBtn_Parse.Enabled = true;
            }));
        }
 
        private void uiBtn_Parse_Click(object sender, EventArgs e)
        {
            string fileName = uiTxt_FileName.Text;
 
            if (File.Exists(fileName) == false)
            {
                MessageBox.Show("File does not exist.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
 
            DataSet xmlDs = new DataSet();
 
            try
            {
                // XML File -> DataSet
                xmlDs.ReadXml(fileName);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
 
            if (xmlDs != null && xmlDs.Tables.Count > 0 && xmlDs.Tables[0].Rows.Count > 0)
            {
                //리스트에 학생들의 정보 저장
                AddStuList(xmlDs);
 
                //DataView Binding
                uiDGV_Main.DataSource = GetDataTable(xmlDs);
            }
        }
 
        /// <summary>
        /// 파싱된 XML 데이터 DB 테이블에 저장시키기
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void uiBtn_Insert_Click(object sender, EventArgs e)
        {
            string name = string.Empty;
            string age = string.Empty;
            string grade = string.Empty;
            string major = string.Empty;
 
            string query = string.Empty;
 
            for (int idx = 0; idx < stuList.Count; idx++)
            {
                name = stuList[idx].Name.ToString();
                age = stuList[idx].Age.ToString();
                grade = stuList[idx].Grade.ToString();
                major = stuList[idx].Major.ToString();
 
                query = @"
            INSERT INTO dbo.STUDENT 
            VALUES ('#NAME', '#AGE', '#GRADE', '#PHONENUMBER')
            ";
 
                query = query.Replace("#NAME", name);
                query = query.Replace("#AGE", age);
                query = query.Replace("#GRADE", grade);
                query = query.Replace("#PHONENUMBER", major);
 
                int result = MssqlManager.Instance.ExecuteNonQuery(query);
 
                if (result < 0)
                {
                    MessageBox.Show("DB Insert 실패");
                }
            }
 
            MessageBox.Show("데이터베이스 Insert 성공");
        }
 
        /// <summary>
        /// DataTable 생성
        /// </summary>
        /// <returns></returns>
        private DataTable GetDataTable(DataSet ds)
        {
            return ds.Tables[0];
        }
 
        /// <summary>
        /// XML 데이터 List에 저장
        /// </summary>
        private void AddStuList(DataSet ds)
        {
            for(int row = 0; row < ds.Tables[0].Rows.Count; row++)
            {
                Student stu = new Student(); //student 객체 생성
                stu.Name = ds.Tables[0].Rows[row]["STD_NAME"].ToString();
                stu.Age = Convert.ToInt32(ds.Tables[0].Rows[row]["STD_AGE"].ToString());
                stu.Grade = ds.Tables[0].Rows[row]["STD_GRADE"].ToString();
                stu.Major = ds.Tables[0].Rows[row]["STD_MAJOR"].ToString();
 
                stuList.Add(stu);
            }
        }
 
        /// <summary>
        /// OpenFileDialog 메서드
        /// </summary>
        private void GetOpenFile()
        {
            OpenFileDialog ofd = new OpenFileDialog
            {
                Filter = "XML files (*.xml)|*.xml|All files (*.*)|*.*",
                Title = "XML 파일 예제창"
            };
 
            if (ofd.ShowDialog() == DialogResult.OK)
                uiTxt_FileName.Text = ofd.FileName;
        }
 
        /// <summary>
        /// DataGridView 사이즈 조절
        /// </summary>
        private void Data_View_Design()
        {
            try
            {
                uiDGV_Main.AutoGenerateColumns = true;
                //DataGridView 사이즈에 맞게 자동 조정
                uiDGV_Main.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
                this.uiDGV_Main.EditMode = DataGridViewEditMode.EditOnEnter;
 
                //DataGridView 일반 Row열 디자인
                uiDGV_Main.BorderStyle = BorderStyle.None;
                uiDGV_Main.AlternatingRowsDefaultCellStyle.BackColor = Color.FromArgb(238, 239, 249);
                uiDGV_Main.CellBorderStyle = DataGridViewCellBorderStyle.Single;
                uiDGV_Main.DefaultCellStyle.Font = new Font("굴림", 11, FontStyle.Bold);
 
                //Row 오른쪽 정렬
                uiDGV_Main.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
                uiDGV_Main.DefaultCellStyle.SelectionBackColor = Color.LightSkyBlue;
                uiDGV_Main.DefaultCellStyle.SelectionForeColor = Color.WhiteSmoke;
                uiDGV_Main.BackgroundColor = Color.White;
 
                //DataGridView ColumnHeader 디자인
                uiDGV_Main.EnableHeadersVisualStyles = false;
                uiDGV_Main.ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.None;
                uiDGV_Main.ColumnHeadersDefaultCellStyle.Font = new Font("굴림", 11, FontStyle.Bold);
 
                //dataGridView.ColumnHeadersDefaultCellStyle.BackColor = Color.FromArgb(15, 50, 72);
                uiDGV_Main.ColumnHeadersDefaultCellStyle.BackColor = Color.FromArgb(15, 50, 72);
 
                //Header Colunm 오른쪽 정렬
                uiDGV_Main.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                uiDGV_Main.ColumnHeadersDefaultCellStyle.ForeColor = Color.White; //컬럼명 폰트 컬러
 
                //DataGridView RowHeader 디자인
                //dataGridView.RowHeadersDefaultCellStyle.BackColor = Color.FromArgb(15, 50, 72);
                uiDGV_Main.RowHeadersDefaultCellStyle.BackColor = Color.FromArgb(15, 50, 72);
                uiDGV_Main.RowHeadersDefaultCellStyle.Font = new Font("굴림", 11, FontStyle.Bold);
                uiDGV_Main.RowHeadersDefaultCellStyle.ForeColor = Color.White;// 로우명 폰트 컬러
                uiDGV_Main.RowHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}
 

메인 폼의 비하인드 클래스 내용입니다.

 

그럼 여기까지 모두 빠짐없이 작업을 해 주셨다면, 이제 프로그램을 실행 시켜 보도록 하겠습니다.

 

실행 결과

 

위와 같이 해당 STUDENT XML의 데이터를 잘 읽어서 파싱을 하고, Insert 버튼을 클릭하면 DB Student 테이블에 알맞게 Insert되어 저장된 모습을 확인하실 수 있습니다.

 

감사합니다.^^