상우의 IT 일기

Non-blocking Sockets (A Chat Program)

Noonipoony — Sat, 27 Feb 2010 20:03:36 +0900

Non-blocking Sockets (A Chat Program)

by: craigrs84

This is a tutorial to explain the use of nonblocking sockets. Non-blocking sockets are the opposite of blocking sockets, and non-blocking sockets do not stop code execution to await incoming data. Non- blocking sockets are more powerful than blocking sockets, but they are also more difficult. I have noticed an advantage to using the Socket class over the TcpListener or TcpClient classes. The TcpListener and TcpClient classes only allow one connection per port number. With the Socket class, you can have as many clients connected to a port as you would like.

This program uses primarily the Socket class. The class TcpSock was built around the Socket class to add ease and functionality.

To start the program you must initialize the Server socket. As you can see, the statement "Server.blocking = false" tells the socket not to block. After initializing the Server socket and binding it to an IP address and port number, the socket is ready to Listen. Now comes the main loop. The first thing we need to check for are incoming connections. Use the Poll method along with the SelectRead argument to do this. When this returns true, we know there is a client trying to connect. So the next thing to do is Accept the connection.

After we have accepted a connection, we can send and receive data. To send the data we simply use the Send method. Receiving data is the hard part. First, we again use the Poll method to check for data available to read. If it returns true, then we call the Recv method, which receives a chunk of data. Telnet does not echo the data unless specifically set to do so, so we will echo the data for telnet. Next we check to see if the person pressed enter... This is this critical part, because we need to know when they have entered a complete line of text, not just a few characters. Once we know they pressed enter, we can send the data to all the other clients using a for loop and the Send method. It's pretty straight- forward.

Lastly, we must close the socket if they disconnect. We already have the information we need. When we Polled the Socket, it returns the number of bytes received. If the number of bytes received = 0, then the Client closed his end of the connection. Now we close our end with the Shutdown and Close methods. Finally, we remove the instance of the TcpSock class from Client, our dynamic array.

This chat program is just a very simple example. If you were ambitious you could add names, commands, and adminstrators.

using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace TcpSock
{
class TcpSock
{
int    tcpIndx = 0;
int    tcpByte = 0;
byte[] tcpRecv = new byte[1024];

////////////////////////////////////////
public Socket tcpSock;
////////////////////////////////////////

public int Recv  (ref string tcpRead)
{
    tcpByte = tcpSock.Available;
    if (tcpByte > tcpRecv.Length - tcpIndx)
        tcpByte = tcpRecv.Length - tcpIndx;

    tcpByte = tcpSock.Receive(tcpRecv, tcpIndx, tcpByte, 
        SocketFlags.Partial);
    tcpRead = Encoding.ASCII.GetString
        (tcpRecv, tcpIndx, tcpByte);
    tcpIndx+= tcpByte;
    return    tcpRead.Length;
}

public int RecvLn(ref string tcpRead)
{
    tcpRead = Encoding.ASCII.GetString
        (tcpRecv, 0, tcpIndx);
    tcpIndx = 0;
    return    tcpRead.Length;
}

public int Send  (string tcpWrite)
{
    return tcpSock.Send(Encoding.ASCII.GetBytes(tcpWrite));
}

public int SendLn(string tcpWrite)
{
    return tcpSock.Send(Encoding.ASCII.GetBytes(tcpWrite + "\r\n"));
}
}


class Tcp
{
[STAThread]
static void Main()
{
    ////////////////////////////////////////////////////////////////////////////////////////////
    ///class IPHostEntry : Stores information about the Host and is required 
    ///for IPEndPoint.
    ///class IPEndPoint  : Stores information about the Host IP Address and 
    ///the Port number.
    ///class TcpSock     : Invokes the constructor and creates an instance.
    ///class ArrayList   : Stores a dynamic array of Client TcpSock objects.

    IPHostEntry Iphe   = Dns.Resolve   (Dns.GetHostName());
    IPEndPoint  Ipep   = new IPEndPoint(Iphe.AddressList[0], 4444);
    Socket      Server = new Socket    (Ipep.Address.AddressFamily, 
    SocketType.Stream, ProtocolType.Tcp);

    ////////////////////////////////////////////////////////////////////////////////////////////
    ///Initialize
    ///Capacity : Maximux number of clients able to connect.
    ///Blocking : Determines if the Server TcpSock will stop code execution 
    ///to receive data from the Client TcpSock.
    ///Bind     : Binds the Server TcpSock to the Host IP Address and the Port Number.
    ///Listen   : Begin listening to the Port; it is now ready to accept connections.

    ArrayList Client = new ArrayList ();
    string    rln    = null;

    Client.Capacity =   256;
    Server.Blocking = false;
    Server.Bind  (Ipep);
    Server.Listen( 32 );

    Console.WriteLine("{0}: listening to port {1}", Dns.GetHostName(), 
        Ipep.Port);

    ////////////////////////////////////////////////////////////////////////////////////////////
    ///Main loop
    ///1. Poll the Server TcpSock; if true then accept the new connection.
    ///2. Poll the Client TcpSock; if true then receive data from Clients.

    while (true)
    {
        //Accept
        if (Server.Poll(0, SelectMode.SelectRead))
        {
            int i = Client.Add(new TcpSock());
            ((TcpSock)Client[i]).tcpSock = Server.Accept ();
            ((TcpSock)Client[i]).SendLn("Welcome.");
            Console.WriteLine("Client {0} connected.", i  );
        }

        for (int i = 0; i < Client.Count; i++)
        {
            //check for incoming data
            if (((TcpSock)Client[i]).tcpSock.Poll(0, SelectMode.SelectRead))
            {
                //receive incoming data
                if (((TcpSock)Client[i]).Recv(ref rln) > 0)
                {
                    //echo incoming data
                    ((TcpSock)Client[i]).Send(rln);

                    //check for new line
                    if (rln == "\r\n")
                    {
                       ///receive line
                     ((TcpSock)Client[i]).RecvLn(ref rln);

                     //send the line to all clients
                     for (int y = 0; y < Client.Count; y++)
                        if (y != i)
                        ((TcpSock)Client[y]).Send(i.ToString() + ": " + rln);

                         Console.Write("{0}: {1}", i, rln);
                     }
                }
                    //recv returned <= 0; close the socket
                else
                {
                    ((TcpSock)Client[i]).tcpSock.Shutdown(SocketShutdown.Both);
                    ((TcpSock)Client[i]).tcpSock.Close();
                    Client.RemoveAt (i);
                    Console.WriteLine("Client {0} disconnected.", i);
                }
            }
        }
    }
}
}
}

C# 스트림라이터로 소켓 통신

Noonipoony — Wed, 06 Jan 2010 00:32:45 +0900

Introduction :

The Program Socket Programming is used a starter for those who wants to write C# Codes using Net Sockets. It lets you to use Socket Connections with other Systems.

The Server Waits for the Connection and gives a Warm Welcome Message to the User Or the Client.

Tools/API Information :

This Programme it Written using Net.Socket and no extra Feature is used. This is written with the Aim that anyone should understand the Usage of Sockets and NetWorks and to show that C# has got great Support for NetWorking.

Benefit :

There are lots of codes still I am sending this because of its Simplicity and you can use write this Code with just a NotePad/TextPad/Editor.

Server Side Code:

using System;
using System.Net.Sockets;
public class AsynchIOServer
{
public static void Main()
{
TCPListener tcpListener = new TCPListener(10);
tcpListener.Start();
Socket socketForClient = tcpListener.Accept();
if (socketForClient.Connected)
{
Console.WriteLine("Client connected");
NetworkStream networkStream = new NetworkStream(socketForClient);
System.IO.StreamWriter streamWriter =
new System.IO.StreamWriter(networkStream);
System.IO.StreamReader streamReader =
new System.IO.StreamReader(networkStream);
string theString = "Sending";
streamWriter.WriteLine(theString);
Console.WriteLine(theString);
streamWriter.Flush();
theString = streamReader.ReadLine();
Console.WriteLine(theString);
streamReader.Close();
networkStream.Close();
streamWriter.Close();
}
socketForClient.Close();
Console.WriteLine("Exiting...");
}
}

Client Code:

using System;
using System.Net.Sockets;
public class Client
{
static public void Main( string[] Args )
{
TCPClient socketForServer;
try
{
socketForServer = new TCPClient("localHost", 10);
}
catch
{
Console.WriteLine(
"Failed to connect to server at {0}:999", "localhost");
return;
}
NetworkStream networkStream = socketForServer.GetStream();
System.IO.StreamReader streamReader =
new System.IO.StreamReader(networkStream);
System.IO.StreamWriter streamWriter =
new System.IO.StreamWriter(networkStream);
try
{
string outputString;
// read the data from the host and display it
{
outputString = streamReader.ReadLine();
Console.WriteLine(outputString);
streamWriter.WriteLine("Client Message");
Console.WriteLine("Client Message");
streamWriter.Flush();
}
}
catch
{
Console.WriteLine("Exception reading from Server");
}
// tidy up
networkStream.Close();
}
}

C# 다른 스레드에서 Form UI 접근시 invoke

Noonipoony — Tue, 05 Jan 2010 12:51:26 +0900

/*
The following example demonstrates the 'Invoke(Delegate)' method of 'Control class.
A 'ListBox' and a 'Button' control are added to a form, containing a delegate
which encapsulates a method that adds items to the listbox.This function is executed
on the thread that owns the underlying handle of the form. When user clicks on button
the above delegate is executed using 'Invoke' method.

*/

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

   public class MyFormControl : Form
   {
public delegate void AddListItem();
public AddListItem myDelegate;
private Button myButton;
private Thread myThread;
private ListBox myListBox;
public MyFormControl()
{
   myButton = new Button();
   myListBox = new ListBox();
   myButton.Location = new Point(72, 160);
   myButton.Size = new Size(152, 32);
   myButton.TabIndex = 1;
   myButton.Text = "Add items in list box";
   myButton.Click += new EventHandler(Button_Click);
   myListBox.Location = new Point(48, 32);
   myListBox.Name = "myListBox";
   myListBox.Size = new Size(200, 95);
   myListBox.TabIndex = 2;
   ClientSize = new Size(292, 273);
   Controls.AddRange(new Control[] {myListBox,myButton});
   Text = " 'Control_Invoke' example";
   myDelegate = new AddListItem(AddListItemMethod);
}
static void Main()
{
   MyFormControl myForm = new MyFormControl();
   myForm.ShowDialog();
}
public void AddListItemMethod()
{
   String myItem;
   for(int i=1;i<6;i++)
   {
myItem = "MyListItem" + i.ToString();
myListBox.Items.Add(myItem);
myListBox.Update();
Thread.Sleep(300);
   }
}
private void Button_Click(object sender, EventArgs e)
{
   myThread = new Thread(new ThreadStart(ThreadFunction));
   myThread.Start();
}
private void ThreadFunction()
{
   MyThreadClass myThreadClassObject = new MyThreadClass(this);
   myThreadClassObject.Run();
}
   }

// The following code assumes a 'ListBox' and a 'Button' control are added to a form,
// containing a delegate which encapsulates a method that adds items to the listbox.

   public class MyThreadClass
   {
MyFormControl myFormControl1;
public MyThreadClass(MyFormControl myForm)
{
   myFormControl1 = myForm;
}

public void Run()
{
   // Execute the specified delegate on the thread that owns
   // 'myFormControl1' control's underlying window handle.
   myFormControl1.Invoke(myFormControl1.myDelegate);
}
   }

C# Dictionary 키 나열하기

Noonipoony — Tue, 05 Jan 2010 12:00:01 +0900

SerializableDictionary<String, LogData>.KeyCollection keyColl = m_dicLogData.Keys;

foreach (String key in keyColl)
{
// 날짜 별로 정렬
TreeNode currentDateNode = Control_Log_TreeList.Nodes[TreeRootKey].Nodes[m_dicLogData[key].Date];
if (currentDateNode == null)
{
currentDateNode = Control_Log_TreeList.Nodes[TreeRootKey].Nodes.Add(m_dicLogData[key].Date, m_dicLogData[key].Date);
}
currentDateNode.Nodes.Add(key, m_dicLogData[key].Title);

}

C# 스레드 종료 이벤트 받는 스레드

Noonipoony — Tue, 05 Jan 2010 11:56:33 +0900

BackgroundWorker bwConnector = new BackgroundWorker();
bwConnector.DoWork += new DoWorkEventHandler(bwConnector_DoWork);
bwConnector.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bwConnector_RunWorkerCompleted);
bwConnector.RunWorkerAsync();

XMLSerialization 딕션어리 클래스 하기

Noonipoony — Mon, 04 Jan 2010 22:53:24 +0900

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;

namespace ServerLib
{
[XmlRoot("dictionary")]

public class SerializableDictionary<TKey, TValue>
: Dictionary<TKey, TValue>, IXmlSerializable
{
#region IXmlSerializable Members
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}

public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

bool wasEmpty = reader.IsEmptyElement;
reader.Read();

if (wasEmpty)
return;

while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");

TKey key = (TKey)keySerializer.Deserialize(reader);

reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);

reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}

public void WriteXml(System.Xml.XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

foreach (TKey key in this.Keys)
{
writer.WriteStartElement("item");
writer.WriteStartElement("key");
keySerializer.Serialize(writer, key);
writer.WriteEndElement();
writer.WriteStartElement("value");
TValue value = this[key];
valueSerializer.Serialize(writer, value);
writer.WriteEndElement();
writer.WriteEndElement();
}
}
#endregion
}
}

XmlSerializer로 데이터 교환을 가볍고 편리하게

Noonipoony — Sun, 03 Jan 2010 21:50:01 +0900

실버라이트 애플리케이션이 웹 서버로부터 데이터를 교환 하는 방법에는 몇 가지를 생각해 볼 수 있죠. 웹 서비스, JSON, XmlHttpRequest, 기타 등등...
전 이 중에서 웹 서비스를 즐겨썼는데 왜냐면 웹 서비스는 웹 서비스로 전달되는 데이터 인자를 자동으로 직렬화Serialize하여 SOAP형식으로 만들어주고 데이터를 받을 때에도 서비스 참조만 해주면 자동으로 프락시 클래스를 생성해주기 때문에 서버가 전달해준 데이터 클래스를 클라이언트에서도 그대로 쓸 수 있어서 무지 편리하기 때문이죠.

그러나 웹 서비스는 기본적으로 SOAP의 특성상 데이터 부분 외의 오버헤드가 상당히 심한 편이기도 하고 사람이 직관적으로 이해하기에는 통신 구조가 복잡한 편이라서 간단한 데이터 교환은 단순한 구조의 XML을 만드는 경우도 있죠.

XML을 직접 전송하고 받는 쪽에서 파싱을 하는 과정은 꽤나 귀찮은 작업인데요, 만약 자신이 개발한 서버와 데이터를 교환할 때에는 아주 간단한 방법으로 데이터 클래스를 XML로 직렬화 할 수 있어요.

C#에서는 기본적으로 클래스를 선언할 때 [Serializable] 이라는 어트리뷰트를 추가함으로써 간단하게 해당 개체를 직렬화 할 수 있지만 실버라이트2는 Serializable 어트리뷰트가 제공되지 않죠. 대신 XmlSerializer와 Xml관련 어트리뷰트를 제공하여 비교적 간단하게 직렬화를 구현할 수 있어요.

참고로 XmlSerializer를 쓰기 위해서는 System.Xml과 System.Xml.Serialization 어셈블리를 참조해야 해요.

예를 들어 서버 측에서 DB에서 데이터를 조회하고 다음과 같은 데이터 클래스를 만들었다고 치죠.

public class ArticleData

{

[XmlElement]

public long ID { get; set; } // ID

[XmlElement]

public string Title { get; set; } // 제목

[XmlElement]

public string Content { get; set; } // 내용

[XmlElement]

public string Description { get; set; } // 주석

[XmlElement]

public DateTime RegDate { get; set; } // 등록 일자

[XmlElement]

public int ViewCount { get; set; } // 조회수

[XmlElement]

public string ImageUrl { get; set; } // 이미지 URL(URI는 사용 불가)

[XmlElement]

public bool IsRemoved { get; set; } // 삭제되었는지 여부

[XmlElement]

public UserData User { get; set; } // 사용자 정보

}

public class UserData

{

[XmlElement]

public string ID { get; set; } // 사용자 ID

[XmlElement]

public string Name { get; set; } // 사용자 이름

}

보이는 것처럼 데이터 클래스의 각 프로퍼티에 [XmlElement] 또는 [XmlAttribute] 어트리뷰트를 선언만 하면 일단 준비는 끝. 아주 직관적이게도 [XmlElement] 어트리뷰트가 붙은 프로퍼티는 나중에 XML로 생성될 때 <Element>value</Element>형식으로 표현되고 [XmlAttribute] 어트리뷰트가 붙은 프로퍼티는 <ClassName Attribute="value"></ClassName>형식으로 표현되죠.

여튼 이 데이터 클래스는 XmlSerializer에 의해 직렬화되고 이렇게 직렬화된 문자열은 다음과 같은 XML형태가 되죠.

<?xml version="1.0" encoding="utf-16" ?>

- <ArticleData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<Content>가나다라 あいうえお　家羅多羅 abcd ♠!@#$</Content>

<ImageUrl>images/sample.png</ImageUrl>

<IsRemoved>false</IsRemoved>

- <User>

<ID>Gongdo</ID>

</User>

</ArticleData>

여기서 문제는 encoding="utf-16"을 실버라이트에서 정상적으로 인식하지 못한다는 점인데요, XML의 인코딩은 utf-8로 설정해야 해요. 바로 다음 코드 처럼요.

// DB나 비즈니스 로직에서 작성된 데이터

ArticleData data = new ArticleData

{

ID = 0, // long

Title = "테스트", // string

Content = "가나다라 あいうえお　家羅多羅 abcd ♠!@#$", // with unicode string

Description = null, // null

RegDate = DateTime.Now, // DateTime

ViewCount = 100, // int

//Image = new Uri("images/sample.png", UriKind.RelativeOrAbsolute), // Do not use URI

ImageUrl = "images/sample.png",

IsRemoved = false, // bool

User = new UserData // Sub class

{

ID = "Gongdo", Name = "공도"

}

};

// 시리얼라이저 작성

XmlSerializer xs = new XmlSerializer(typeof(ArticleData));

string response = null;

// 시리얼라이즈 결과를 저장할 스트림

using (MemoryStream ms = new MemoryStream())

{

// UTF-8 인코딩을 사용하기 위해 XmlTextWriter사용

using (XmlTextWriter xtw = new XmlTextWriter(ms, Encoding.UTF8))

{

// 데이터 시리얼라이즈

xs.Serialize(xtw, data);

// 기록된 데이터의 처음부터 끝까지 string으로 읽기

ms.Seek(0, SeekOrigin.Begin);

using (StreamReader sr = new StreamReader(ms))

{

response = sr.ReadToEnd();

}

여튼 이렇게 만들어진 XML 문자열을 응답해주면 실버라이트 측에서는 받은 XML 문자열을 별도의 파싱 코드 없이 XmlSerializer의 역직렬화Deserialize를 통해 데이터 클래스로 얻을 수 있어요.

// WebClient로 XML데이터 Request/Response 처리

WebClient wc = new WebClient();

wc.OpenReadCompleted += delegate(object sender, OpenReadCompletedEventArgs e)

{

if (e.Error != null || e.Cancelled)

{

// 에러

return;

}

XmlSerializer xs = new XmlSerializer(typeof(ArticleData));

ArticleData data = xs.Deserialize(e.Result) as ArticleData;

};

wc.OpenReadAsync(uri);

여튼 이 방법은 사실 실버라이트가 [Serializable]을 지원하지 않아서 XSD에 기반한 클래스를 곧바로 사용할 수 없기 때문에 차선으로 선택한 방법이고요, 설계상 썩 좋다고는 할 수 없지만 내가 관리하는 서버와 통신하되 XML로 데이터를 교환하고 싶을 때 아주 유용하게 쓸 수 있는 방법이죠.

타이틀바 없는 WPF 윈도우 쉽게 드래그 하기

Noonipoony — Wed, 11 Nov 2009 12:07:42 +0900

1. 타이틀 바가 없는 WPF 윈도우의 경우 어떻게 드래그를 해야 할까요?

먼저 고전적인 방법으로 아래와 같은 코드를 예상할 수 있습니다.

이는 Win32 에서 주로 쓰던 코드이지요.

private const int WM_NCHITTEST = 0x84;
private const int HTCLIENT = 0x1;
private const int HTCAPTION = 0x2;

protected override void WndProc(ref Message message)
{

   base.WndProc(ref message);
   if (message.Msg == WM_NCHITTEST && (int)message.Result == HTCLIENT)

        message.Result = (IntPtr)HTCAPTION;

하지만 WPF 에서는 더욱 간단한 방법으로 이를 구현 할 수 있습니다.

MouseDown += delegate { DragMove(); };

간단하지 않나요? ㅎ

UI 스레드 접근(액세스) 문제

Noonipoony — Mon, 09 Nov 2009 14:09:58 +0900

WPF에서는 메인스레드에서 생성한 컨트롤에 다른 스레드가 접근하지 못하도록 되어있습니다.(윈폼에서도 그랬나..)

접근하려고 하면 다음과 같은 에러메시지에 직면하죠 :

“다른 스레드가 이 개체를 소유하고 있어 호출한 스레드가 해당 개체에 액세스할 수 없습니다.”

Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate

{

lblStatus.Content = "동작중"; // 해당 소스

}));

다음과 같이 메인 Dispatcher를 통해 라벨내용을 변경시켜주시면 문제없이 돌아갑니다.

이미지 호스팅 (월 5,000원 무제한 트래픽&용량) [오픈 마켓 이미지]

Noonipoony — Sun, 25 Oct 2009 12:51:55 +0900

프로그램 다운로드 주소 : 요기..

이미지호스팅 소개

1. 월 5,000 원 무제한 트래픽&용량

2. 한번 업로드 100MB 가능

3. 플래시 파일 지원

1. 이미지 업로드 방법

이미지 파일을 올리시려면 [파일->이미지] 업로드를 클릭하시면 됩니다.

그렇게 하게 되면 아래와 같은 대화 상자가 뜨게 됩니다. 이 대화상자에서 자신이 원하는 이미지를 클릭한 후 열기를 누르면 이미지가 업로드 됩니다. 지원되는 확장파일은 BMP를 제외한 그림파일과 swf 플래시 파일입니다. 한번 업로드 할 수 있는 용량은 100 메가 정도 이고, 총 용량에 상관 없이 무제한 업로드가 가능합니다.

성공적으로 이미지가 추가가 되면 왼쪽의 트리에 현재 업로드 된 이미지 파일이 나오게 되며, 이것을 메인 화면에 드래그 드롭을 하면 해당 이미지의 내용을 볼 수 있습니다.

2. 이미지 주소 알아내기

오픈 마켓에 이미지를 올리기 위해서는 서버에 올라간 이미지의 주소를 알아야 됩니다. 이것은 이미지를 클릭하고 속성에 들어가시면 해당 이미지의 주소를 확인 할 수 있으며,

이 주소를 가지고 오픈 마켓에 이미지를 올리시면 됩니다.