DS 's RoOm

2012년 12월 19일 수요일

Stack Heap,,,메모리공간

아래와 같은 메소드와 변수들이 있을경우 메모리에서는 도대체 무슨일이 일어나는가??

출처 http://www.codeproject.com/Articles/76153/Six-important-NET-concepts-Stack-heap-value-types
다음에는 new로 인스턴스를 두개 생성했을경우의 그림이다.

이렇게 스택과 힙 두영역에 나누어 지고
힙영역의 메모리가 가득찬다면 C#? 닷넷에서는
Garbage Collecter가 자동적으로 메모리를 관리해준다.
사용하지 않거나 사용한지 오래된 것은 GC가 알아서 처리하여 메모리를관리해준다고 한다.
하지만 직접적인 GC 호출은 시스템에 성능저하를 유발할수 있어 불가피한상황이 아니라면 피해야한다고 함.

GC 사용을 하지말라면???
IDispose, Finalize 를 구현하자!!! 단, C#에서는 소멸자를 사용하지말자?
예를 들자면 대용량의 객체를 사용한뒤 시스템 부하를 줄여야 하는상황..

다음의 코드는 인자로 받아진 object의 메모리 주소를 알아보는 코드다
{

Thread 개념

Socket통신을 사용하다가 Client가 통신이 끊기게 되면
Server는 이를 알아채고 클라이언트의 접속을 다시 대기해야합니다.

Socket.Accept();

Accept()부분을 쓰레드로 생성하여
기본 스레드와 별개로 스레드를 생성해서 Accept()를 했습니다.
이러면 기본스레드에 대해 비동기적으로 Accept()를 수행됩니다.

스레드를 이해하고 얼마 지나지 않으면 스레드에 기억이..가물가물..
또 다시 스레드에대 학습하게 됩니다.-_-;;

간단히 스레드에 대해 알아봅시다.

public class Worker
{
    // This method will be called when the thread is started.
    public void DoWork()
    {
        while (!_shouldStop)
        {
            Console.WriteLine("worker thread: working...");
        }
        Console.WriteLine("worker thread: terminating gracefully.");
    }
    public void RequestStop()
    {
        _shouldStop = true;
    }
    // Volatile is used as hint to the compiler that this data
    // member will be accessed by multiple threads.
    private volatile bool _shouldStop;
}

public class WorkerThreadExample
{
    static void Main()
    {
        // Create the thread object. This does not start the thread.
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);

// Start the worker thread.
        workerThread.Start();
        Console.WriteLine("main thread: Starting worker thread...");

// Loop until worker thread activates.
        while (!workerThread.IsAlive);

// Put the main thread to sleep for 1 millisecond to
        // allow the worker thread to do some work:
        Thread.Sleep(1);

// Request that the worker thread stop itself:
        workerObject.RequestStop();

// Use the Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();
        Console.WriteLine("main thread: Worker thread has terminated.");
    }
}

Worker클래스의 DoWork 메소드를
Thread.Start() 메소드로 실행하여 줍니다.

workThread.IsAlive 는 현재 스레드의 실행상태를 나타내는 값을 가져옵니다.
스레드가 시작되었으며 정상적으로 종료 또는 중단되지 않았으면 true고, 그렇지않으면 false

Thread.Sleep(1); 이렇게 한다면 기본스레드가 잠시 중단하고
다른 스레드(workerThread)는 DoWork메소드의 루프를 몇차례 반복하여 실행할수 있습니다.
Thraed.Abort()는 다른 스레드에서 스레드를 종료 할수 있습니다.
하지만 스레드의 작업이 완료됬는지 관계없이 스레드가 종료되어 리소스를 정리할수없습니다.

그래서 기본스레드(메인)에서 Thread.Join()메소드를 호출하여
개체가 가리키는 스레드가 종료될때까지 현재 스레드를 차단하거나 대기상태로 만듭니다.
Join()은 작업자스레드가 반환되고 자체 종료될떄까지 반환되지 않습니다.

관련내용은 http://msdn.microsoft.com/ko-kr/library/7a2f3ay4(v=vs.90).aspx
다음글에서 쓰레드와 관련되는 클래스를 만들어 사용해 보기로 합시다.

사용자정의 컨트롤 만들어보기 (ProgressBar)

C# 닷넷 컴포넌트의 ProgressBar가 있습니다.
닷넷 프로그래스바의 내부에 Text라던가 Label을 넣어
프로그래스바와 내부에 글자를 넣어 보겠습니다.
우리가 만들것은 아래의 그림과 같은 ProgressBar 사용자 정의 컨트롤 입니다.

추가 => 사용자 정의컨트롤을 선택하여 CProgressBar.cs 를 생성합니다.
이제 코딩을 시작해 봅시다.
우선, 디자인부분에서 프로그래스바와 내부에 위치할 Text를 가질 Label을 넣어줍니다.

하나의 TableLayoutPanel(열 두개)을 만들고
각 열에 Label을 만들어넣습니다(구분을 명확하게 하기위해 Color를 임의로 넣어준겁니다.)
TableLayoutPanel과 Label의 BackColor는 투명하게 해줍니다(TransParent)
코드를 살펴봅시다.

CProgressBa 생성자에 디자이너부분에서 만든 Label들의 ForeColor와 Font를 지정합니다.
(불필요한 작업같군요. 안해줘도 될거 같아요)
맴버 변수 선언부분입니다.
Pen pen은 열을 구분하기 위해 OnPaint시 사용할 Color입니다.
┌───────────┐
│ │ │
└───────────┘빨간 구분선

protected 선언된 맴버변수는 디자이너의 속성창을 보면 생성되어져 보입니다.
속성창에서 값을 변경하게 되면 아래의 맴버변수들의 변경되는거지요.
protected로 선언되었으니 이를 대신 받아줄 get; set 변수들이 필요합니다.
아래에서 Value 즉 Percent값의 변경될때마다 Invalidate()를 호출하는데요
this.Invalidate()메소드를 호출할때마다 OnPaint()메소드를 재 호출 합니다

public Color MEDOCOLOR
        {
            get { return MedoColor; }
            set { MedoColor = value; }
        }
        public Color MESUCOLOR
        {
            get { return MesuColor; }
            set { MesuColor = value; }
        }
        public float Value
        {
            get { return percent; }
            set
            {
                //if (value < 0) value = 0;
                //else if (value > 100) value = 100;
                percent = value;
                this.Invalidate();
            }
        }
        [System.ComponentModel.Bindable(true)]
        public string JANRYANG
        {
            get { return JanRyang; }
            set
            {
                JanRyang = value;
                // 매도, 매수
                if (this.RightToLeft) { this.label2.Text = JanRyang; }
                else { this.label1.Text = JanRyang; }
            }
        }
        [System.ComponentModel.Bindable(true)]
        public string DEBI
        {
            get { return Debi; }
            set
            {
                Debi = value;
                // 매도, 매수
                if (this.RightToLeft) { this.label1.Text = Debi; }
                else { this.label2.Text = Debi; }
            }
        }
        [System.ComponentModel.Bindable(true)]
        public bool RIGHT2LEFT
        {
            get { return RightToLeft; }
            set { this.RightToLeft = value; }
        }
        public float MAXIMUM
        {
            get { return Maximum; }
            set { Maximum = value; }
        }

OnPaint 메소드를 오버라이드 해서 필요한 것을 그려주면 되는것이지요
ClientRectangle은 컨트롤 영역의 사각형을 가지고 계산식으로
Rectangle에 색깔을 입히게 되는겁니다.

protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            try
            {
                Rectangle rect = ClientRectangle;
                Rectangle lb;

if (RightToLeft)
                {
                    lb = new Rectangle(rect.Width - (int)Math.Round(((float)Value / Maximum) * rect.Width), rect.Y + bar_gap,
                        (int)Math.Round(((float)Value / Maximum) * rect.Width), rect.Height - bar_gap * 2);
                    e.Graphics.FillRectangle(new SolidBrush(MedoColor), lb);
                }
                else
                {
                    lb = new Rectangle(rect.X, rect.Y + bar_gap, (int)Math.Round(((float)Value / Maximum) * rect.Width), rect.Height - bar_gap * 2);
                    e.Graphics.FillRectangle(new SolidBrush(MesuColor), lb);
                }

e.Graphics.DrawLine(pen, new Point(this.Size.Width / 2, 0), new Point(this.Size.Width / 2, this.Size.Height));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Catch Error CProgressBa::OnPaint " + ex.Message);
            }
        }

// Resize 자동조절
        protected override void OnSizeChanged(EventArgs e)
        {
            base.OnSizeChanged(e);
            try
            {
                label1.Location = new Point(this.Width / 4 - 21 / 2 - 4, this.Height / 2 - 15 / 2);
                label2.Location = new Point(this.Width - this.Width / 4 - 21 / 2 - 4, this.Height / 2 - 15 / 2);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Catch Error CProgressBa::OnSigeChanged" + ex.Message);
            }
        }

}// close CProgressBar

Socket(Tcp) 비동기 Client

public class AsyncClient
    {
        private Socket hSock;

private Socket ConnSock;
        private byte[] m_ReceiveByte;
        private const int MAXSIZE = 1024;
        private string HOST = "127.0.0.1";
        private int PORT = 9999;
        
        public AsyncClient()
        {
            hSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            m_ReceiveByte = new byte[MAXSIZE];
        }

//##########################
        //  Connet
        public void BeginConnect()
        {
            Console.WriteLine("서버로 접속 대기중입니다.......");
            try
            {
                hSock.BeginConnect(HOST, PORT, new AsyncCallback(ConnectCallBack), hSock);
            }
            catch (SocketException se)
            {
                Console.WriteLine("서버에 접속 실패했습니다...  {0} , {1}", se.Message, se.SocketErrorCode);
            }

}

//   CallBack COnnect
        private void ConnectCallBack(IAsyncResult ar)
        {
            try
            {
                // 보류중인 연결을 완성
                Socket s = (Socket)ar.AsyncState;
                IPEndPoint serEP = (IPEndPoint)s.RemoteEndPoint;
                Console.WriteLine("서버로 접속 성공..... serverIP: {0}, Port: {1}", serEP.Address, serEP.Port);
                s.EndConnect(ar);
                ConnSock = s;

ConnSock.BeginReceive(this.m_ReceiveByte, 0, m_ReceiveByte.Length, SocketFlags.None,
                                    new AsyncCallback(OnReceiveCallBack), ConnSock);
            }
            catch (SocketException se)
            {
                if (se.SocketErrorCode == SocketError.NotConnected)
                {
                    Console.WriteLine("서버에 접속 실패했습니다...  {0} , {1}", se.Message, se.SocketErrorCode);
                    //   접속 실패시 연결 재호출
                    this.BeginConnect();
                }
            }
        }

// SEND
        public void BeginSend(string message)
        {
            try
            {
                //  연결 시 
                if (hSock.Connected)
                {
                    Console.WriteLine("서버로 데이터 전송 준비... {0}", message);
                    byte[] t_sendByte = new UTF8Encoding().GetBytes(message);
                    hSock.BeginSend(t_sendByte, 0, t_sendByte.Length, SocketFlags.None,
                                    new AsyncCallback(SendCallBack), message);
                }
            }
            catch (SocketException e)
            {
                Console.WriteLine("Send Errorr {0}, {1}", e.Message, e.SocketErrorCode);
            }
        }

//   Send CallBack
        private void SendCallBack(IAsyncResult ar)
        {
            string Message = (string)ar.AsyncState;
            Console.WriteLine("서버로 데이터를 전송했습니다... Text: {0}", Message);
        }

// Receive
        public void Receive()
        {
            ConnSock.BeginReceive(this.m_ReceiveByte, 0, m_ReceiveByte.Length,
                SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ConnSock);
        }
        
        // Receive CallBack
        private void OnReceiveCallBack(IAsyncResult ar)
        {
            try
            {
                Socket t_Sock = (Socket)ar.AsyncState;
                int num_read = t_Sock.EndReceive(ar);
                if (num_read != 0)
                {
                    string message = new UTF8Encoding().GetString(m_ReceiveByte, 0, num_read);
                    Console.WriteLine(message);
                }
                this.Receive();
            }
            catch (SocketException se)
            {
                if (se.SocketErrorCode == SocketError.ConnectionReset)
                {
                    this.BeginConnect();
                }
            }
        }

}   //  AsyncClient CLose

Socket(Tcp) 비동기 Server

c# Socket의 비동기 서버 입니다.
비동기 부분에서 눈여겨 봐야할부분은
BeginAccept <====> EndAccept
BeginSend <====> EndSend
BeginReceive <====> EndReceive
메소드들의 짝을 이뤄야한다는점입니다.
Socket.BeginSend()의 원형을 보면(MSDN Library 참고 및 검색) AsyncCallback 대리자
Object state 상태정보를 포함한 객체(사용자정의객체도 됨)를 눈여겨봐야할것같습니다.
예외처리시 SocketException이 발생하는데요
SocketException.SocektErrorCode의 맴버들을 적절히 사용해야됩니다.
NotConnected = Socket의 연결되지 않은 상태로 응용프로그램에서 데이터를 보내고 받으...
ConnectionRefused = 원격호스트가 연결을 거부했습니다.
ConnectionReset = 원격피어가 연결을 다시 설정했습니다. 등등등.

public class AsyncServer
    {
        /// Begin Connect ==> EndConnet 메서드를 호출하여 완료
        /// 
        private Socket hsock;
        private byte[] buffer;
        private const int MAXSIZE = 1024;
        private StateObject so1;
        private StateObject so2;
        private UTF8Encoding utf8;
        //  private BackgroundWorker bw_Receiver;

public AsyncServer()
        {
            //  비동기라 쓰레드를 사용하지 않아도 되는것 같습니다.
            //  this.bw_Receiver = new BackgroundWorker();
            //  this.bw_Receiver.WorkerSupportsCancellation = true;
            //  this.bw_Receiver.DoWork +=new DoWorkEventHandler(bw_Receiver_DoWork);
            //  this.bw_Receiver.RunWorkerCompleted +=new RunWorkerCompletedEventHandler(bw_Receiver_RunWorkerCompleted);
            this.hsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            this.buffer = new byte[MAXSIZE];
            utf8 = new UTF8Encoding();
            this.so2 = new StateObject();
            // hsock.Connect(
        }
        public void Listen()
        {
            this.hsock.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9999));
            this.hsock.Listen(2);
            Array.Clear(buffer, 0, MAXSIZE);    //  c 에서 memset(&buff, 0, buff.length) 엯할
            Console.WriteLine("클라이언트 접속 대기 중입니다.....");
            this.hsock.BeginAccept(new AsyncCallback(OnListenCallBack), hsock);
        }

public void Send(string message)
        {
            byte[] sendByte = utf8.GetBytes(message);
            Socket t_Csock = this.so2.workSocket;
            t_Csock.BeginSend(sendByte, 0, sendByte.Length, SocketFlags.None, new AsyncCallback(OnSendCallBack), t_Csock);
        }

// Send CallBack
        private void OnSendCallBack(IAsyncResult ar)
        {
            Socket t_CientSock = (Socket)ar.AsyncState;
            int size = t_CientSock.EndSend(ar);
            //  전송이 성공적으로 되었다면 결과값으로 보낸 크기가 리턴(size)
            //  그렇지 않다면 에러가 나올것이다.
            if (size < 0)
            {
                Console.WriteLine("Sending.... 실패");
            }
        }

// Receive CallBack
        private void OnReceiveCallBack(IAsyncResult ar)
        {
            StateObject so = (StateObject)ar.AsyncState;
            Socket t_sock = so.workSocket;
            try
            {
                int read = t_sock.EndReceive(ar);
                IPEndPoint ep = (IPEndPoint)t_sock.RemoteEndPoint;
                
                Console.WriteLine("클라이언트로부터 데이터를 받았습니다.ip: {0}, port: {1}", ep.Address, ep.Port);

if (read > 0)
                {
                    //  so.sb.Append(utf8.GetString(so.buffer, 0, read));
                    Console.WriteLine("===> \t {0}", utf8.GetString(so.buffer, 0, read));
                    t_sock.BeginReceive(so.buffer, 0, StateObject.BUFFER_SIZE, SocketFlags.None,
                                        new AsyncCallback(OnReceiveCallBack), so);
                }
                else    //  데이터가 없다.
                {
                    if (so.sb.Length > 1)
                    {
                        string strContent;
                        strContent = so.sb.ToString();
                        Console.WriteLine(String.Format("Read {0} byte from socket" +
                                     "data = {1} ", strContent.Length, strContent));
                    }
                    t_sock.Close();
                }
            }
            catch (SocketException se)  // 클라이언트가 연결이 끊겼을경우
            {
                Console.WriteLine("Receive Catch Error {0}, {1}", se.Message, se.SocketErrorCode);
                if (se.SocketErrorCode == SocketError.ConnectionReset)
                {
                    this.hsock.Close();
                    Console.WriteLine("클라이언트 연결이 끊겼습니다. ");
                }
            }
        }

// Accept CallBack
        private void OnListenCallBack(IAsyncResult ar)
        {
            //  클라이언트가 접속한후에 종료하게 된다면 서버쪽에서는 에러가 남
            //  새로운 클라이언트가 올떄마나 새로운 클래스 객체를 생성하고
            //  클래스 객체안에서는 메세지를 주고 받을 byte형
            try
            {
                Socket t_sock = (Socket)ar.AsyncState;
                Socket s2 = t_sock.EndAccept(ar);
                IPEndPoint ep = (IPEndPoint)s2.RemoteEndPoint;
                
                Console.WriteLine("클라이언트가 접속 했습니다. ip: {0}, port: {1}", ep.Address, ep.Port);
                
                this.so2.workSocket = s2;           //  클라이언트 정보 
                s2.BeginReceive(so2.buffer, 0, MAXSIZE, SocketFlags.None,
                    new AsyncCallback(OnReceiveCallBack), so2);
            }
            catch (SocketException se)
            {
                Console.WriteLine(se.Message + " / " + se.SocketErrorCode);
            }
        }

public class AsyncServerEventArg : EventArgs
        {
            public bool ClientIsConnected;
            public IPEndPoint ClientEP;
            public string Message;
            public AsyncServerEventArg(bool isConnected, IPEndPoint ep)
            {
                this.ClientIsConnected = isConnected;
                this.ClientEP = ep;
            }
            public AsyncServerEventArg(string message)
            {
                this.Message = message;
            }
        }
        public delegate void ClientConnectedHandler(object sender, AsyncServerEventArg e);
        public event ClientConnectedHandler ClientIsConnected;

}// close AsycServer CLASS
}// CLOSE NameSpace

Socket(Tcp) 동기 Client

c# Socket(Tcp) 클라이언트를 구현해봤습니다.

private Socket sock;
        private IPAddress serverIp;
        private int serverPort = 9999;
        private IPEndPoint ipep;
        private BackgroundWorker bwReceiver;
        private byte[] receivebyte;
        private int idx = 0;
        
        //constructor
        public LocalSocketClient()
        {
            receivebyte = new byte[1024];
            serverIp = IPAddress.Parse("127.0.0.1");
            serverPort = 9999;
            ipep = new IPEndPoint(serverIp, serverPort);// 서버 끝점
            
            bwReceiver = new BackgroundWorker();
            bwReceiver.WorkerSupportsCancellation = true;
            bwReceiver.DoWork += new DoWorkEventHandler(bw_Receiver);
            bwReceiver.RunWorkerCompleted += new RunWorkerCompletedEventHandler(DisconnectFromReciver);
        }

private void DisconnectFromReciver(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                this.Connect();
            }
        }

public void Send(string str)
        {
            if (sock.Connected)
            {
                byte[] sendByte = new UTF8Encoding().GetBytes(str); //ASCIIEncoding.UTF8.GetBytes(buff)
                sock.Send(sendByte, sendByte.Length, SocketFlags.None);
            }
        }
        
        private void bw_Receiver(object sender, DoWorkEventArgs e)
        {
            string s_Receive = string.Empty;
            while (true)
            {
                Array.Clear(receivebyte, 0, receivebyte.Length);
                s_Receive = "";
                try
                {
                    if (sock.Connected)
                    {
                        int size = sock.Receive(receivebyte);
                        Console.WriteLine("받은 데이터 글자수 : {0}", size);

s_Receive = ASCIIEncoding.UTF8.GetString(receivebyte);
                        this.Received(this, new ClientEventArgs(s_Receive.Trim('\0')));
                    }
                    else
                    {
                        Console.WriteLine("서버가 닫혔습니다");
                        break;
                    }
                }
                catch (SocketException se)
                {
                    if (se.SocketErrorCode == SocketError.ConnectionReset) //   클라이언트로부터 접속이 끊긴다면
                    {
                        Console.WriteLine("{0} Error code: {1}. Receiver BackgroundWork() ", se.Message, se.ErrorCode);
                        e.Cancel = true;
                        this.bwReceiver.CancelAsync();
                        break;
                    }
                }
            }
        }

public void Connect()
        {
            Console.WriteLine("서버 접속 중입니다...");
            sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

while (true)
            {
                try
                {
                    sock.Connect(ipep);     //  접속 에러 발생시 catch문 이동

if (sock.Connected)     //  접속 완료시 receive 백그라운드 작동
                    {
                        this.IsConnected(this, new ClientEventArgs(true));
                        bwReceiver.RunWorkerAsync();
                        Console.WriteLine("서버 접속 완료 ===> \t Receive Background 작동");
                        break;
                    }
                }
                catch (SocketException e)       //  서버 접속 에러 발생시 
                {
                    if (e.SocketErrorCode == SocketError.ConnectionRefused)
                    {
                        Console.WriteLine("서버 접속 실패 ===> \t 접속 대기중입니다.");
                    }
                }
            }
        }// close ServerConnect

//  Evevent Fire Class
        public class ClientEventArgs : EventArgs
        {
            public bool IsConnected;
            public string Message;
            public ClientEventArgs(string str)
            {
                this.Message = str;
            }
            public ClientEventArgs(bool isconnect)
            {
                this.IsConnected = isconnect;
            }
        }

public delegate void SendEventHandler(object sender, ClientEventArgs e);
        public event SendEventHandler SendDest;
        public delegate void ReceiveHandler(object sender, ClientEventArgs e);
        public event ReceiveHandler Received;
        public delegate void ConnectedEvnetHandler(object sender, ClientEventArgs e);
        public event ConnectedEvnetHandler IsConnected;

}// close TCLIENT

2012년 12월 17일 월요일

Socket(Tcp) 동기 Server

c# Socket(Tcp)를 이용한 싱글 서버를 구현해봤습니다. 수정할 부분이 많습니다.-_-

public class LocalSocket
    {
        private Socket m_hSock;     // host
        private Socket m_cSock;     // client
        private IPEndPoint m_hEp;
        private byte[] m_receiveByte;
        private BackgroundWorker m_bwReceiver;
        public static LocalSocket sockTrade;
        private readonly int MAXSIZE = 1024;
        private bool m_CLOSE = false;

public static LocalSocket Instance()
        {
            if (sockTrade == null)
            {
                sockTrade = new LocalSocket();
            }
            return sockTrade;
        }

private LocalSocket()
        {
            this.m_bwReceiver = new BackgroundWorker();
            this.m_bwReceiver.WorkerSupportsCancellation = true;
            this.m_bwReceiver.DoWork += new DoWorkEventHandler(bw_Receiver);
            this.m_bwReceiver.RunWorkerCompleted += new RunWorkerCompletedEventHandler(DisconnectFormClient);

try
            {
                this.m_hSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                this.m_hEp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9999);
                this.m_cSock = null;

this.m_receiveByte = new byte[MAXSIZE];

this.m_hSock.Bind(m_hEp);   //  bind
            }
            catch (SocketException se)
            {
                //
            }
        }

/// <summary>
        /// 1.  서버(자신)의 포트를 열고
        /// 2.  클라이언트의 연결시도 대기 -> 연결완료
        /// 3.  BackgroundWorker로 Receive(메소드 호출 )
        /// </summary>
        public void Open()
        {
            this.m_hSock.Listen(1);

//  Console.WriteLine("클라이언트 연결을 대기중입니다.....");

m_cSock = m_hSock.Accept();     // client instance 생성
            if (m_cSock.IsBound)            // 재차 확인
            {
                // Console.WriteLine("클라이언트 연결 완료.....");
                IPEndPoint ep = (IPEndPoint)m_cSock.RemoteEndPoint;
                if (this.ClientIsConnected != null)
                    this.ClientIsConnected(this, new LocalSocketEvent(true, ep));

//  Background 실행여부 
                if (!m_bwReceiver.IsBusy)
                    this.m_bwReceiver.RunWorkerAsync();     //  Receive Backgorund 호출
            }
            else
            {
                //  Disconnect Event Fire
                if (this.ClientFireDisConnected != null)
                    this.ClientFireDisConnected(this, new LocalSocketEvent(true));
            }
        }   //  close Open

public void Send(string str)
        {
            try
            {
                if (m_cSock.Connected)
                {
                    byte[] sendByte = new UTF8Encoding().GetBytes(str); 
                    m_cSock.Send(sendByte, sendByte.Length, SocketFlags.None);
                }
            }
            catch (SocketException se)
            {
                //  Sending Event Fire
                if (this.SendingFireError != null)
                    this.SendingFireError(this, new LocalSocketEvent(true));
                return;
            }
        }

public void Dispose()
        {
            try
            {
                if (this.m_hSock != null)
                {
                    this.m_CLOSE = true;
                    this.m_bwReceiver.CancelAsync();

if (this.m_cSock != null && this.m_cSock.Connected)
                    {
                        this.m_cSock.Close();
                    }

// this.m_hSock.Shutdown(SocketShutdown.Both);
                    this.m_hSock.Close();
                }
            }
            catch (SocketException e)
            {
                Console.WriteLine("LocalSocket Exception {0}, {1}", e.Message, e.SocketErrorCode);
            }
            Console.WriteLine(" localSocket CLOSE");
        }

/// <summary>
        /// 백그라운드로 데이터 계속 받음
        /// 중간에 연결 끊김시 재시작
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void bw_Receiver(object sender, DoWorkEventArgs e)
        {
            string t_Receive = string.Empty;

while (this.m_cSock.Connected)
            {
                try
                {
                    //    Console.WriteLine("클라이언트로부터 응답을 받을때까지 대기합니다...");

Array.Clear(this.m_receiveByte, 0, MAXSIZE);
                    int size = 0;

if ((size = m_cSock.Receive(this.m_receiveByte)) > 0)   // 
                    {
                        // Console.WriteLine("받은 데이터 charact 수: {0}", size);
                        t_Receive = new UTF8Encoding().GetString(m_receiveByte);

//  Receive Event Fire
                        if (this.Received != null)
                            this.Received(this, new LocalSocketEvent(t_Receive.Trim('\0')));
                    }
                }
                catch (SocketException se)
                {
                    if (se.SocketErrorCode == SocketError.ConnectionReset)   //  Client 접속이 끊김
                    {
                        // Console.WriteLine("{0} Error Code: {1}, Receiver BW()", se.Message, se.ErrorCode);
                        e.Cancel = true;

// Disconnecte Event Fire
                        if (this.ClientFireDisConnected != null)
                            this.ClientFireDisConnected(this, new LocalSocketEvent(true));
                        this.m_bwReceiver.CancelAsync();
                        break;
                    }
                }
            }   // close while
        }   // close bw_Receiver(objet sender, DoWorkEventArgs e);

private void DisconnectFormClient(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                if(!this.m_CLOSE)
                this.Open();    //  서버(본인) 다시 개방하고 클라이언트로 부터접속대기
            }
        }

public class LocalSocketEvent : EventArgs
        {
            public string Message;
            public bool ClientIsConnected;      //  연결
            public bool ClientIsDisConnected;   //  끊김
            public IPEndPoint ClientEP;

public LocalSocketEvent(string str)
            {
                this.Message = str;
            }
            public LocalSocketEvent(bool isConnected, IPEndPoint ep)
            {
                this.ClientIsConnected = isConnected;
                this.ClientEP = ep;
            }
            public LocalSocketEvent(bool isDisconnect)
            {
                this.ClientIsDisConnected = isDisconnect;
            }
        }   //  close SockTrade

//  받았을때 BW_RECEIVER 발생
        public delegate void ReceiverHandler(object sender, LocalSocketEvent e);
        public event ReceiverHandler Received;

//  클라이언트 접속시발생
        public delegate void ClientIsConnectHandler(object sender, LocalSocketEvent e);
        public event ClientIsConnectHandler ClientIsConnected;

//  클라이언트로 데이터 전송시 발생
        public delegate void SendErrorHandler(object sender, LocalSocketEvent e);
        public event SendErrorHandler SendingFireError;

public delegate void ClientFireDisConnect(object sender, LocalSocketEvent e);
        public event ClientFireDisConnect ClientFireDisConnected;

}
}