IT 이야기

프로그램 설명

DataGridView 의 datasource 와 List class를 이용하는 방법입니다.

데이타베이스 4칙 연산을 수행합니다.

Contacts class 는 아래와 같습니다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Windows.Forms;
using DataGridViewExample.lib;


namespace DataGridViewExample.data
{
    public class Contacts
    {
        #region Properties
        public int Idx { get; set; }
        public string Name { get; set; }
        public string BirthInfo { get; set; }
        public string ZipCode { get; set; }
        #endregion

        #region Functions
        /// 

        // Add the contacts info
        /// 
        /// 
        public bool AddContacts()
        {
            bool retval = false;
            try
            { 
                SQLOperator sdo = new SQLOperator("SampleDBConnectionString");

                string query = @"insert into [dbo].[tbl_contacts](Name, BirthInfo, ZipCode)
                                    values(@Name, @BirthInfo, @ZipCode);";

                sdo.ExecuteNoneQuery(query,
                                    new SqlParameter[]
                                    {
                                        new SqlParameter("@Name", Name),
                                        new SqlParameter("@BirthInfo", BirthInfo),
                                        new SqlParameter("@ZipCode", ZipCode)
                                    },
                                    CommandType.Text);
                sdo.Dispose();

                retval = true;
            }
            catch (SqlException se)
            {
                Trace.WriteLine(se.Message);
                retval = false;
            }
            catch(Exception ex)
            {
                Trace.WriteLine(ex.Message);
                retval = false;
            }

            return retval;
        }

        /// 

        /// Modify the contacts info
        /// 
        /// 
        public bool ModifyContacts()
        {
            bool retval = false;
            try
            {
                SQLOperator sdo = new SQLOperator("SampleDBConnectionString");

                string query = @"update [dbo].[tbl_contacts]
                                set  Name = @Name, BirthInfo = @BirthInfo, ZipCode = @ZipCode
                                where Id = @Idx;";

                sdo.ExecuteNoneQuery(query,
                                    new SqlParameter[]
                                    {
                                        new SqlParameter("@Name", Name),
                                        new SqlParameter("@BirthInfo", BirthInfo),
                                        new SqlParameter("@ZipCode", ZipCode),
                                        new SqlParameter("@Idx", Idx)
                                    },
                                    CommandType.Text);
                sdo.Dispose();

                retval = true;
            }
            catch (SqlException se)
            {
                Trace.WriteLine(se.Message);
                retval = false;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
                retval = false;
            }

            return retval;
        }

        public bool RemoveContacts()
        {
            bool retval = false;
            try
            {
                SQLOperator sdo = new SQLOperator("SampleDBConnectionString");

                string query = @"delete from [dbo].[tbl_contacts]
                                where Id = @Idx;";

                sdo.ExecuteNoneQuery(query,
                                    new SqlParameter[]
                                    {
                                        new SqlParameter("@Idx", Idx)
                                    },
                                    CommandType.Text);
                sdo.Dispose();

                retval = true;
            }
            catch (SqlException se)
            {
                Trace.WriteLine(se.Message);
                retval = false;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
                retval = false;
            }

            return retval;
        }
        #endregion
    }
}

실행 화면

소스 파일 

DataGridViewExample.zip

데이타베이스 작업을 할시에 필요한 라이브러리를 소개합니다.

select, update, delete, insert 모두에 사용되며, ad-hoc 쿼리나 스토어프로시저 모두에 사용 가능합니다.

사용하는 방법

아래 예제는 모두 Contacts class 가 있어서, UI 버튼 클릭시 Contacts 클래스의 property 에 개별적인 값을 대입한 후, 필요한 작업을 수행합니다.

Contacts.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using DataGridViewExample.lib;

namespace DataGridViewExample.data
{
    public class Contacts
    {
        #region Properties
        public int Idx { get; set; }
        public string Name { get; set; }
        public string BirthInfo { get; set; }
        public string ZipCode { get; set; }
        #endregion

        #region Functions
        /// 

        // Add the contacts info
        /// 
        /// 
        public bool AddContacts()
        {
            bool retval = false;
            try
            { 
                SQLOperator sdo = new SQLOperator("SampleDBConnectionString");

                string query = @"insert into [dbo].[tbl_contacts](Name, BirthInfo, ZipCode)
                                    values(@Name, @BirthInfo, @ZipCode);";

                sdo.ExecuteNoneQuery(query,
                                    new SqlParameter[]
                                    {
                                        new SqlParameter("@Name", Name),
                                        new SqlParameter("@BirthInfo", BirthInfo),
                                        new SqlParameter("@ZipCode", ZipCode)
                                    },
                                    CommandType.Text);
                sdo.Dispose();

                retval = true;
            }
            catch (SqlException se)
            {
                Trace.WriteLine(se.Message);
                retval = false;
            }
            catch(Exception ex)
            {
                Trace.WriteLine(ex.Message);
                retval = false;
            }

            return retval;
        }

        /// 

        /// Modify the contacts info
        /// 
        /// 
        public bool ModifyContacts()
        {
            bool retval = false;
            try
            {
                SQLOperator sdo = new SQLOperator("SampleDBConnectionString");

                string query = @"update [dbo].[tbl_contacts]
                                set  Name = @Name, BirthInfo = @BirthInfo, ZipCode = @ZipCode
                                where Id = @Idx;";

                sdo.ExecuteNoneQuery(query,
                                    new SqlParameter[]
                                    {
                                        new SqlParameter("@Name", Name),
                                        new SqlParameter("@BirthInfo", BirthInfo),
                                        new SqlParameter("@ZipCode", ZipCode),
                                        new SqlParameter("@Idx", Idx)
                                    },
                                    CommandType.Text);
                sdo.Dispose();

                retval = true;
            }
            catch (SqlException se)
            {
                Trace.WriteLine(se.Message);
                retval = false;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
                retval = false;
            }

            return retval;
        }

        public bool RemoveContacts()
        {
            bool retval = false;
            try
            {
                SQLOperator sdo = new SQLOperator("SampleDBConnectionString");

                string query = @"delete from [dbo].[tbl_contacts]
                                where Id = @Idx;";

                sdo.ExecuteNoneQuery(query,
                                    new SqlParameter[]
                                    {
                                        new SqlParameter("@Idx", Idx)
                                    },
                                    CommandType.Text);
                sdo.Dispose();

                retval = true;
            }
            catch (SqlException se)
            {
                Trace.WriteLine(se.Message);
                retval = false;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
                retval = false;
            }

            return retval;
        }
        #endregion
    }
}

            SQLOperator sdo = new SQLOperator("SampleDBConnectionString");
            DataTable dt = sdo.ExecuteQuery("select Id, Name, BirthInfo, ZipCode from [dbo].[tbl_contacts]");

            dataGridView1.DataSource = dt;

            dt.Dispose();
            sdo.Dispose();

            SQLOperator sdo = new SQLOperator("SampleDBConnectionString");
            DataTable dt = sdo.ExecuteQuery("select Id, Name, BirthInfo, ZipCode from [dbo].[tbl_contacts]");

            List<Contacts>  pContact = new List<Contacts>();
            if(dt.Rows.Count > 0)
            {
                foreach(DataRow row in dt.Rows)
                {
                    pContact.Add(new Contacts()
                        {
                            Idx = Convert.ToInt32(row["Id"]),
                            Name = row["Name"].ToString(),
                            BirthInfo = row["BirthInfo"].ToString(),
                            ZipCode = row["ZipCode"].ToString()
                        });
                }
            }

            dataGridView1.DataSource = pContact;

            dt.Dispose();
            sdo.Dispose();

            Contacts contact = new Contacts();

            contact.Idx = Convert.ToInt32(lblIdx.Text);
            contact.Name = txtName.Text.Trim();
            contact.BirthInfo = txtBirthInfo.Text.Trim();
            contact.ZipCode = txtZipCode.Text.Trim();

            if (contact.ModifyContacts())
            {
                toolStripStatusLabel1.Text = Properties.Resources.AddConfirmMsg;
            }
            else
            {
                toolStripStatusLabel1.Text = Properties.Resources.AddErrorMsg;
            }

            Contacts contact = new Contacts();

            contact.Idx = Convert.ToInt32(lblIdx.Text);
            string message = string.Format("[{0}] 정보를 삭제하시겠습니까", txtName.Text.Trim());

            if (MessageBox.Show(message, "확인", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.OK)
            { 
                if (contact.RemoveContacts())
                {
                    toolStripStatusLabel1.Text = Properties.Resources.RemoveConfirmMsg;
                }
                else
                {
                    toolStripStatusLabel1.Text = Properties.Resources.RemoveErrorMsg;
                }
            }

            Contacts contact = new Contacts();

            contact.Name = txtName.Text.Trim();
            contact.BirthInfo = txtBirthInfo.Text.Trim();
            contact.ZipCode = txtZipCode.Text.Trim();

            if (contact.AddContacts())
            {
                toolStripStatusLabel1.Text = Properties.Resources.AddConfirmMsg;
            }
            else 
            { 
                toolStripStatusLabel1.Text = Properties.Resources.AddErrorMsg;
            }

데이타베이스 라이브러리는 아래와 같습니다.

SQLOperator.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace DataGridViewExample.lib
{
    /// 


    /// Summary description for SqlDataOperator
    /// 
    public class SQLOperator : IDisposable
    {
        private SqlConnection conn;
        private SqlCommand comm;
        private SqlDataAdapter adap;
        private SqlTransaction tran;

        public SqlConnection Connection
        {
            get
            {
                return conn;
            }
            set
            {
                conn = value;
            }
        }

        public SqlCommand Command
        {
            get
            {
                return comm;
            }
            set
            {
                comm = value;
            }
        }

        public SqlTransaction Transaction
        {
            get
            {
                return tran;
            }
        }

        public SQLOperator()
            : this("default")
        {
        }

        public SQLOperator(string connectionStringName)
        {
            conn = new SqlConnection(ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString);
            //conn = new SqlConnection(Properties.Settings.Default.SampleDBConnectionString);

            comm = new SqlCommand();
            comm.Connection = conn;
            adap = new SqlDataAdapter();
        }

        public SqlTransaction BeginTransaction()
        {
            if (conn.State == ConnectionState.Closed)
                conn.Open();

            tran = conn.BeginTransaction();

            return tran;
        }

        public void RollBackTran()
        {
            if (tran != null)
                tran.Rollback();
        }

        public void CommitTran()
        {
            if (tran != null)
                tran.Commit();
        }

        public SqlDataReader ExecuteReader(string query, SqlParameter[] parameters, CommandType commType)
        {
            comm.CommandType = commType;
            comm.CommandText = query;
            AddParameters(parameters);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            SqlDataReader dr = comm.ExecuteReader(CommandBehavior.CloseConnection);

            return dr;
        }

        public SqlDataReader ExecuteReader(string spName, SqlParameter[] parameters)
        {
            comm.CommandType = CommandType.StoredProcedure;
            comm.CommandText = spName;
            AddParameters(parameters);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            SqlDataReader dr = comm.ExecuteReader(CommandBehavior.CloseConnection);

            return dr;
        }

        public SqlDataReader ExecuteReader(string query)
        {
            comm.CommandType = CommandType.Text;
            comm.CommandText = query;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            SqlDataReader dr = comm.ExecuteReader(CommandBehavior.CloseConnection);

            return dr;
        }

        public object ExecuteScalar(string sql)
        {
            comm.CommandText = sql;
            comm.CommandType = CommandType.Text;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            object result = comm.ExecuteScalar();
            comm.Parameters.Clear();

            return result;
        }

        public object ExecuteScalar(string spName, SqlParameter[] parameters)
        {
            comm.CommandText = spName;
            comm.CommandType = CommandType.StoredProcedure;
            AddParameters(parameters);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            object result = comm.ExecuteScalar();
            comm.Parameters.Clear();

            return result;
        }

        public object ExecuteScalar(string spName, SqlParameter[] parameters, CommandType commType)
        {
            comm.CommandText = spName;
            comm.CommandType = commType;
            AddParameters(parameters);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            object result = comm.ExecuteScalar();
            comm.Parameters.Clear();

            return result;
        }

        public object ExecuteScalar(string spName, SqlParameter[] parameters, CommandType commType, SqlTransaction tran)
        {
            comm.Transaction = tran;

            return ExecuteScalar(spName, parameters, commType);
        }

        public object ExecuteScalar(string spName, SqlParameter[] parameters, SqlTransaction tran)
        {
            comm.Transaction = tran;

            return ExecuteScalar(spName, parameters);
        }

        public void ExecuteNoneQuery(string spName, SqlParameter[] parameters)
        {
            comm.CommandText = spName;
            comm.CommandType = CommandType.StoredProcedure;
            AddParameters(parameters);

            SqlParameter para = new SqlParameter("@RETURN_VALUE", SqlDbType.Int);
            para.Direction = ParameterDirection.ReturnValue;

            comm.Parameters.Add(para);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            comm.ExecuteNonQuery();
            comm.Parameters.Clear();
        }

        public void ExecuteNoneQuery(string spName, SqlParameter[] parameters, CommandType commType)
        {
            comm.CommandText = spName;
            comm.CommandType = commType;
            AddParameters(parameters);

            SqlParameter para = new SqlParameter("@RETURN_VALUE", SqlDbType.Int);
            para.Direction = ParameterDirection.ReturnValue;

            comm.Parameters.Add(para);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            comm.ExecuteNonQuery();
            comm.Parameters.Clear();
        }

        public int ExecuteNoneQuery_Retrun_Param(string spName, SqlParameter[] parameters, CommandType commType)
        {
            comm.CommandText = spName;
            comm.CommandType = commType;
            AddParameters(parameters);

            SqlParameter para = new SqlParameter("@RETURN_VALUE", SqlDbType.Int);
            para.Direction = ParameterDirection.ReturnValue;

            SqlParameter return_param = comm.Parameters.Add(para);

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            comm.ExecuteNonQuery();
            var return_param_1 = return_param.Value;
            comm.Parameters.Clear();
            return (int)return_param_1;
        }

        public void ExecuteNoneQuery(string spName, SqlParameter[] parameters, CommandType commType, SqlTransaction tran)
        {
            comm.Transaction = tran;

            ExecuteNoneQuery(spName, parameters, commType);
        }

        public void ExecuteNoneQuery(string spName, SqlParameter[] parameters, SqlTransaction tran)
        {
            comm.Transaction = tran;

            ExecuteNoneQuery(spName, parameters);
        }

        public void ExecuteNoneQuery(string sql, SqlTransaction tran)
        {
            comm.Transaction = tran;

            ExecuteNoneQuery(sql);
        }

        public void ExecuteNoneQuery(string sql)
        {
            comm.CommandText = sql;
            comm.CommandType = CommandType.Text;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            comm.ExecuteNonQuery();
        }

        public DataTable ExecuteQuery(string tableName, string spName, SqlParameter[] parameters)
        {
            DataTable dtResult = new DataTable(tableName);
            comm.CommandText = spName;
            comm.CommandType = CommandType.StoredProcedure;
            AddParameters(parameters);
            adap.SelectCommand = comm;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            adap.Fill(dtResult);

            comm.Parameters.Clear();
            return dtResult;
        }

        public DataTable ExecuteQuery(string tableName, string spName, SqlParameter[] parameters, CommandType commType)
        {
            DataTable dtResult = new DataTable(tableName);
            comm.CommandText = spName;
            comm.CommandType = commType;
            AddParameters(parameters);
            adap.SelectCommand = comm;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            adap.Fill(dtResult);

            comm.Parameters.Clear();
            return dtResult;
        }


        public DataSet ExecuteQueryToDS(string spName, SqlParameter[] parameters)
        {
            DataSet dsResult = new DataSet();
            comm.CommandText = spName;
            comm.CommandType = CommandType.StoredProcedure;
            AddParameters(parameters);

            adap.SelectCommand = comm;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            adap.Fill(dsResult);
            comm.Parameters.Clear();

            return dsResult;
        }

        public DataTable ExecuteQuery(string tableName, string sql)
        {
            DataTable dtResult = ExecuteQuery(sql);

            dtResult.TableName = tableName;

            return dtResult;
        }

        public DataTable ExecuteQuery(string sql)
        {
            DataTable dtResult = new DataTable();
            comm.CommandText = sql;
            comm.CommandType = CommandType.Text;
            adap.SelectCommand = comm;

            if (conn.State == ConnectionState.Closed)
                conn.Open();

            adap.Fill(dtResult);
            return dtResult;
        }

        private void AddParameters(SqlParameter[] parameters)
        {
            comm.Parameters.Clear();

            foreach (SqlParameter parameter in parameters)
            {
                comm.Parameters.Add(parameter);
            }
        }

        public string AntiInjection(string val)
        {
            val = RemoveScriptTag(val).Replace("'", "''");

            return val;
        }

        public static string RemoveScriptTag(string s)
        {
            System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex("(?<capture><[/]?script[a-zA-Z_0-9=\"\'\\s]*>)");

            System.Text.RegularExpressions.MatchEvaluator evaluator = new System.Text.RegularExpressions.MatchEvaluator(MatchReplace);

            return reg.Replace(s, evaluator);
        }

        public static string MatchReplace(System.Text.RegularExpressions.Match m)
        {
            string s = m.Groups["capture"].Value;

            s = s.Replace("<", "<").Replace(">", ">");

            return s;
        }

        #region IDisposable 멤버

        public void Dispose()
        {
            comm.Parameters.Clear();

            if (conn.State == ConnectionState.Open)
                conn.Close();
        }

        #endregion
    }
}

프로그램 설명

텍스트와 이미지 파일을 전송하는 예제입니다.

규칙은 아래 그림과 같습니다.

실행 후

연결 후

텍스트 전송 후

이미지 파일 전송 후

프로그램 작성 순서

1. 서버 프로그램

전체 소스는 아래에 있으며, 핵심적인 내용의 소스만 갈무리해서 올립니다.

AsyncSocketServer.zip

        public void ReceiveAsync()
        {
            socket.BeginReceive(lenBuffer, 0, lenBuffer.Length, SocketFlags.None, receiveCallBack, null);
        }

        public void receiveCallBack(IAsyncResult ar)
        {
            try
            {
                int rec = socket.EndReceive(ar);

                if (rec == 0)
                {
                    if (Disconnected != null)
                    {
                        Disconnected(this);
                        return;
                    }
                }

                if (rec != 4)
                {
                    throw new Exception();
                }
            }
            catch(SocketException se)
            {
                switch(se.SocketErrorCode)
                {
                    case SocketError.ConnectionAborted:
                    case SocketError.ConnectionReset:
                        if (Disconnected != null)
                        {
                            Disconnected(this);
                            return;
                        }
                        break;
                }
            }
            catch(ObjectDisposedException)
            {
                return;
            }
            catch(NullReferenceException)
            {
                return;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }

            buffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer, 0));

            socket.BeginReceive(buffer.Buffer, 0, buffer.Buffer.Length, SocketFlags.None, receivePacketCallBack, null);
        }

        public void receivePacketCallBack(IAsyncResult ar)
        {
            int rec = socket.EndReceive(ar);

            if (rec <= 0)
            {
                return;
            }

            buffer.BufStream.Write(buffer.Buffer, 0, rec);

            buffer.ToReceive -= rec;

            if (buffer.ToReceive > 0)
            {
                Array.Clear(buffer.Buffer, 0, buffer.Buffer.Length);

                socket.BeginReceive(buffer.Buffer, 0, buffer.Buffer.Length, SocketFlags.None, receivePacketCallBack, null);
                return;
            }

            if (DataReceived != null)
            {
                buffer.BufStream.Position = 0;
                DataReceived(this, buffer);
            }

            buffer.Dispose();

            ReceiveAsync();
        }

2. 클라이언트 프로그램

전체 소스는 아래에 있으며, 핵심적인 내용의 소스만 갈무리해서 올립니다.

AsyncSocketClient.zip

        void SendText(string text)
        {
            BinaryWriter bw = new BinaryWriter(new MemoryStream());
            bw.Write((int)Commands.String);
            bw.Write(text);
            byte[] data = ((MemoryStream)bw.BaseStream).ToArray();
            bw.BaseStream.Dispose();
            client.Send(data, 0, data.Length);
            data = null;
        }

        void SendImage(string path)
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(ms);
            byte[] b = File.ReadAllBytes(path);
            bw.Write((int)Commands.Image);
            bw.Write((int)b.Length);
            bw.Write(b);
            bw.Close();
            b = ms.ToArray();
            ms.Dispose();

            client.Send(b, 0, b.Length);
        }

프로그램 설명

바이트 배열을 이용한 파일 전송을 구현한 예시입니다.

이미지 파일 전송시 데이타 구조와 일반 텍스트 데이타 구조가 다르므로 아래에 그림으로 표시했습니다.

실행 후

이미지 파일 전송 후

메시지 전송 후

프로그램 작성

1. 데이타 버퍼 클래스 (StateObject.cs)

    class StateObject
    {
        // Client socket
        public Socket workSocket = null;

        public const int BufferSize = 4096;

        // Receive buffer
        public byte[] buffer = new byte[BufferSize];
    }

2. 서버 프로그램

    public partial class MainForm : Form
    {
        bool initialFlag = true;
        string receivedPath = string.Empty;
        enum DataPacketType { TEXT = 1, IMAGE };
        int dataType = 0;
        string textData = string.Empty;

        public MainForm()
        {
            InitializeComponent();

            Thread t_handler = new Thread(StartListening);
            t_handler.IsBackground = true;
            t_handler.Start();
        }

        public static ManualResetEvent allDone = new ManualResetEvent(false);
        private void StartListening()
        {
            IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 9050);
            Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                listener.Bind(localEP);
                listener.Listen(10);

                while(true)
                {
                    allDone.Reset();
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                    allDone.WaitOne();
                }
            }
            catch(SocketException se)
            {
                Trace.WriteLine(string.Format("SocketException :{0}", se.Message));
            }
            catch(Exception ex)
            {
                Trace.WriteLine(string.Format("Exception :{0}", ex.Message));
            }
        }

        private void AcceptCallback(IAsyncResult ar)
        {
            allDone.Set();

            Socket listener = ar.AsyncState as Socket;
            Socket handler = listener.EndAccept(ar);

            StateObject state = new StateObject();
            state.workSocket = handler;
            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
            initialFlag = true;
        }

        private void ReadCallback(IAsyncResult ar)
        {
            int fileNameLen = 0;
            string content = string.Empty;
            StateObject state = ar.AsyncState as StateObject;
            Socket handler = state.workSocket;
            int bytesRead = handler.EndReceive(ar);
            
            if(bytesRead > 0)
            {                
                if (initialFlag)
                {
                    dataType = BitConverter.ToInt32(state.buffer, 0);
                    if (dataType == (int)DataPacketType.IMAGE)
                    { 
                        fileNameLen = BitConverter.ToInt32(state.buffer, 4);
                        string fileName = Encoding.UTF8.GetString(state.buffer, 8, fileNameLen);

                        string pathUser = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
                        string pathDownload = Path.Combine(pathUser, "Downloads");

                        receivedPath = Path.Combine(pathDownload, fileName);

                        if (File.Exists(receivedPath))
                            File.Delete(receivedPath);
                    }
                    else if (dataType == (int)DataPacketType.TEXT)
                    {
                        textData = Encoding.UTF8.GetString(state.buffer, 4, bytesRead - 4);
                        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
                    }
                }

                if (dataType == (int)DataPacketType.IMAGE)
                {
                    BinaryWriter bw = new BinaryWriter(File.Open(receivedPath, FileMode.Append));
                    if (initialFlag)
                        bw.Write(state.buffer, 8 + fileNameLen, bytesRead - (8 + fileNameLen));
                    else
                        bw.Write(state.buffer, 0, bytesRead);

                    initialFlag = false;
                    bw.Close();
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
                }
            }
            else
            {
                if (dataType == (int)DataPacketType.IMAGE)
                {
                    pictureBox1.ImageLocation = receivedPath;
                    Invoke((MethodInvoker)delegate
                    {
                        lblMessage.Text = "Data has been received";
                    });
                }
                else if (dataType == (int)DataPacketType.TEXT)
                    Invoke((MethodInvoker)delegate
                    {
                        textBox1.AppendText(textData + Environment.NewLine);
                    });
            }
        }
    }

3. 클라이언트 프로그램

    public partial class MainForm : Form
    {
        string m_splitter = "'\\'";
        string m_fName = string.Empty;
        string[] m_split = null;
        byte[] m_clientData = null;
        enum DataPacketType { TEXT = 1, IMAGE };

        public MainForm()
        {
            InitializeComponent();
            
        }

        private void btnBrowse_Click(object sender, EventArgs e)
        {
            char[] delimeter = m_splitter.ToCharArray();

            openFileDialog1.Filter = "Image files (*.jpg, *.jpeg, *.jpe, *.jfif, *.png) | *.jpg; *.jpeg; *.jpe; *.jfif; *.png";
            openFileDialog1.ShowDialog();

            textBox1.Text = openFileDialog1.FileName;
            pictureBox1.ImageLocation = openFileDialog1.FileName;

            m_split = textBox1.Text.Split(delimeter);
            int limit = m_split.Length;

            m_fName = m_split[limit - 1].ToString();

            if (textBox1.Text != null)
                btnSend.Enabled = true;
        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            Thread t_handler = new Thread(SendData);
            t_handler.IsBackground = true;
            t_handler.Start();
        }

        private void SendData()
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            byte[] fileName = Encoding.UTF8.GetBytes(m_fName);
            byte[] fileData = File.ReadAllBytes(textBox1.Text);
            byte[] fileNameLen = BitConverter.GetBytes(fileName.Length);
            byte[] fileType = BitConverter.GetBytes((int)DataPacketType.IMAGE);
            // IMAGE(4 byte) + 파일이름(4 byte) + 파일이름길이(4 byte) + 데이타 길이
            m_clientData = new byte[fileType.Length + 4 + fileName.Length + fileData.Length];

            fileType.CopyTo(m_clientData, 0);
            fileNameLen.CopyTo(m_clientData, 4);
            fileName.CopyTo(m_clientData, 8);
            fileData.CopyTo(m_clientData, 8 + fileName.Length);
            
            clientSocket.Connect(IPAddress.Parse("192.168.0.11"), 9050);
            clientSocket.Send(m_clientData);
            clientSocket.Close();
        }

        private void btnSendText_Click(object sender, EventArgs e)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            byte[] textData = Encoding.UTF8.GetBytes(textBox2.Text);
            byte[] fileType = BitConverter.GetBytes((int)DataPacketType.TEXT);
            // TEXT(4 byte) + 데이타 길이
            m_clientData = new byte[fileType.Length + textData.Length];

            fileType.CopyTo(m_clientData, 0);
            textData.CopyTo(m_clientData, 4);

            clientSocket.Connect(IPAddress.Parse("192.168.0.11"), 9050);
            clientSocket.Send(m_clientData);
            clientSocket.Close();
        }
    }

프로그램 설명

SslStream 클래스를 이용한 통신 방법으로 구현 되었습니다.

보안이 없는 일반 tcp 서버/클라이언트와 비교해서 다른 점은 데이타를 주고 받기 전에 반드시 SSL 핸드세이크의 단계를 거친다는 점입니다.

아래는 msdn 에서 발취한 내용입니다.

https://msdn.microsoft.com/ko-kr/library/system.net.security.sslstream(v=vs.110).aspx

작업을 하기 전에 인증서를 만드는 방법을 알고 개발에 사용할 인증서를 만들어야 합니다.

1.

Makecert.exe (Certificate Creation Tool) 사이트에서 다음의 예제와 같이 도스 창에서 명령어를 실행해서 작성합니다.

makecert 파일은 Windows 8.1 을 기준으로 아래의 경로에 있습니다.

2.

Visual Studio 를 이용해서 인증서를 테스트 할 수 있는 환경, 즉 사용할 수 있는 인증서로 만듭니다.

여기에 보여지는 소스는 msdn 사이트에 나오는 소스이며 원본 사이트는 아래와 같습니다.

https://msdn.microsoft.com/ko-kr/library/system.net.security.sslstream(v=vs.110).aspx

실행 후

메시지 전송 후

프로그램 작성 방법

1. 서버 프로그램

using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Diagnostics;

    public sealed class SslTcpServer
    {
        static X509Certificate serverCertificate = null;

        public static void RunServer(string certificate, string password)
        {
            try
            {
                serverCertificate = new X509Certificate(certificate, password);
                
                TcpListener listener = new TcpListener(IPAddress.Any, 8080);
                listener.Start();

                while(true)
                {
                    Console.WriteLine("Waiting for a client to connect...");
                    Console.WriteLine();

                    TcpClient client = listener.AcceptTcpClient();
                    ProcessClient(client);
                }
            }
            catch(Exception ex)
            {
                Trace.WriteLine(string.Format("Error : {0}", ex.Message));
            }
        }

        static void ProcessClient(TcpClient client)
        {
            SslStream sslStream = new SslStream(client.GetStream(), false);

            try
            {
                sslStream.AuthenticateAsServer(serverCertificate, false, SslProtocols.Tls, true);
                
                // Set timeouts for the read and write to 5 seconds.
                //sslStream.ReadTimeout = 5000;
                //sslStream.WriteTimeout = 5000;

                // Read a message from the client.
                Console.WriteLine("Waiting for client message...");
                string messageData = ReadMessage(sslStream);
                Console.WriteLine("Received : {0}", messageData.Substring(0, messageData.IndexOf("$")));

                // Write a message to the client
                messageData = "[reply] " + messageData;
                byte[] message = Encoding.UTF8.GetBytes(messageData);
                sslStream.Write(message);
                Console.WriteLine("Sending hello message");
                Console.WriteLine();
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection.");
                sslStream.Close();
                client.Close();
                return;
            }
            finally
            {
                // The client stream will be closed with the sslStream
                // because we specified this behavior when creating
                // the sslStream.
                sslStream.Close();
                client.Close();
            }
        }

        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the client.
            // The client signals the end of the message using the
            // "$" marker.
            byte[] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];
                decoder.GetChars(buffer, 0, bytes, chars, 0);
                messageData.Append(chars);
                // Check for EOF or an empty message.
                if (messageData.ToString().IndexOf("$") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            SslTcpServer.RunServer("XYZ_Company_ver2.pfx", "agrafood01");

            Console.WriteLine("Press the any key to continue...");
            Console.ReadLine();
        }
    }

2. 클라이언트 프로그램

using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Diagnostics;
using System.Collections;

    public class SslTcpClient
    {
        private static Hashtable certtificateError = new Hashtable();

        // The following method is invoked by the RemoteCertificateValidationDelegate.
        public static bool ValidateServerCertificate(
              object sender,
              X509Certificate certificate,
              X509Chain chain,
              SslPolicyErrors sslPolicyErrors)
        {
            if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }

        public static void RunClient(string machineName, string serverName, string inputMessage)
        {
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient client = new TcpClient(machineName, 8080);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback(ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection.");
                client.Close();
                return;
            }

            // Encode a test message into a byte array.
            // Signal the end of the message using the "$".
            byte[] messsage = Encoding.UTF8.GetBytes(inputMessage + "$");
            // Send hello message to the server. 
            sslStream.Write(messsage);
            sslStream.Flush();

            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage.Substring(0, serverMessage.IndexOf("$")));


            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
            Console.WriteLine();
        }

        private static string ReadMessage(SslStream sslStream)
        {
            // Read the message sent by the server.
            // The end of the message is signaled using the "$" marker
            byte[] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;

            do
            {
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars, 0);
                messageData.Append(chars);

                if (messageData.ToString().IndexOf("$") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {            
            string inputMessage = string.Empty;

            do
            {
                Console.Write("Clients says: ");
                inputMessage = Console.ReadLine();
                SslTcpClient.RunClient("192.168.0.12", "XYZ Company", inputMessage);
            } while (inputMessage.ToLower() != "exit");
            
            Console.WriteLine("Press any key to continue...");
            Console.ReadLine();
        }
    }