블로그 이미지
따시쿵

calendar

1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31

Notice

2015. 1. 13. 16:16 C# with TCP/IP

프로그램 설명


msdn 에 있는 예제를 가지고 만든 버전입니다.


TcpListener 클래스 

http://msdn.microsoft.com/ko-kr/library/system.net.sockets.tcplistener(v=vs.110).aspx


TcpClient 클래스

http://msdn.microsoft.com/ko-kr/library/system.net.sockets.tcpclient(v=vs.110).aspx


클라이언트 버전은 사용자 입력을 반복적으로 입력받을 수 있게 수정했습니다.


클라이언트의 메시지를 서버가 받아서 대문자로 변경해 주는 작업만 처리합니다.



실행 후



메시지 전송 후




프로그램 작성 순서


1. 소켓/쓰레드과 관련한 네임스페이스를 서버/클라이언트 모두에 포함 시킵니다.

using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Diagnostics;


2. 서버 프로그램

        TcpListener server = null;
 
        public MainForm()
        {
            InitializeComponent();
            FormClosing += new FormClosingEventHandler(Form_Closing);
        }

        private void Form_Closing(object sender, FormClosingEventArgs e)
        {
            if (server != null)
                server = null;

            Application.Exit();
        }
        
        private void btnListen_Click(object sender, EventArgs e)
        {
            new Thread(delegate()
                {
                    try
                    {
                        // Set the TcpListener on port 14000.
                        Int32 port = 14000;
                        IPAddress localAddr = IPAddress.Parse("127.0.0.1");

                        // TcpListener server = new TcpListener(port);
                        server = new TcpListener(localAddr, port);
                        server.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

                        // Start listening for client requests.
                        server.Start();

                        // Buffer for reading data
                        Byte[] bytes = new Byte[256];
                        String data = null;
                        
                        // Enter the listening loop.
                        while (true)
                        {
                            Invoke((MethodInvoker)delegate
                            {
                                listBox1.Items.Add("Waiting for a connection... ");
                            });

                            // Perform a blocking call to accept requests.
                            // You could also user server.AcceptSocket() here.
                            TcpClient client = server.AcceptTcpClient();
                            Invoke((MethodInvoker)delegate
                            {
                                listBox1.Items.Add("Connected!");
                            });

                            data = null;

                            // Get a stream object for reading and writing
                            NetworkStream stream = client.GetStream();

                            int i;

                            // Loop to receive all the data sent by the client.
                            while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
                            {
                                // Translate data bytes to a ASCII string.
                                data = System.Text.Encoding.UTF8.GetString(bytes, 0, i);
                                Invoke((MethodInvoker)delegate
                                {
                                    listBox1.Items.Add(string.Format("Received: {0}", data));
                                });

                                // Process the data sent by the client.
                                data = data.ToUpper();

                                byte[] msg = System.Text.Encoding.UTF8.GetBytes(data);

                                // Send back a response.
                                stream.Write(msg, 0, msg.Length);
                                Invoke((MethodInvoker)delegate
                                {
                                    listBox1.Items.Add(string.Format("Sent: {0}", data));
                                    listBox1.Items.Add("");
                                });
                            }

                            // Shutdown and end connection
                            client.Close();
                        }  // end of outer while                    
                    }
                    catch (SocketException se)
                    {
                        MessageBox.Show(string.Format("SocketException: {0}", se.Message.ToString()));
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(string.Format("Exception: {0}", ex.Message.ToString()));
                    }
                    finally
                    {
                        // Stop listening for new clients.
                        server.Stop();
                    }
            }).Start();
        }

2. 클라이언트 프로그램


        private void btnSend_Click(object sender, EventArgs e)
        {
            string serverIP = textServerIP.Text;
            string sendData = textMessage.Text;

            SendMessage(serverIP, sendData);
        }

        private void SendMessage(string server, string message)
        {
            try
            {
                // Create a TcpClient.
                // Note, for this client to work you need to have a TcpServer 
                // connected to the same address as specified by the server, port
                // combination.
                Int32 port = 14000;
                TcpClient client = new TcpClient(server, port);

                // Translate the passed message into ASCII and store it as a Byte array.
                Byte[] data = System.Text.Encoding.UTF8.GetBytes(message);

                // Get a client stream for reading and writing.
                //  Stream stream = client.GetStream();

                NetworkStream stream = client.GetStream();

                // Send the message to the connected TcpServer. 
                stream.Write(data, 0, data.Length);

                Invoke((MethodInvoker)delegate
                {
                    listBox1.Items.Add(string.Format("Sent: {0}", message));
                });

                // Receive the TcpServer.response.

                // Buffer to store the response bytes.
                data = new Byte[256];

                // String to store the response ASCII representation.
                String responseData = String.Empty;

                // Read the first batch of the TcpServer response bytes.
                Int32 bytes = stream.Read(data, 0, data.Length);
                responseData = System.Text.Encoding.UTF8.GetString(data, 0, bytes);
                Invoke((MethodInvoker)delegate
                {
                    listBox1.Items.Add(string.Format("Received: {0}", responseData));
                    listBox1.Items.Add("");
                });

                // Close everything.
                stream.Close();
                client.Close();
            }
            catch (ArgumentNullException e)
            {
                MessageBox.Show(string.Format("ArgumentNullException: {0}", e.Message.ToString()));
            }
            catch (SocketException e)
            {
                MessageBox.Show(string.Format("SocketException: {0}", e.Message.ToString()));
            }
        }
posted by 따시쿵
2015. 1. 10. 18:03 C#

비동기 작업을 나타냅니다.


다음 예제에서는 TaskFactory.StartNew 메서드를 사용하여 작업을 시작하는 방법을 보여 줍니다.


출처 : http://msdn.microsoft.com/ko-kr/library/system.threading.tasks.task(v=vs.110).aspx


실행 화면


예제 프로그램

// Expected results:
// 		Task t1 (alpha) is created unstarted.
//		Task t2 (beta) is created started.
//		Task t1's (alpha) start is held until after t2 (beta) is started.
//		Both tasks t1 (alpha) and t2 (beta) are potentially executed on 
//           threads other than the main thread on multi-core machines.
//		Task t3 (gamma) is executed synchronously on the main thread.

            Action<object> action = (object obj) =>
                {
                    Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                        Task.CurrentId, obj.ToString(), Thread.CurrentThread.ManagedThreadId.ToString());
                };

            // Construct aun unstarted task
            Task t1 = new Task(action, "alpha");

            // Construct a started task
            Task t2 = Task.Factory.StartNew(action, "beta");

            // Block the main thread to demonstrate that t2 is executing
            t2.Wait();

            // Launch t1
            t1.Start();

            Console.WriteLine("t1 has been launched. (Main Thread={0})", Thread.CurrentThread.ManagedThreadId.ToString());

            // Wait for the task to finish
            t1.Wait();

            // Construct an unstarted task
            Task t3 = new Task(action, "gamma");

            // Run it synchronously
            t3.RunSynchronously();

            // Although the task was run synchronously. it is a good practice
            // to wait for it in the event exception were thrown by task.
            t3.Wait();

            // 프로그램 종료 방지
            Console.Read();



Task 를 만들어서 실행하는 방법들을 설명합니다.


실행 화면



예제 프로그램


        static void Main(string[] args)
        {
            // use an Action delegate and named method
            Task task1 = new Task(new Action(printMessage));

            // use an anonymous delegate
            Task task2 = new Task(delegate { printMessage(); });

            // use a lambda expressiion and a named method
            Task task3 = new Task(() => printMessage());

            // use a lambda expression and an anonymous method
            Task task4 = new Task(() => { printMessage(); });
            
            task1.Start();
            task2.Start();
            task3.Start();
            task4.Start();

            Console.WriteLine("Main method complete. Press <enter> to finish");
            Console.WriteLine("Main Thread={0}", Thread.CurrentThread.ManagedThreadId.ToString());
            Console.ReadLine();
        }

        private static void printMessage()
        {
            Console.WriteLine("Task={0}, Thread={1}",
                                    Task.CurrentId, Thread.CurrentThread.ManagedThreadId.ToString());
        }


Task<TResult> 를 보여주는 예제입니다.


실행 화면




예제 프로그램

        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            t.Wait();

            // Get the result (the Result property internally calls Wait) 
            Console.WriteLine("The sum is: " + t.Result);   // An Int32 value
            Console.ReadLine();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; n--)
                checked { sum += n; }
            return sum;
        }

posted by 따시쿵
2015. 1. 9. 10:22 C#

윈도우/콘솔 프로그램 중 로그 파일을 남기고 싶을 경우가 종종 있습니다.


클라이언트 경우에는 서버로 데이타를 전송한 목록을 가지고 있다거나 서버에서는 클라이언트에서 전송 된 데이타를 정상적으로 받았는지 확인 해 볼 필요가 있습니다. 이런 경우 텍스트 파일로 남기는 경우가 필요한데 이런 경우에 사용하면 됩니다.


멀티 쓰레드 환경에서 작동하도록 작성했으며 라이브러리와 사용 예제를 올립니다.


실행파일 폴더를 가져와서 Log 폴더를 작성하고, 일자별로 파일을 생성하며 시간별로 로그를 쌓습니다.



LogFile.cs


LogFile.cs


using System;
using System.Data;
using System.Configuration;
using System.IO;
using System.Diagnostics;

/// 
/// Summary description for LogFile
/// 
public class LogFile
{

    private static string strLogDir = System.IO.Directory.GetCurrentDirectory() + @"\Log\";
	private static string strLogFile = "Log";
    private static readonly object thisLock = new object();

	public LogFile()
	{
	}

	public static void SetLogPath(string strDir)
	{
		strLogDir = strDir;
	}

	public static void SetLogFile(string strFile)
	{
		strLogFile = strFile;
	}

	public static void WriteLog(string strLog)
	{
		WriteLog(strLog, LogCode.Infomation, strLogFile);
	}

	public static void WriteLog(string strLog, string strFileName)
	{

		WriteLog(strLog, LogCode.Infomation, strFileName, strLogDir);
	}

	public static void WriteLog(string strLog, string strFileName, string strPath)
	{
		WriteLog(strLog, LogCode.Infomation, strFileName, strPath);
	}

	public static void WriteLog(string strLog, LogCode logCode)
	{
		WriteLog(strLog, logCode, strLogFile);
	}

	public static void WriteLog(string strLog, LogCode logCode, string strFileName)
	{

		WriteLog(strLog, logCode, strFileName, strLogDir);
	}

	public static void WriteLog(string strLog, LogCode logCode, string strFileName, string strPath)
	{
		string strFullName;

		if (!Directory.Exists(strPath))
		{
			Directory.CreateDirectory(strPath);
		}

		if (strPath.EndsWith(@"\") == false || strPath.EndsWith("/") == false)
		{
			strPath = strPath + @"\";
		}
		strFullName = strPath + strFileName + "_" + DateTime.Now.ToShortDateString() + ".txt";

		string strFullLog = DateTime.Now.ToString("HH:mm:ss") + " (" + logCode.ToString() + ")" + " : " + strLog;

        lock(thisLock)
        { 
		    StreamWriter sw = new StreamWriter(strFullName, true, System.Text.Encoding.UTF8, 4096);
		    sw.WriteLine(strFullLog);
		    sw.Close();
        }
	}

	public enum LogCode
	{
		Infomation = 0,
		Success = 1,
		Error = -1,
		Failure = -2,
		Warning = -10,
		SystemError = -101,
		ApplicationError = -201
	}
}


사용예제


            new Thread(delegate()
                {                    
                    for (int i = 0; i <= 100; i++)
                        LogFile.WriteLog(string.Format("Thread[1] = {0}", i.ToString()));

                }).Start();

            new Thread(delegate()
                {
                    for (int i = 0; i <= 100; i++)
                        LogFile.WriteLog(string.Format("Thread[2] = {0}", i.ToString()));

                }).Start();;


'C#' 카테고리의 다른 글

텍스트 로그 파일 라이브러리 - 2  (0) 2015.02.21
멀티플(multiple) 윈도우 - 1  (0) 2015.01.24
멀티스레드 환경에서 UI 에 데이타 표시할 경우  (0) 2015.01.15
Task 클래스  (0) 2015.01.10
ManualResetEvent 클래스  (0) 2014.12.24
posted by 따시쿵