다다

윈폼이라는 것에 대해서 알아봐야 할것이다.

MFC를 해본 나로서는 윈폼과 그에 대한 이벤트는 그렇게 까지 난해하게 다가오지는 않았다.

실제 MFC의 이벤트등도 VS스튜디오의 툴 내에서 손쉽게 지정이 가능하다.

VS C#에서도 이에대해서 충실하게 지원해준다.

보면 왼쪽에 있는 툴박스에서 버튼 컨트롤을 선택한후 오른쪽에 보이는 속성창에서 이벤트등을 생성해 줄수 있다.

MFC와 거의 동일한 인터페이스 이다.

이벤트란 간단히 말해서

버튼을 눌렀다.

창을 키웠다.

창을 움직였다 등을 의미합니다.

그러한 이벤트가 벌어졌을시 특정한 행동을 해라. 라는것이 기본적인 이벤트의 사용법 입니다.

그러한 이벤트가 벌어졌을시 특정한 행동을 해라. 라는것이 기본적인 이벤트의 사용법 입니다.

시간을 알려주는 구조체이다. 사용법은 아래와 같고.

자세한 내용은 msdn의 구조체 항목에서 datetime 구조체를 참고하면 된다.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    class Program

    {

        static void Main(string[] args)

        {

            DateTime dt = DateTime.Now;

            string str;

            str = string.Format("금일은 {0}년 {1}월 {2}일({3})이다", dt.Year, dt.Month, dt.Day, dt.DayOfWeek);

            Console.WriteLine(str);

            str = string.Format("현재 {0}시 {1}분 {2}초({3})이다", dt.Hour, dt.Minute, dt.Second, dt.Millisecond);

            Console.WriteLine(str);

            str = string.Format("dt.Date {0}", dt.Date);

            Console.WriteLine(str);

            str = string.Format("짧은 날짜 형식 {0}", dt.ToShortDateString());

            Console.WriteLine(str);

        }

    }

}

namespace ConsoleApplication1

{

    struct MyData

    {

        public int x, y;

        public MyData(int x, int y)

        {

            this.x = x;

            this.y = y;

        }

        public MyData(ref int x, ref int y)

        {

            this.x = 0;

            this.y = 0;

        }

        public void NoShow()

        {

            Console.WriteLine("no swap");

            Console.WriteLine("{0}        {1}", this.x, this.y);

        }

        public void Show()

        {

            Console.WriteLine("swap");

            Console.WriteLine("{0}        {1}", this.x, this.y);

        }

    }

    class MyDataClass

    {

        public int x = 10, y = 100;

        public void NoShow()

        {

            Console.WriteLine("No swap");

            Console.WriteLine("{0}        {1}", x, y);

        }

        public void Show()

        {

            Console.WriteLine("swap");

            Console.WriteLine("{0}        {1}", x, y);

        }

    }

    class Swap

    {

        static public void CSwapdata(MyDataClass md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

        static public void CSwapdata1(ref MyDataClass md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

        static public void Swapdata(MyData md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

        static public void Swapdata1(ref MyData md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            MyData Md = new MyData(10, 100);

            MyData Md1;

            Md1.x = 10;

            Md1.y = 100;

            Console.WriteLine("new struct value");

            Md.NoShow();

            Swap.Swapdata(Md);

            Md.Show();

            Console.WriteLine("new struct ref");

            Md.NoShow();

            Swap.Swapdata1(ref Md);

            Md.Show();

            Console.WriteLine("value struct value");

            Md1.NoShow();

            Swap.Swapdata(Md1);

            Md1.Show();

            Console.WriteLine("value struct ref");

            Md1.NoShow();

            Swap.Swapdata1(ref Md1);

            Md1.Show();

            MyDataClass CMd = new MyDataClass();

            Console.WriteLine("class value swap");

            CMd.NoShow();

            Swap.CSwapdata(CMd);

            CMd.Show();

            Console.WriteLine("class ref swap");

            CMd.NoShow();

            Swap.CSwapdata1(ref CMd);

            CMd.Show();

        }

    }

}

구문이 좀 길지만 실행해보면 차이를 알수 있다.

구조체의 경우 ref로 참조하지 않을 경우 원본의 데이터를 바꿀수 없다.

이것은 구조체를 new로 할당하거나 그냥 할당해도 마찬가지이다.

클래스의 경우에는 반대이다. 어떤 방식으로 넣어도(ref로 넣던 값형으로 넣던) 내부의 데이터를 변경할수가 있다.

즉 클래스는 애초부터 참조형 형태의 데이터이고 구조체의 경우에는 값형 데이터이며 이 차이를 명확하게 인식해야 한다.

빠르게 배워나가는 도중이기 때문에 변수나 함수에 대해서 깊게 파고 있지는 않았다.

하지만 C#에서는 몇가지 새로운 경고와 변수의 사용시점등이 약간 다른 면이 있어서 다음과 같이 정리해 보았다.

    class aaa

    {

        private int c = 0; -> 선언 순간 초기화. 봐도 신기하기는 하다.

        public void a()

        {

            this.c = 1;

        }

    }

위의 클래스를 컴파일 하면 다음과 같은 경고가 뜬다.

경고 CS0414: 'ConsoleApplication1.aaa.c' 필드가 할당되었지만 그 값은 사용되지 않습니다.

사용되지 않았다? 그냥 상수 값의 대입은 컴파일러가 사용하지 않았다라고 판단하는 것 같다.

그럼 어떤때 사용했다고 할까?

    class aaa

    {

        private int c = 100;

        public void a()

        {

            int dd = 100;

            this.c = dd; -> 이 녀석을 대입하면 사용했다고 본다. 상수가 지역변수등을 혹은 public void a(int temp) { this.c = temp;} 같은 식도 된다.

            b(this.c); -> 아무것도 없는 함수지만 내부에 넣었다는 것만으로도 사용한 것으로 본다.

        }

        public void b(int a)

        {

        }

        public void p()

        {

            Console.WriteLine(c); -> 마찬가지다.

        }

        public aaa(int a)

        {

            this.c = a; -> 생성자를 만들어서 대입해주면 역시나 사용했다고 인식한다.

        }

    }

인덱서란? ------------------------------------------------------------------------------------------------------------------------

  인덱서란 내부에 존재하는 맴버변수나 혹은 인스턴스를 배열과 같이 취급하는 것을 인덱서라고 한다.

  문법적으로는 C#의 속성의 배열 버전이라고 보면 된다 보인다.

    class SampleCollection<T>

    {

        private T[] arr = new T[100]; -> 어라 클래스의 맴버변수를 내부에서 그냥 초기화 해버린다. 가능했구나...

  private int c = 0; -> 이렇게 굳이 할당을 하지 않아도 가능하다.

        public T this[int i] -> 이녀석이 인덱서이다. this구문을 무조건 붙여줘야 한다.

        {

            get

            {

                return arr[i]; -> 내부 인스턴스의 값을 배열적인 측면으로 접근이 가능하다.

            }

            set

            {

                arr[i] = value; -> 마찬가지로 대입도 가능하다.

            }

        }

    }

    // This class shows how client code uses the indexer

    class Program

    {

        static void Main(string[] args)

        {

            SampleCollection<string> stringCollection = new SampleCollection<string>();

            stringCollection[0] = "Hello, World"; -> 객체에서 즉각 접근이 가능해진다.

            stringCollection[1] = "World, Hello"; -> 배열이니 인덱스를 바꾸는 것도 마찬가지.

            System.Console.WriteLine(stringCollection[1]);

        }

    }

일단 구조체의 사용법을 좀 보자.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    interface a

    {

    }

    struct Player : a

    {

        public string name;

        public int Att;

        public int Def;

        public int Hp;

        public int Dex;

        public Player(string name, int Att, int Def, int Hp, int Dex) -> 생성자를 만들었다면

        {

            this.name   = name;

            this.Att    = Att;

            this.Def    = Def;

            this.Hp     = Hp;

            this.Dex    = Dex; -> 내부에서 마지막 맴버까지 모든 맴버를 초기화 시켜줘야 한다. 그렇지 않으면 오류가 난다.

        }

        public void Show()

        {

            Console.WriteLine(name + "의 능력:");

            Console.WriteLine("공격력: " + Att + ", 방어력: " + Def + ", 체력:" + Hp + ", 민첩성: " + Dex);

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            Player Player1 = new Player("수깔", 94, 96, 84, 92);

            Player1.Show();

            Player Player2;

            Player2.name = "빨딴";

            Player2.Att = 100;

            Player2.Def = 84;

            Player2.Hp = 96;

            Player2.Dex = 86;

            Player2.Show();

        }

    }

}

c++에서 사용하는 구조체와 동일하게 이용이 가능하나 다음과 같은 차이가 생겼다.

1. 인터페이스를 제외하고는 상속이 불가능하다.(c++에서는 구조체도 클래스 상속이 가능했습니다. 아니 구조체와 클래스의 차이가 없다고 봐도 무방할 정도다.)

2. 디폴트 생성자를 지원하지 않는다.(생성자를 만들어 놓지 않으면 경고가 미친듯이 뜬다. 컴파일은 된다.)

3. 또한 initilizer를 지원하지 않는다. 무슨 말이냐면.

    struct Player

    {

        public int Att = 0; -> 구조체는 이런식으로 초기화가 불가능하다.

    }

4. 구조체는 명시적매개변수가 없는 명시적 생성자를 포함할수 없다.

    struct MyData

    {

        private int x, y;

        public MyData() -> 이런 녀석은 만들 수가 없다.

        {

            this.x = 0;

            this.y = 0;

        }

    }

5. 또한 내부의 static변수는 내부의 모든 맴버가 초기화 하기 전까지는 사용이 불가능하다.

    namespace ConsoleApplication1

    {

        interface a

        {

        }

        struct Player : a

        {

            public string name;

            public int Att;

            public int Def;

            public int Hp;

            static public int Dex;

            public Player(string name, int Att, int Def, int Hp, int Dex)

            {

                this.name = name;

                this.Att = Att;

                this.Def = Def;

                this.Hp = Hp;

            }

            public void Show()

            {

                Console.WriteLine(name + "의 능력:");

                Console.WriteLine("공격력: " + Att + ", 방어력: " + Def + ", 체력:" + Hp + ", 민첩성: " + Dex);

            }

            public void SetDex()

            {

                Dex = 100; -> 보면 알겠지만 static 맴버는 this라는 

            }

        }

        class Program

        {

            static void Main(string[] args)

            {

                Player Player1;

                //Player1.SetDex();

                Player1 = new Player("수깔", 94, 96, 84, 92);

                Player1.Show();

                Player1.SetDex(); -> 모든 변수가 초기화된 후에야 사용이 가능하다.

                Player Player2;

                Player2.name = "빨딴";

                Player2.Att = 100;

                Player2.Def = 84;

                Player2.Hp = 96; -> //Player2.Hp = 96; 초기화중 모든 맴버를 할당하지 않고 사용하려고 하면 오류가 뜬다. 할당되지 않은 지역변수를 사용했다는 오류다.

                                   // 그래서 내부적으로 맴버를 사용하지 않는 함수를 만들어서 시험해 사용해봤으나 마찬가지의 결과가 나왔다.

 // 즉 귀찮게 생각하지 말고 무조건 static맴버를 제외하고는 초기화 시켜라!

                Player2.Show();

                Player1.Show();

            }

        }

    }

7. 마지막으로 구조체는 값형의 데이터이다. 따로 주소가 할당되지 않기 때문에. 그냥 값형을 인자로 받는 함수에 넣을 경우 원본 데이터에는 아무런 영향이 가지 않는다.

[C#] 인터페이스, 추상클래스, 클래스

Programming/.NET Programming 2009/05/31 05:11

abstract 키워드를 사용하면 불완전하여 파생 클래스에서 구현해야 하는 클래스 및 클래스 멤버를 만들 수 있습니다.

public abstract class A
{
    // Class members here.
}

public abstract class A
{
    public abstract void DoWork(int i);
}

// compile with: /target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

public sealed class D
{
    // Class members here.
}

public class D : C
{
    public sealed override void DoWork() { }
}

인터페이스란? ----------------------------------------------------------------------------

  c# 에서는 기본적으로 다중상속을 지원하지 않는다.

  class a {}

  cass b {}

  class c : a, b {} -> 이런식의 상속은 불가능하다는 것이다.

  하지만 인터페이스라는 녀석은 실행가능한 코드를 포함하지 않는 특수한 클래스로서. 마치 c++의 순수가상클래스와 비슷한 역할을 한다.

    class Program

    {

        static void Main(string[] args)

        {

            SubA _Sub = new SubB();

            _Sub.Fun();

        }

    }

    interface InterA -> 인터페이스의 선언부분이다.

    {

        void Fun(); -> 구현은 없는 선언을 인터페이스의 필드에 포함시킨다.

    }

    class SubA : InterA -> 인터페이스를 상속한다.

    {

        public virtual void Fun() -> 이런식으로 가상함수로 정의가 가능하다.

        {

            Console.WriteLine("zzzzz"); -> 순수가상함수를 상속한 클래스와 비슷하다. 인터페이스에 존재하는 함수의 구현을 포함시켜야 문법적으로 오류가 나지 않는다.

        }

    }

    class SubB : SubA -> 인터페이스를 구현하고 있는 클래스를 상속했다.

    {

        public override void Fun() -> 당연히 오버라이드도 가능하다.

        {

            Console.WriteLine("XXXX");

        }

    }

다중상속은 지원하지 않지만 다중 인터페이스 상속은 지원한다. 

    interface Inter1

    {

    }

    interface Inter2

    {

    }

    class SubA : Inter1, Inter2

    {

    }

클래스와 함께 상속시킬 수도 있다.

    interface Inter1

    {

    }

    interface Inter2

    {

    }

    class SubB

    {

    }

    class SubA : SubB, Inter1, Inter2 -> 인터페이스는 이렇게 몇개든 상속이 가능하다.

    {

    }