five minutes of funk

제 아들놈이에요 ㅋㅋㅋ

2010-03-17T14:47:31+09:00

파견생활~+_+

2010-03-17T10:31:32+09:00

즐겁다~ 왜?

마이 배우고있응께 ㅋㅋㅋ

충무로 맛집 지도를 만들어볼까 ㅡㅡ;;

송죽은 강추

DOKDO, This is part of Korea

2010-03-02T08:53:00+09:00

메일주소가 2칸으로 나뉘어져있는 경우에 생각나서......

2010-02-19T20:38:05+09:00

위와같이 메일주소를 2칸으로 입력받는경우에 뭐 직접입력, 등등 선택해서 많이들 사용하는경우가

요즘들어 빈번하게 작업이 있어서 하다 문득???

내가 이렇게 치고있는걸 발견했었다......

쩝 ㅋㅋㅋ 나만그런가...ㅠㅠㅠ

아무튼 이걸 해결하기 위해서 나름 머리를 굴리다가 아래와같은 스크립트를 만들어 보았다!!!

function MoveToTail() {

var str = document.frm.userEmail01.value;

if(str.indexOf("@") > 0) {

str = str.replace(/\@/g,"");

document.frm.userEmail01.value = str;

document.frm.userEmail02.focus();

}

앞쪽 텍스트 박스에

onkeydown="MoveToTail(this.value)"

이벤트를 추가시키면 나도몰래 메일주소를 @붙어셔 치고있는분들께는 꽤나 유용한 인터페이스가

되지 않을까 싶다 ㅎㅎ

메모장

2010-02-17T10:15:34+09:00

말그대로 메모장..ㅎㅎ

드래그 기능을 제외한 다른부분을 그대로 구현해보았음..

실행파일.zip

소스.zip

쓰레기들..ㅎㄷㄷ

2010-02-17T09:27:21+09:00

쇼트트랙.....이야기 보니까 정말

쓰레기들.....많쿠나..라는 생각만 쩝....

쓰레기색키들아.....

이건뭐..... 에라이...쓰레기색키들...가치도 없는것들 ㅡㅡ

촐라체

2010-02-08T09:20:02+09:00

간만에 읽은 소설..ㅎㅎ
이야 나름 이렇게 책읽고 글쓰는걸 잘 하지 못하는데...절로 글을쓰게 만드는 책이었던...느낌이다.

표지에 적힌 H.J 1996.11.5 SEOUL KOREA "사랑해" 영우,선우,마야,정순희 미안ㅎ.....
미안ㅎ... 이걸 타자로 치고보니깐 아 미안~ ㅎㅎㅎ 과 흡사한데...흠 넘어가고 ㅡㅡ

내용을 느낌으로 말하고싶지는 않은듯....그저 읽어보시라~ 이게 나의 짧은 서평이다 ㅎㅎ

단지 소설을 읽는다는것을 나름 표현해보자면

집에가는 길 내리는 버스정류장에 높은 건물이 하나 있는데 항상 가던 큰 건물옆이 어느날
버스를 일찍 세워준 기사님덕에 몇골목 전에 내려서 집으로 향하는 어두운 골목에서
그 건물을 멀찌감치 바라보는 심정이라고 말하고 싶다...

"아 저 건물이 저렇게 높았구나 맞아 저 간판을 보니까 저 건물에 저런것도 있었지라고 새삼 느끼는
감회를 새롭게 해주는 무언가 ..... 하지만 다시금 그 건물옆을 지날즈음이면 익숙한 풍격에 반응하는
감정이 다시 일상으로 언제 그런생각을 했었는지는 중요하지도 기억나지도 않는것처럼..."

마지막 페이지를 덮는순간까지도 나에게는 너무도 짠한~ 가족을 나를 친구를 일을 되돌아 볼수 있게해준
촐라체 였다 ㅎㅎ 다시 일상으로 돌아왔지만 책상 한켠에 영교와 상민은 하릴없이 촐라체 정상을 향해
도전하고 있겠지...

박범신 작가님의 이 책을 볼 수 있었던 좋은 인연은 hellow! blogger 대한민국 블로거 컨퍼런스. 라는 글에서
남겼던것처럼 직접 만날 수 있었던 기회가 있었던것인데 앞으로는 책에서도 자주 뵈었으면 하는 바램임~ ㅋ

흠..지남이 덕에 만들어본? 테이블 제어 스클비트

2010-02-02T15:56:45+09:00

<HTML>
 <HEAD>
<TITLE> New Document </TITLE>

<script type='text/javascript'>
//<![CDATA[ 
function FNTableControl()
{
 var etable = document.getElementById('jin');  
 for( i = 0 ; i < etable.rows.length ;  i++ )
 {
  var row = etable.rows[i];
  for ( j = 0 ; j < row.cells.length ; j ++ )
  {
   var cell = etable.rows[i].cells[j];    
   if ( cell.name == 'charge' )
   {
    cell.style.backgroundColor = '#F30';
    alert(cell.innerHTML);
   }
  }
 }
}
//]]> 
</script>

 </HEAD>
 <BODY>
  <table id='jin' border='1'>
 <tr>
  <td>네이버</td>
  <td name='charge'>홍길동</td>
  <td>000-1111-2222</td>
  <td>iiii@naver.com</td>
 </tr>
 <tr>
  <td>다음</td>
  <td name='charge'>춘향이</td>
  <td>333-4444-5555</td>
  <td>uuuu@daum.net</td>
 </tr>
 <tr>
  <td colspan='4'><input type='button' value='test' onclick='FNTableControl();'></td>
 </tr>
</table>
 </BODY>
</HTML>

Array

2010-02-01T09:58:29+09:00

using System; namespace Ex07Array
{
    class Program
    {
        static void Main(string[] args)
        {
            Random r = new Random();
            
            #region 배열 선언 및 접근
            
            //1.
            //int[] ar1 = new int[10];
            //for (int i = 0; i < 10; i++)
            //{
            //    ar1[i] = r.Next(100, 1000);
            //}             
            //for (int i = 0; i < 10; i++)
            //{
            //    Console.WriteLine("ar[{0}] = {1}", i, ar1[i]);
            //}             
            //Console.WriteLine();
            //Console.WriteLine();             
            #endregion             

            #region 다차원 배열
            //2.
            //int[,] ar2 = new int[5, 7];
            //for (int i = 0; i < 5; i++)
            //{
            //    for (int j = 0; j < 7; j++)
            //    {
            //        ar2[i, j] = r.Next(100, 1000);
            //    }
            //}             
            //for (int i = 0; i < 5; i++)
            //{
            //    for (int j = 0; j < 7; j++)
            //    {
            //        Console.Write("{0,5}",ar2[i,j]);
            //    }
            //    Console.WriteLine();
            //}             
            #endregion             

            #region 배열 초기화
            ////3.
            //int[] ar3_1 = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            ////int[] ar3_1 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            ////int[] ar3_1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };             
            //for (int i = 0; i < 10; i++)
            //{
            //    Console.Write("{0,3}",ar3_1[i]);
            //}
            //Console.WriteLine();             
            //int[,] ar3_2 = new int[2, 3] { {1, 2, 3}, {4, 5, 6} };             
            //for (int i = 0; i < 2; i++)
            //{
            //    for (int j = 0; j < 3; j++)
            //    {
            //        Console.Write("{0,3}",ar3_2[i,j]);
            //    }
            //    Console.WriteLine();
            //}             
            #endregion             

            #region 배열 지원 메서드 / 프로퍼티             
            //4.
            //int[] ar4_1 = new int[10];
            ////배열.Length : 배열 요소의 갯수를 반환
            //for (int i = 0; i < ar4_1.Length; i++)
            //{
            //    ar4_1[i] = r.Next(100, 1000);
            //}             
            //Console.Write("Before Sorting : ");
            //for (int i = 0; i < ar4_1.Length; i++)
            //{
            //    Console.Write("{0,5}",ar4_1[i]);
            //}
            //Console.WriteLine();             
            //Console.Write("After Sorting : ");
            //Array.Sort(ar4_1); //오름차순 정렬
            ////Array.Reverse(ar4_1); //배열을 역순으로 재정렬
            //for (int i = 0; i < ar4_1.Length; i++)
            //{
            //    Console.Write("{0,5}",ar4_1[i]);
            //}
            //Console.WriteLine();             
            //Console.Write("Input Number : ");
            //int number = int.Parse(Console.ReadLine());             
            //Console.WriteLine("입력된 숫자의 배열 내 위치 : {0}", Array.IndexOf(ar4_1, number));
            ////요소의 위치 없으면(-1)             
            ////////////////////////////////////////////////////////
            //int[,] ar4_2 = new int[2, 3];
            //for (int i = 0; i < ar4_2.GetLength(0); i++)
            //{
            //    for (int j = 0; j < ar4_2.GetLength(1); j++)
            //    {
            //        ar4_2[i, j] = r.Next(100, 1000);
            //    }
            //}             
            //for (int i = 0; i < ar4_2.GetLength(0); i++)
            //{
            //    for (int j = 0; j < ar4_2.GetLength(1); j++)
            //    {
            //        Console.Write("{0,5}",ar4_2[i,j]);
            //    }
            //    Console.WriteLine();
            //}             
            #endregion             

            #region 가변 배열 전달인자
            //5.
            //TestMethod(1);
            //TestMethod(1, 2);
            //TestMethod(1,2,3,4,5,6,7,8);             
            #endregion             

            #region Zagged Array
            //6.
            int[][] ar6 = new int[10][];
            for (int i = 0; i < ar6.Length; i++)
            {
                ar6[i] = new int[r.Next(5, 15)];
            }             for (int i = 0; i < ar6.Length; i++)
            {
                for (int j = 0; j < ar6[i].Length; j++)
                {
                    ar6[i][j] = r.Next(100, 1000);
                }
            }             for (int i = 0; i < ar6.Length; i++)
            {
                for (int j = 0; j < ar6[i].Length; j++)
                {
                    Console.Write("{0,5}",ar6[i][j]);
                }
                Console.WriteLine();
            }
            #endregion
        }         
            //가변 배열 전달인자 관련
        private static void TestMethod(params int[] p)
        {
            Console.WriteLine("전달인자의 갯수 : {0}",p.Length);
        }
    }
}

Method

2010-02-01T09:54:13+09:00

using System; namespace Ex05Method
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("박스그리기에 사용할 문자 : ");
            string drawingUnit = Console.ReadLine();
            int width = InputInt("박스의 넓이 : ");             
            int height = InputInt("박스의 높이 : ");             
            DrawBox(drawingUnit, width, height);//호출시 데이터 전달
        }         
        
        private static int InputInt(string message)
        {
            Console.Write(message + " : ");
            int data = int.Parse(Console.ReadLine());
            //메스드를 종료하고 메서드 호출 영역으로 data를 반환
            return data;
        }         

        private static void DrawBox(string drawingUnit, int width, int height)
        {
            for (int i = 0; i < height; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    if (i == 0 || i == height - 1 ||
                        j == 0 || j == width - 1)
                    {
                        //Console.Write("*");
                        Console.Write(drawingUnit);
                    }
                    else
                    {
                        Console.Write(" ");
                    }
                }
                Console.WriteLine();
            }
        }
    }
}

연산자

2010-02-01T09:51:03+09:00

using System; namespace Ex04ControlStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            //Calculator (+, -, *, /, %)             
            #region input operation
            Console.Write("Input First Operand : ");
            int operanda = int.Parse(Console.ReadLine());
            
            Console.Write("Input Operator (+,-,*,/,%) : ");
            string op = Console.ReadLine();
            
            Console.Write("Input Second Operand : ");
            int operandb = int.Parse(Console.ReadLine());
            #endregion             
            int result = 0;             
            #region operation (if - else)
            //if (op.Equals("+"))
            //{
            //    result = operanda + operandb;
            //}
            //else if (op == "-")
            //    result = operanda - operandb;
            //else if (op == "*")
            //    result = operanda * operandb;
            //else if (op == "/")
            //    result = operanda / operandb;
            //else if (op == "%")
            //    result = operanda % operandb;
            //else
            //{
            //    Console.WriteLine("Invalid Operator !!!");
            //    return;
            //}
            #endregion             
            #region operation (switch - case)
            switch (op)
            {
                case "+": result = operanda + operandb; break;
                case "-": result = operanda - operandb; break;
                case "*": result = operanda * operandb; break;
                case "/": result = operanda / operandb; break;
                case "%": result = operanda % operandb; break;
                default: 
                    Console.WriteLine("Invalid Operator");
                    break;
            }
            #endregion             
            Console.WriteLine(
                "{0} {1} {2} = {3}", 
                operanda, op, operandb, result);
        }
    }
}
/*
관계연산자 (두 데이터의 대소 관계를 비교 --> 참/거짓 판단)
1. == : 같다 (cf : 대입연산자(=)와 구분)
2. != : 다르다
3. >  : 크다
4. >= : 크거나 같다
5. <  : 작다
6. <= : 작거나 같다 ex) 10 == 10 : true, 10 == 5 : false */

Windows Form 띄워보기

2010-02-01T09:47:53+09:00

using System;
using System.Windows.Forms;
using System.Drawing; 
namespace Ex03WinForm
{
    class Program
    {
        static void Main(string[] args)
        {
            Form form = new Form();
            form.Text = "Hello, Windows Forms";
            form.Width = 500;
            form.Height = 350;
            form.BackColor = Color.Orange;             
            Button button = new Button();
            button.Width = 200;
            button.Height = 100;
            button.BackColor = Color.Purple;
            button.Text = "Push Me !!!!!";
            int x = form.ClientRectangle.Width / 2 - 100;
            int y = form.ClientRectangle.Height / 2 - 50;
            button.Location = new Point(x, y);
            button.Click += new EventHandler(button_Click);             
            form.Controls.Add(button);             
            //form.Show();//Modeless 방식
            form.ShowDialog();//Modal 방식
        }         
        static void button_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Thank You for Clicking Me !!!!!");
        }         
        static void form_MouseClick(object sender, MouseEventArgs e)
        {
            MessageBox.Show("X : " + e.X + " / Y : " + e.Y);
        }         
        static void form_Click(object sender, EventArgs e)
        {
            MessageBox.Show("폼 위에서 마우스가 클릭되었습니다.");
        }
    }
}

Type

2010-02-01T09:44:32+09:00

Person.cs

using System; enum RelationType
{
    Family = 1,
    Friend,//2
    Biz,//3
    Community//4
} struct Person
{
    //public int Number;
    public Int32 Number;
    public string Name;
    public string Phone;
    public string Email;
    public RelationType Relation;
}

Program.cs

using System; namespace Ex02Type
{
    class Program
    {
        static void Main(string[] args)
        {
            //객체 생성
            Person person = new Person();             //값 할당
            person.Number = 1;
            person.Name = "장동건";
            person.Phone = "010-9563-4487";
            person.Email = "<A href="mailto:jdk@example.com">jdk@example.com</A>";
            person.Relation = RelationType.Biz;             
            Console.WriteLine("[{0}][{1}][{2}][{3}][{4}][{5}]",
                person.Number, person.Name,
                person.Phone, person.Email,
                person.Relation, (int)person.Relation);         }
    }
}

Hello, Visual Studio

2010-02-01T09:41:18+09:00

using System; namespace Ex01Greetings
{
    class Program
    {
        /// <summary>
        /// 프로그램 진입점
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)//Entry Point
        {
            Console.WriteLine("Hello, Visual Studio");
            Console.Write("현재 시각은 ");
            Console.Write(System.DateTime.Now.ToString());
            Console.WriteLine(" 입니다.");             
            int 변수;
            변수 = 10;
        }
        public void Test() { }
    }
}

C# 메모리 구조로 보는 간단한 배열할당과 박싱 언박싱

2010-01-21T09:35:17+09:00

메모리의 구조

박싱 언박싱

배열

a = 1, b = 1  : a == b 는 true
int[] ar1 = new int[] {1,2,3}
int[] ar2 = new int[] {1,2,3}
 : ar1 == ar2 는 false

Call By Value

using System;
namespace ConClass
{
    class MyClass
    {
        public void IntegerCallByValue(int num)
        {
            num = 200;
        }
        public void ArrayCallByValue(int[] MyArray)
        {
            for (int i = 0; i < MyArray.Length; i++)
            {
                MyArray[i] = 0;
            }
        }
        public void StringCallByValue(string str)
        {
            str = "Korea";
        }
    }

 class Program
    {
        public static void Main()
        {
            MyClass mc = new MyClass();
            int num = 30;
            mc.IntegerCallByValue(num);
            Console.WriteLine(num);
            Console.WriteLine();
            int[] MyArray = new int[] { 10, 20, 30 };
            mc.ArrayCallByValue(MyArray);
            for (int i = 0; i < MyArray.Length; i++)
            {
                Console.WriteLine(MyArray[i]);
            }
            Console.WriteLine();
            string str = "Seoul";
            mc.StringCallByValue(str);
            Console.WriteLine(str);
        }
    }
}

11 C# 생성자(Constructor)

2010-01-21T09:02:25+09:00

생성자(constructor)

class instance의 생성

new 연산자를 사용, heap 영역에 저장
Customer cu1 = new Customer(); // default 생성자를 호출하여 객체 생성 cu1.CustPoint++; // 생성된 객체의 사용

생성자의 특징

클래스와 같은 이름

리턴값이 없음

주로 멤버필드의 초기화에 사용

파라메터가 서로 다른 여러개의 생성자를 갖을 수 있다.- 메소드 오버로딩

새롭게 파라메터가 있는 custom constructor를 만들면 반드시 별도로 default constructor를 재정의해 주어야 한다.

생성자의 정의

class Customer{ int custpoint = 0; string custname; public Customer(){ // 생성자 custpoint = 1; // custpoint member field 초기화 } public Customer(int custpoint, string name){ // custom constructor // integer 인수가 두 개인 생성자, overloading this.custpoint = custpoint; custname = name; } }

생성자의 호출

new 연산자를 통해 인스턴스를 생성할 때 호출
생성자 파라메터가 없으면 default 생성자가 호출
파라메터가 있다면, 파라메터의 자료형과 순서가 일치하는 생성자 호출

생성자를 정의하지 않으면 C# Compiler가 파라메터가 없는 생성자(default constructor)를 자동으로 생성
Customer cu1 = new Customer(); // custpoint = 1 이 설정됨 Customer cu2 = new Customer(10, “홍길동”);

자신의 타입(class)을 파라메터로 받는 생성자

하나의 클래스 인스턴스와 동일한 복사본 값이 저장된 새로운 인스턴스를 생성할 때 유용
class Customer{ string corpName; string custName; ...... // 생략 public Customer(string corpName, string custName) { this.corpName = corpName; this.custName = custName; } public Customer(Customer cu, string custName) //클래스의 타입을 생성자로 갖는 경우 { corpName = cu.corpName; this.custName = custName;} ...... // corpName, custName을 접근하는 readonly property인 CorpName, CustName 정의 } ...... // 생략 Customer cu1 = new Customer("ㅇㅇ기업", "홍길동"); Customer cu2 = new Customer(cu1, "전우치"); //같은 객체의 값을 가질경우 Console.WriteLine(cu2.CorpName + " " + cu2.CustName); // ‘(주)단국기업 강태주’ 출력

this

class 자기자신을 가리키는 지시자
생성자에서 다른 생성자를 호출하는 호출자
class Customer{ int age; string username; public Customer():this(“홍길동", 20){ // 여기서 this는 다른 생성자를 호출하는 용도로 사용 } public Customer(string name, int age){ this.age = age; // 여기서 this는 Customer class를 가지킨다. username = name; } }

정적 생성자(static constructor)

parameter가 없으며, static 키워드로 정의된 생성자
class의 정적 멤버 필드(static member field)를 초기화하는 용도로 사용
.NET Runtime에 의해 호출되기 때문에 접근 제한자가 없다.

class Customer{ static int MaxLength; // static member field, 모든 instance가 공유 public Customer(){ …… } // constructor static Customer(){ // static constructor MaxLength = 20; // static member field 초기화 } }

접근 제한자(access modifier)

class의 member 를 private(비공개, default)로 정의하면 클래스 외부에서 멤버에 접근불가
일반적으로 class의 member field는 private로 설정
public member method를 정의하여 이 method에서 private field에 접근하도록 프로그래밍

public 어느 class 나 instance 에서도 접근 가능
private(default) 오직 class 내부에서만 접근가능
protected class 내부와 상속받은 sub class 에서만 접근 가능
internal assembly 안에서만 접근가능
protected internal protected나 internal로 접근가능

10 C# 클래스(Class) 2 중첩 클래스_클래스 멤버

2010-01-21T09:12:37+09:00

중첩 클래스(nested class)

class 안에 또다른 class를 정의
class가 논리적으로 다른 class에 포함되어 있지만, 독립적으로는 별 의미가 없을 때 중첩 클래스로 구성 outer class = 주 역할, nested class = 보조 역할 public, internal 접근 제한자일 때 outer class 밖에서도 접근 가능(하지만 제공 목적상 outer 에서 주로 사용) 외부에서 nested class에 접근하려면 outer class를 포함하여 type을 지정

중첩 클래스(nested class)

class MyClass{
 private MyNestedClass mnc; // outer class에서 nested class 접근
 public MyClass(){ mnc = new MyNestedClass(); }
 class MyNestedClass{ // nested class 정의
  public void DisplayString(){
                  // nested class member 정의
  }
 }
 public PrintString(){ mnc.DisplayString(); }
 // nested class는 outer class에서만…
} MyClass.MyNestedclass mnc = new MyClass.MyNestedClass();
// 외부에서 접근시… 하지만 가급적 피해야…

member method

class Customer{
 int custpoint = 0;       // member field public int GetCustPoint(){ // member method
                            return custpoint;
 }
 public void SetCustPoint(int point){
                             this.custpoint = point;
 }
}
// Customer class를 사용하는 다른 class 에서 고객 john의 구매 포인트를 1만큼 증가
Customer john = new Customer();
john.SetCustPoint(john.GetCustPoint() + 1);

member property

class Customer{
 int custpoint = 0;       // member field public int CustPoint{   // member property
                            get{return custpoint;}
                            set{
                                custpoint = value;
                            }
 }
}
// Customer class를 사용하는 다른 class 에서 고객 john의 구매 포인트를 1만큼 증가
Customer john = new Customer();
john.CustPoint++;  // method로 접근하는 방법보다 쉽게 접근이 가능

member property

set 접근자
void 형 메소드와 같음
value 라는 특수한 parameter가 사용됨, 이 value에는 property를 설정하기 위한 값이 전달됨 property를 읽기전용으로 하려면 set 접근자를 생략하면 되고
property를 쓰기전용으로 하려면 get 접근자를 생략하면 된다.

static method, instance method

class에 정의된 member method 중 static이라는 키워드가 붙어있는 method 는 class 이름으로 호출
class 의 member method class에 정의된 member method 중 static이라는 키워드가 붙지 않은 method는 class의 instance로 호출
instance(객체)의 member method 예

 MyClass mc = new MyClass();
 mc.AnyMethod();   // instance의 method member
 System.Threading.Thread.Sleep(100000); // class의 method member

객체 지향의 기초

2010-01-21T08:54:18+09:00

클래스란?

아리스토텔레스에 따르면
인간이 사물을 인식하는 방식
먼저 사물의 공통적인 행위와 속성을 인식
공통적인 행위와 속성에 대한 동의
필요한 어휘를 생성, 교환,…
비슷한 사물을 공통적으로 인식
객체 지향 프로그램에 따르면
객체의 공통적인 행위와 속성을 기술한 구성자
데이터와 메소드(함수)를 포함하는 자료형
메모리상에 있는 데이터와 메소드의 집합으로 그것을 구성하는것들의 묶음은 클래스
재사용성을 기초로 함.

객체란?

클래스 vs. 구조체

추상화

캡슐화

데이터(멤버)와 메소드를 결합
접근 권한의 통제
캡슐화
객체 데이터
클래스 데이터(멤버) 사용하기
클래스 메소드 사용하기

데이터(멤버)와 메소드를 결합

접근 권한의 통제

캡슐화

가릴것은 가리고 보여줄 것은 보여준다

객체 데이터(멤버)

클래스 데이터(멤버) 사용하기

클래스 메소드 사용하기

09 C# 클래스(Class) 1 객체와 class

2010-01-21T09:05:20+09:00

객체(object) 와 클래스(class)

객체(object) : 실제로 존재하는 구체적인 대상

클래스(class) : 유사한 특성(attribute)과 행위(behavior)를 갖는 객체를 표현(정의)한 것
세탁기 class
특성 : 브랜드명, 모델명, 일련번호, 용량, 색상 등
행위 : '옷 넣기', '물 투입', '세탁 ', ' 행굼' , '탈수', '완료 신호' 등

OOP(object oriented programming) 객체(object)
Class 를 기반으로 생성된 실체

객체의 3가지 특징

특성(attribute)
해당 객체에 저장되어 있는 정보

행위(behavior)
해당 객체가 행동하거나 반응하는 방법을 결정

정체성(identiry)
해당 객체를 다른 객체와 구별짓게 하는 식별값

객체지향의 기본원리

추상화(abstraction)
필요한 만큼의 특성과 행위를 추출해 내는 것.

캡슐화(encapsulation)
구현방법에 대한 자세한 사항을 내부에 감추고 외부에 노출된 인터페이스(interface)를 통해서만 사용할 수 있게하는 개념

상속(inheritance)
하나의 객체는 자신의 class에 속해 있는 특성과 행위를 모두 물려받는다.

다형성(polymorphism)
다른 class인데 같은 이름의 행위를 가지게 되는 경우

class

사용자가 정의하는 하나의 data type

생성자(constructor), 소멸자(destructor), 상수(constant), 필드(field), 메소드(method), 속성(property), 인덱서(indexor), 연산자(operator) 등을 멤버로 포함

class 의 정의
class classname{ // class의 member 정의 }

class의 특성

class의 특성은 member field와 property로 구현
class MyClass{ private int myField; // 멤버필드</P> public int MyProperty{ // 멤버속성 set{ // 속성 설정 구현코드 } get{ // 속성값 반환 구현코드 } } }

class의 행위

class의 행위는 member method로 구현 class MyClass{ public void MyMethod(){ // return 값이 없는 멤버 메소드 // 메소드의 구현 } public bool MyMethod2(){ // return 값이 boolean type인 멤버 메소드 // 메소드의 구현 return true; } }

member field

class Book{ string title; // 일반 변수를 선언하듯 사용 string isbncode; int part = 0; // 초기값을 설정할 수 있음 string[] authors; // 배열의 사용</P> const int COMPUTER = 0; // 상수를 정의하여 사용 const int BUSINESS = 1; const int NOVEL = 2; static int objCount; // static member field }

상수와 static field

상수 : 값이 변할 수 없는, 항상 같은 값
const int MaxLength = 25; // integer 상수 public const string appName = "My C# App“; // string 상수

static field
static method 처럼 객체의 member가 아닌 class의 member
static constructor를 통해 초기화 가능
public static int objCount = 100; // 처음 한번만 초기화 된다. public Customer(){ objCount++; // 객체 생성시마다 증가 } // …… Console.WriteLine(Customer.objCount); // static member field 접근

06 C# 형변환(Data Type Conversion)

2010-01-21T08:48:20+09:00

형변환의 문제

데이터 형식 끼리 변환해야하는 필요가 발생
byte a = 20; byte b = 100; byte result = a + b; // 형변환 error 출력, byte 값을 연산하면 암시적으로 // int형으로 변환되기 때문에 int 형보다 작은 byte 변수에 // 넣을 수 없다.
하나의 data type에서 다른 data type 으로 변환을 할 때, 컴파일러는 데이터 손실이 발생할 경우 명시적 형변환을 요구하고, 손실이 발생하지 않는다면 묵시적으로 형변환을 한다.
묵시적 형변환 : 작은 data type에서 큰 data type으로 변환 시
명시적 형변환 : 큰 data type에서 작은 data type으로 변환 시

묵시적 형변환

데이터의 형식변환에서 데이터 값이 변하지 않는다는 보장이 있을 때 자동으로 형변환이 이루어 지는 것
메모리상의 크기가 적은 data type에서 메모리상의 크기의 큰 data type으로의 변환
byte a = 20; byte b = 30; int result = a + b; // int data type은 byte type 보다 크기가 크기 때문에 // 묵시적형변환이 가능하다.

명시적 형변환

묵시적으로 형변환이 될 수 없는 예
int -> short
int -> uint
long -> int
float -> int
숫자 데이터 형 -> char
decimal -> 다른 숫자 데이터 형
......
명시적 형변환
형변환의 위험성을 개발자가 인지하고 있다는 것을 컴파일러에게 알려주어 강제적인 형변환이 가능하도록 하는 것
byte a = 20; byte b = 100; byte result = (byte)(a + b);

명시적 형변환의 위험성

명시적 형변환의 위험성
long value = 3210000000; int result = (int)value; // 여기서 result 값을 출력해보면 –1084967296라는 값이 // 나오게 된다. value 에서 지정한 값이 int 에서 허용하는 // 값을 초과했기 때문에 이런 결과가 나온다.
위의 예제는 error를 발생하지 않지만 결과는 원하던 결과와 다르게 나온다.
명시적 형변환 자체가 위험을 감수하고 변환하는 것이기 때문에 개발자는 이런 엉뚱한 상황이 발생할 수 있다는 것을 인지하고 있어야 한다.

이런 상황이 올 수 있는 경우 checked 연산자를 사용하여 stack overflow를 검사할 수 있다.

checked 연산자의 사용

명시적 형변환시 연산도중 발생할 수 있는 stack overflow를 검사하는 연산자
이를 통해 현재의 형변환이 안전한지를 검사할 수 있다.
long val = 3210000000; int i; checked{ // checked 연산자를 이용한 stack overflow 검사 i = (int)val; }
처리되지 않은 'System.OverflowException' 형식의 예외가 ConApp5.exe에서 발생했습니다.
추가 정보: 산술 연산으로 인해 오버플로가 발생했습니다.
checked 연산자를 통해 실행시 발생하는 문제를 미리 점검할 수 있다.

Boxing

value type 을 reference type 으로 묵시적으로 변환
//Boxing int i = 123; object o = i; // boxing Console.WriteLine(o.GetType()); string str = 123.ToString(); // boxing "123" 문자열 리턴 Console.WriteLine(str);

Unboxing

reference type 을 value type 으로 명시적으로 변환
// Unboxing int j = 234; object r = j; // boxing int k = (int)r; // unboxing Console.WriteLine(r.GetType()); Console.WriteLine(k); // 호환되지 않는 타입으로 unboxing 시도시 InvalidCastException 예외 발생 int l = 345; object s = l; // boxing float m = (float)s; // unboxing Exception

05 C# 열거형M_구조체_연산자

2010-01-21T09:06:32+09:00

열거형(enumeration)

열거자(enumerator)란 이름이 부여된 일련의 정수 상수로 구성되는 데이터 타입
열거자의 값은 기본적으로 0으로 시작하여 1씩 증가
값을 바꿀 수 있는데, 한 값을 바꾸면 다음 열거자부터는 바뀐값에서 1씩 증가
default type 은 int 이며 char를 제외한 정수형 타입(byte, sbyte, short, int, uint, long, ulong)의 지정이 가능

열거형 정의 및 사용

열거형 정의
enum Weekday{Mon, Tue, Wed, Thu, Fri, Sat, Sun}; // Mon=0, Tue=1, Wed=2, Thu=3, Fri=4, Sat=5, Sun=6 enum Weekday{Mon = 1, tue, Wed = 4, Thu, Fri = 7, Sat, Sun}; // Mon=1, Tue=2, Wed=4, Thu=5, Fri=7, Sat=8, Sun=9
열거형 사용
WeekDay weekday = WeekDay.Fri; // 또는 int weekday = (int)WeekDay.Fri;

구조체

대문자로 표시
value type
사용자 정의 데이터 타입을 정의하는데 사용
일반적으로 여러개의 필드를 포함하는 복합 데이터 타입(composite data type)을 정의하기 위해 사용
공개필드 멤버로만 포함하는 것이 일반적
생성자를 가질 수 있다.
이때 default 생성자는 재정의할 수 없으며, 반드시 파라메터가 있는 생성자이어야 한다.

구조체 정의 및 사용

구조체 정의
struct POINT { public int x; public int y; }
구조체 사용
POINT pt; pt.x = 10; pt.y = 20;

구조체 생성자 사용

struct POINT { public int x; public int y; public POINT(int x, int y) {// 구조체에서 생성자 사용시 파라메터가 있어야 한다. this.x = x; this.y = y; } }
// 구조체의 생성자 호출시 new 키워드를 사용한다. POINT pt = new POINT(20, 30); Console.WriteLine("POINT pt.x = {0}, pt.y = {1}", pt.x, pt.y);

04 C# 변수_배열

2010-01-21T09:10:24+09:00

변수의 종류

멤버 필드(member field)
Class 내부에 선언된 변수
지역 변수(local variable)
Method 내부에 선언된 변수

class MyVariable{
    private string name; // 멤버 필드 name
    public void SetName(string name, int age){ // 지역변수 name, age
        string cityName; // 지역변수 cityName
        ……
        for(int i = 0; i < 7; i++){    // 지역변수 i
        }
    }
}

변수 이름

변수 이름으로 사용할 수 있는 문자.
문자, 언더 바(_), 숫자
숫자로 시작할 수 없다.
공백이 포함되어서는 안된다.
예약 어는 사용할 수 없다.
class, struct, abstract, base, bool, default, if, finally ......

변수의 범위

public void SetProcess(){
    for(int i = 0; i < 10 ; i++){    // i 의 영역은 for문 안에서만 유효
    }
    for(int i = 0; i < 10; i++){     // 유효 : 첫번째 for문이 종료되므로 첫번째 i 역시 소멸
    }
}

public boolean SetProcess(){
    int a = 10;
    for(int i = 0; i < 10 ; i++){
        int a = 20;    // 위쪽 변수 a의 영역은 for문 역시 포함 되므로 같은 이름의 a 변수를 
                           // 또다시 선언할 수 없다.
    }
    return true;
}

배열

같은 데이터 타입의 값들을 포함할 수 있는 데이터 구조
Value type 이외에 object, interface 등 C#의 고유타입들이 들어올 수 있다.
초기화를 하지 않을 경우 디폴트값으로 초기화
선언시 배열명 앞에 [] 가 와야하며, new 를 통해 초기화
배열을 다른 배열로 복사시 Clone() 를 사용
동적인 배열을 생성해야 할 경우 ArrayList를 사용

배열 선언 및 초기화

// 선언
int[] arrDay;
arrDay = new int[12]; // new를 통해 배열 생성, 0~11 까지의 요소값을 가짐// 선언과 동시에 생성
int[] arrDay = new int[12];
arrDay[0] = 31; // 개별적인 초기화
arrDay[1] = 28;
… // 선언, 생성, 초기화를 한꺼번에
int[] arrDay = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

다중 차원 배열

Rectangle 배열

int[,] grid = new int[3, 4]; //세로 3, 가로 4의 배열 생성//다중차원 배열의 길이 얻기
int id1 = 0, id2 = 0, arrLength;
int[,] grid = new int[3, 4];
id1 = grid.GetLength(0); //배열생성시 지정한 첫번째 인덱스 리턴 == 3
id2 = grid.GetLength(1); //배열생성시 지정한 두번째 인덱스 리턴 == 4
arrLength = grid.Length; // id1 * id2 == 12

Rectangle 배열

// rectangular array
int [] a1 = new int[] { 1, 2, 3 };
int [,] a2 = new int[,] { {1, 2, 3}, {4,5,6} };
int [,,] a3 = new int[10,20,30];
// GetLength
Console.WriteLine("a1.GetLength(0) = {0}", a1.GetLength(0));
Console.WriteLine("-----------------------------");
Console.WriteLine("a2.GetLength(0) = {0}", a2.GetLength(0));
Console.WriteLine("a2.GetLength(1) = {0}", a2.GetLength(1));
Console.WriteLine("-----------------------------");
Console.WriteLine("a3.GetLength(0) = {0}", a3.GetLength(0));
Console.WriteLine("a3.GetLength(1) = {0}", a3.GetLength(1));
Console.WriteLine("a3.GetLength(2) = {0}", a3.GetLength(2));

Jagged 배열

// jagged array
int[][] j2 = new int[3][];
j2[0] = new int[] { 1, 2, 3};
j2[1] = new int[] { 1, 2, 3, 4, 5};
j2[2] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9};
// GetLength
Console.WriteLine("-----------------------------");
Console.WriteLine("j2.GetLength(0) = {0}", j2.GetLength(0));
//Console.WriteLine("j2.GetLength(1) = {0}", j2.GetLength(1));
Console.WriteLine("-----------------------------");
Console.WriteLine("j2[0].GetLength(0) = {0}", j2[0].GetLength(0));
Console.WriteLine("j2[1].GetLength(0) = {0}", j2[1].GetLength(0));
Console.WriteLine("j2[2].GetLength(0) = {0}", j2[2].GetLength(0));
Console.WriteLine("-----------------------------");

배열 사용

배열 값 얻기

int[] arrDay = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; for(int i=0;i< arrDay.Length;i++){  //Length 속성은 배열의 크기를 리턴(12)
    Console.WriteLine(i + “월의 마지막 날은 " + arrDay[i] + " 일 입니다.");
}

배열 복사

int[] arrDay = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int[] newDay = new int[12];        // 새 배열 생성
 newDay = (int[]) arrDay.Clone(); 
 // 원본배열의 Clone()메소드를 통해 복제해야 한다.

03 C# Data Type과 변수_상수_문자열

2010-01-20T16:42:04+09:00

CTS(Common Type System)

CTS는 서로 다른 언어에서 상호작용을 하기위한 표준 데이터 형식을 정의한 것
서로 다른 Language로 제작된 class의 인스턴스를 만들거나 상속받을 때는 해당 class에서 사용하는 data type을 알아야한다.

Value Type 과 Reference Type

Value Type
메모리 상의 스택(stack)에 저장됨
Stack : int(4byte 크기) 형식 처럼 고정된 길이를 갖는 데이터를 저장
변수 선언시 실제 값을 내부에 가짐
변수 대입시 같은 데이터의 복사본을 메모리에 만듬(서로 영향을 미치지 않는다.)
정수형, 부동소수점형, decimal 형, boolean 형, 구조체(struct)
Reference Type
메모리 상의 힙(heap)에 저장됨
Heap : 동적인 크기를 가진 데이터를 저장하는 공간
변수 선언시 변수는 실제 값이 저장된 위치에대한 주소를 가짐
변수 대입시 주소값을 복사하게 됨(서로 영향을 미칠 수 있다.)
class, interface, 배열(array), 위임(delegate)

상수와 읽기 전용 변수

상수(constant)
변하지 않고 항상 같은 값, 변경불가, 오직 읽기 전용
const double PI = 3.14;

읽기 전용 변수(read-only variable)
readonly 키워드
class 의 멤버필드(변수)에만 사용가능,
필드초기화 또는 생성자(constructor)에서 초기화한 후에 읽기 전용으로 사용

Reference Type

객체(object)의 레퍼런스(reference) 정보를 저장
객체 또는 배열에 할당된 메모리 위치 정보가 저장됨

class type
interface type
array type
delegate type

OOP 및 Delegate, Event 강좌에서 상세 설명

문자열(string)

string 은 class 이다.
string str = "hello world!"; - 주로 자료형처럼 사용 // 위의 문장은 아래와 동일한 의미 string str = new string("hello world!"); -주로 클래스 인스턴스생성시 사용 // 하지만 이 문장은 에러를 발생, string 클래스의 인스턴스는 new를 사용하지 않음.
string type은 값이 변동될 때 내부적으로 다르게 처리
string str = "hello world!"; str = "another world!"; // string class 의 인스턴스는 읽기 전용으로 변경이 불가능하다. // 위의 코드는 새로운 문자열을 저장할 공간을 만든 후, 거기에 문자열을 넣고 // 해당 주소를 str 이라는 레퍼런스 변수에 저장하는 과정이 된다. // 이러한 과정은 문자열과 문자열을 더하거나 잘라내는 과정에서도 발생

문자열(string)

class 이지만 value type 처럼 값 대입시 실제 값이 대입됨
string str1 = “Hello"; string str2; str2 = str; str2 = " world!"; Console.WriteLine(str1 + str2); // string 의 처리는 value type 처럼 실제 값을 복사한다.

02 C# Language 기본구조

2010-01-21T09:11:23+09:00

C# Language 기초

C, C++, Java 처럼 세미콜론(;)으로 문장 구분
a +=1 ; b += 1;

하나의 처리 단위를 이루는 문장들은 중괄호 { } 내부에 들어 있어야 한다.
for, if

모든 코드는 class 안에 코딩

class MyClass{
int a = 0;
public static void Main(){} 
}

외부에서 참조할 class 는 using 키워드를 사용

using System;

C# Language 기본 구조

Hello World Application

using System;
 
class HelloClass
{
 public static void Main()
 {
  Console.WriteLine("Hello World~!");
  System.Threading.Thread.Sleep(10000);
 }
}

Namespace

영역을 구분하는 데 사용
.NET Framework에서 제공하는 기본적인 class 들은 각각의 특성에 맞는 이름을 가진 namespace로 나뉨
namespace 는 종속관계가 없다.
System 이라는 namespace 와 System.Threading 이라는 namespace는 서로 관계가 없다.

using System; // 필요한 class 가 들어있는 namespace는 using 키워드를 사용
…
Console.WriteLine("Hello Class");
Thread.Sleep(10000); // System이라는 namespace에 Thread라는 Class없음
Threading.Thread.Sleep(10000); // Threading 이라는 namespace가 없음
System.Threading.Thread.Sleep(10000); // 정상작동

Class

Class
생성자(constructor), 소멸자(destructor), 상수(constant), 필드(field), 메소드(method), 속성(property), 인덱서(indexor), 연산자(operator) 등을 멤버로 포함
Class의 특성은 field와 property로 표현
Class의 행위(behavior)는 method로 표현
access modifier를 통해 information hiding 구현

class HelloClass
{
    ……
}

Main()

Application 의 진입점인 Main method

public static void Main()
{
    ……
}

public 은 접근제한자로 class 외부에서도 접근이 가능
static 은 객체의 인스턴스를 통하지 않고 class 차원에서 Main method를 호출할 수 있다는 것
void 는 리턴값이 없다는 의미

Return value

using System;
class HelloClass
{
 static int Process()
 {
  int a = 4, b = 3;
  return a * b;
 }
 public static void Main(string[] args)
 {
  Console.WriteLine("Hello World!");
  Console.WriteLine("return value = {0}", Process());
   System.Threading Thread.Sleep(10000);
 }
}

Parameter

using System;
class HelloClass
{
 static int Process(int a, int b)
 {
  return a * b;
 }
 public static void Main(string[] args)
 {
  Console.WriteLine("Hello World!");
  Console.WriteLine("return value = {0}", Process(3, 4));
   System.Threading Thread.Sleep(10000);
 }
}

01 .NET 과 C# Language

2010-01-20T16:23:01+09:00

프로그래밍 방법

Win32 프로그래밍
주로 C로 제작함. 메모리관리 수동적으로 해야함. 절차적프로그램으로 제약을 줌
C++/MFC 프로그래밍
C언어보다 월등히 좋아졌지만, 여전히 메모리관리 수동으로 해야함. 복잡한 포인터연산
VB 프로그래밍
간단하게,쉽게,빠르게 개발해보자는 컨셉. 객체지향 언어 아님.
Java 프로그래밍
객체지향, 플렛폼 독립적, 다양한 패키지 지원하기 때문에 파워풀하게 개발 할 수 있다.단점은 실행에 대단히 느림.
COM 프로그래밍
언어 독립적, 컴파일을 가지고 새로운 프로그램 만들수 없고, 단순히 재사용면에서만 가능
Windows DNA 프로그래밍
분산어플리케이션에서 사용. 다양한 기술과 언어를 사용해서 개발해야하기 때문에 상당한 시이 걸린다.

.NET Framework의 특징

코드 재사용성
컴파일에서 사용했던것을 재사용함. 어셈블리에서 사용
언어의 통합
공통적인 실행환경을 제공
기본클래스 라이브러리(base class libraries)
COM의 복잡한 연결고리에서 탈출
단순한 개발 모델

.NET Framework

.NET의 핵심 요소

CLR – 메모리관리, 이진코드라이브러 단순하게 배포, 로드하고 관리하는 일
Common Language Runtime
Base Class Library
CTS – 런타임이 지원 모든 데이터타입들이 상호 작용하는지 메타 데이터 지원
Common Type System
CLS – 공통타입들을 묶어서 부분집합으로 분류할때 사용한는 일종의 명세서
Common Language Specification

Common Language Runtime

Runtime : 코드 블럭을 실행시키는데 필요한 모든 서비스를 총칭하는 것
.NET Platform Runtime의 특징
.NET 지원의 모든 언어들 위에 적절히 정의해 둔 하나의 계층을 둔 것.
CLR의 두가지 핵심 개체
Mscoree.dll 이라는 런타임 실행 엔진
기본 클래스 라이브러리(base class libraries)
IL파일 명령어식으로 만들어서 제공

Common Type System

CTS는 Runtime이 지원하는 모든 data type이 어떻게 서로간에 상호 작용을 하는지, metadata 형식을 어떻게 표현할 것인지를 정해 주는 것

CTS는 class나 structure, interface, 고유 데이터 타입 같은 각각의 타입들을 설명해 주는 공식화된 명세(formal specification)

CTS의 멤버
CTS class type(클래스 타입)
CTS structure type(구조체 타입)
CTS interface type(인터페이스 타입)
CTS type member(타입 멤버)
CTS enumeration type(열거형 타입)
CTS delegate type(위임 타입)
CTS intrinsic data type(고유 데이터 타입)

Common Language Specification

서로 다른 언어로 제작된 코드를 가지고 각각의 컴파일러를 통해 공통된 IL 명령어 집합을 구성해야 하는데,
이때 기준이 되는 규칙이 CLS이다.
예) CLS 규칙 1
CLS 규칙은 단지 정의된 어셈블리에서 밖으로 노출시킨 타입에서만 정의된다. – 외부에 노출되는 것에만 적용된다는 것임

Base Class Library

.NET 지원 프로그래밍 언어에서 사용할 수 있도록 기본적으로 제공되는 라이브러리

File I/O, 그래픽 표현, 외부 하드웨어 장치와의 상호작용에 필요한 class 등 기본적인 구현에 필수적인 요소와 실제 애플리케이션 작성에 필요한 부가적인 요소까지 함께 제공

Data Access, GUI, secret, XML/SOAP, thread, File I/O, degugging ...

C# Language의 특징

.NET platform 에 가장 잘 들어맞도록 설계된 언어

Java 처럼 문법적으로 깔끔하고, Visual Basic 처럼 쉽고, C++ 처럼 유연하고 강력한 언어를 지향

Visual Basic의 class property 와 C++의 연산자 오버로딩을 C#에 반영(이 두가지는 Java에 없다.)

C#은 .NET Runtime(CLR)에서만 작동

.NET 지원 언어의 실행과정

프로젝트관리 고홈 버전 1

2010-01-08T11:15:55+09:00

[0911-1001] C#, .NET Framework 3.5, MSSQL
어플리케이션 ( 가칭 고홈 관리자모듈 버전 1 )

내가 아이폰을 사진 못했어도 아이폰에 찍히다 ㅎㅎ

2009-12-16T08:59:07+09:00

상큼한걸..

경험경제, 경험산업 시대의 진정성에 대해서, 조셉파인의 TED 발표

2009-12-08T12:34:59+09:00

출처 : http://uxfactory.com/789

Hungarian Rhapsodies

2009-12-03T10:47:33+09:00

No. 1 in E major (à son ami E. Zerdahely)

No. 2 in C-sharp minor (au Comte Ladislas Teleky)

No. 3 in B-flat minor (au Comte Leo Festetics)

No. 4 in E-flat major (au Comte Casimir Esterházy)

No. 5 in E minor, Héroïde-élégiaque (Comtesse Sidonie Reviczky)

No. 6 in D-flat major (au Comte Antoine d'Appony)

No. 7 in D minor (au Baron Fery Orczy)

No. 8 in F-sharp minor (à Anton Augusz)

No. 9 in E-flat major, Pesther Carneval (à H. W. Ernst)

No. 10 in E major (à Béni Egressy)

No. 11 in A minor (au Baron Fery Orczy)

No. 12 in C-sharp minor (à Joseph Joachim)

No. 13 in A minor (au Comte Leo Festetics)

No. 14 in F major (à Hans von Bülow)

No. 15 in A minor, Rákóczi-Marsch

No. 16 in A minor (Budapest Munkácsy-Festlichkeiten)

No. 17 in D minor

No. 18 in F-sharp minor (ungarischen Ausstellung in Budapest)

No. 19 in D minor, d'après les 'Csárdás nobles' de K. Ábrányi (sr)

이미지 트랙킹 툴

2009-12-09T13:25:04+09:00

이미지 스크랩 이벤트 등관련해서

해당 스크랩된 이미지가 얼마나 노출되는지를 알아보기위한

IIS + 404페이지를 이용한 트랙킹툴사이트

[0911]ASP, MSSQL, IIS6.0