[문과 코린이의 IT 기록장] C# - 클래스 2 (구조체 , 제네릭 (Generic), Delegate / Event)

[문과 코린이의 IT 기록장] C# - 클래스 2 (구조체 , 제네릭 (Generic), Delegate / Event)

C# 프로그래밍 기초 - 인프런 | 강의

본 강좌는 C# 문법 위주로 구성되어있지 않습니다. 클래스를 이해하고 만드는 요령 위주로 구성되어 있습니다. 기초 문법도 다루지만 많은 예제를 가지고 진행하기 때문에 프로그램 실전 작성

www.inflearn.com

1. 구조체 (Struct)

1) 참조 형식(클래스)과 값 형식(구조체)에 대한 이해

- Heap Memory / Stack Memory

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Program 
    {
        static void Main(string[] args)
        {
            // Value Type의 특성
            // - 동작방법 
            /*int a = 1;
            int b = 2;
 
            Console.WriteLine($"1. a = {a} b = {b}");
            int c = ValueTypeTest(a, b);
            Console.WriteLine($"2. a = {a} b = {b}");*/
 
 
            Console.WriteLine("클래스 : 참조 형식");
            Student1 st1 = new Student1();
            st1.Name = "Lee";
            Console.WriteLine(st1.Name);
            ReferenceTypeTest(st1);
            Console.WriteLine(st1.Name);
 
            Console.WriteLine("-----------------------------------");
 
            Console.WriteLine("구조체 : 값 형식");
            Student2 st2 = new Student2();
            st2.Name = "Lee";
            Console.WriteLine(st2.Name);
            ReferenceTypeTest(st2);
            Console.WriteLine(st2.Name);
        }
 
 
 
        static int ValueTypeTest(int a, int b) // 호출할 때 값을, copy해 준 것. (참조가 X)
        {
            Console.WriteLine($"3. a = {a} b = {b}");
            a++;
            b++;
            Console.WriteLine($"4. a = {a} b = {b}");
            return a + b;
        }
 
        static void ReferenceTypeTest(Student1 a)
        {
            a.Name = "Kim";
        }
 
        static void ReferenceTypeTest(Student2 a)
        {
            a.Name = "Kim";
        }
 
    } 
 
    /// <summary>
    /// 참조 형식으로 학생 클래스입니다.
    /// </summary>
    class Student1
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
 
    struct Student2
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
 
}

2) 구조체 정의

- 클래스 정의와 유사하다.

- class 예약어를 struct 예약어로 대체한다.

3) 구조체가 클래스와 다른점

- 인스턴스 생성을 new로 해도 되고, 안 해도 된다.

- 참조 형식이 아니라 값 형식이다.

- 기본 생성자는 명시적으로 정의 불가능하다.

- 매개변수를 갖는 생성자를 정의해도, 기본 생성자가 C# 컴파일러에 의해 자동 포함된다.

- 매개변수를 받는 생성자의 경우, 반드시 해당 코드 내에서, 구조체의 모든 필드에 값을 할당해야 한다.

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Program
    {
        static void Main(string[] args)
        {
            Student st = new Student();
            Student st1 = st; // 메모리 자체가 통째로 복사되는, 깊은 복사가 이루어짐.
            Student st2; // new를 쓰지 않고 생성 가능 (값 형식 변수이기 때문)
 
            st.Name = "Lee";
            st1.Name = "Kim";
            //st2.Name = "Kim";
 
            Console.WriteLine(st.Name);
            Console.WriteLine(st1.Name); // 깊은 복사이기 때문에, 새로운 메모리 공간에 st1이 만들어진 것. 따라서, 둘은 다른 값을 가짐
 
            AAA(st);
        }
 
 
        static void AAA(Student st) // 깊은 복사 발생. (스택에서 발생) - 구조체는 참조형식 X. (매개변수만 참조형식으로 힙에 존재)
        {
        }
 
 
        /// <summary>
        /// 참조 형식으로 학생 클래스입니다.
        /// </summary>
        struct Student
        {
            public string Name { get; set; }
            public int Age { get; set; }
 
            // 1. Sturct에 대해, C컴파일러가 알아서, 매개변수가 없는 생성자를 만들어준다.
            // public Student() { }; // 구조체는 명시적으로 기본 생성사를 정의하는 것이 불가능하다.
 
            // 2. 매개변수를 갖는 생성자의 경우, 반드시 해당 코드 내에 구조체의 모든 필드의 값을 할당해야 한다.
            public Student(string name, int age)
            {
                Name = name;
                Age = age;
            }
        }
 
    }
}

2. 제네릭 (Generic)

- OOP에서 Object를 처리하는데 발생하는 문제점들을 개선하기 위한 하나의 방법

1) Generic 탄생 동기

- ArrayList를 사용할 때, boxing, unboxing의 문제와, 코드 중복의 문제를 해결하기 위해, Generic이라는 개념이 나타났다.

 using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Student;
 
namespace class_0804
{
    class generic
    {
 
        public void Run()
        {
            ArrayList list = new ArrayList();
            list.Add(4); // boxing 발생
            int a = (int)list[0]; // unboxing 발생
 
            PrintMe(3);
            PrintMe("String");
        }
 
        // [문제] 여러 종류의 Type이 존재할 때, 이렇게 함수를 다 나눠서 코드를 작성해야 할 것인가?
        // - 코드 중복이 굉장히 많이 발생
        private void PrintMe(int val)
        {
            Console.WriteLine($"val = {val}");
        }
        private void PrintMe(string val)
        {
            Console.WriteLine($"val = {val}");
        }
 
      
    }
}

2) Generic 사용법 : ArrayList -> List<T>

a. 프로젝트 1 - [ Generic.cs ]

 using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Student;
 
namespace class_0804
{
    class generic
    {
        public void Run()
        {
            // [해결방법] List 컬랙션 사용
            // 1. int 사용
            // List<T> list = new List<T>(); // T : 타입 변수명 = Type Parametor (Generic)
            List<int> list = new List<int>(); // int ArrayList 생성 : 이 ArrayList에는 int만 들어온다. 다른 것이 들어오면 error.
 
            list.Add(1); // 가능 O
            // list.Add("string"); // 불가능
 
            int a = list[0]; // (int)로 캐스팅 해줄 필요 없음. 즉, unboxing이 필요 없음. (Type을 int로 설정했기 때문)
 
	// 2. 클래스 사용
            // 다른 프로젝트의 클래스를, 각각 클래스는 어셈블리 파일(.exe, .dll)로 구성되어 있으며, 이들 간에 서로가 보일려면 public이라는 접근 제한자를 쓸 수 밖에 없음. 
            // 참조로, Student namespace를 가져온 후, StudentC 사용
            List<StudentC> list1 = new List<StudentC>();
            StudentC st = new StudentC(); // st 인스턴스 생성
            list1.Add(st);
            //list1.Add(1); // 타입 불일치. 불가능.
        }
    }
}

b. 프로젝트 2 - [StudentC.cs]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Student
{
 
    // public class Student = internal class Student
    // ( internal이란? : 동일한 어셈블리 내에서는 public과 같이 동작됨. 그러나 다른 어셈블리에서 바라봤을 때는 보이지 않는다. )
    
    // 다른 프로젝트에서 해당 클래스를 가져다 쓰기 위해서는, public을 넣어줘야 함.
    public class StudentC:IComparable // IComparable : 두 객체를 비교하기 위한 인터페이스 (배열 및 컬랙션을 정렬하는데 효과적인 인터페이스)
    {
        public string Name { get; set; }
        public int StudentSex { get; set; }
        public int Score { get; set; }
 
        public int CompareTo(object obj)
        {
            StudentC st1 = obj as StudentC;
            // return Score - st1.Score;
            return Name.CompareTo(st1.Name);
        }
 
        public override string ToString()
        {
            return $"{Name}[{StudentSex}][{Score}]";
        }
    }
}

3) Generic class & Generic method

 using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Student;
 
namespace class_0804
{
    class generic
    {
        public void Run()
        {
            // 1. Generic Class < T >
            PrintAny<int> p1 = new PrintAny<int>(); // PrintAny형의 인스턴스 p를 생성 (내부 T는 모두 int형으로 변환)
            p1.Print(3);
 
            PrintAny<double> p2 = new PrintAny<double>(); // PrintAny 인스턴스 p2를 생성 (내부 T는 모두 double형으로 변환)
            p2.Print(3.141592);
 
            PrintAny<StudentC> p3 = new PrintAny<StudentC>();
            StudentC st = new StudentC();
            st.Name = "홍길동";
            p3.Print(st);
 
            // 2. Generic Method
            PrintAny1 p4 = new PrintAny1();
            p4.Print<int>(15);
            p4.Print(10); // <int>를 지정해주지 않아도, 타입 추정 가능.
 
            // 3. Generic Class < T, U >
            PrintAny2<int, string> p5 = new PrintAny2<int, string>();
            p5.Print(33, "string");
 
        }
    }
 
 
    // [문제] 수많은 기본 타입, class들이 존재함. 그런데, 이렇게 type별로 print해야하는 클래스를 모두 만드는 것은 어려움
    class PrintInteger
    {
        public void Print(int val)
        {
            Console.WriteLine($"val = {val}"); 
        }
    }
 
    // [해결방법] Generic Class<T>로 해결
    class PrintAny<T> // Generic Class : T는 어떤 type이던, 컴파일 타임 때 지정된 type으로 전부 다 변경됨.
    {
        public void Print(T val) // T는 타입변수. 따라서 이렇게 선언 가능
        {
            Console.WriteLine($"val = {val}");
            // Console.WriteLine($"val = {val + 1}"); 
            // 이는 불가능. 특정 타입에 관계된 연산 처리와 같은 것을 Generic이라고 쓸 수 없음. 즉, 범용으로 커버하는데 사용될 수 없음. 
        }
    }
 
    // [해결방법] Generic Method로 해결
    class PrintAny1
    {
        public void Print<T>(T val) // Generic Method
        {
            Console.WriteLine($"val = {val}");
        }
    }
 
    // Generic Class <T, U>
    class PrintAny2<T, U> 
    {
        public void Print(T val1, U val2) 
        {
            Console.WriteLine($"val1 = {val1}, val2 = {val2}");
        }
    }
 
    // T와 U가 IComparable이라는 인터페이스를 구현하지 않은 타입이라면 받아들이지 못한다. ex. :IComparable을 하지 않은 클래스
    class PrintAny3<T, U> where T:IComparable where U:IComparable
    {
        public void Print(T val1, U val2)
        {
            Console.WriteLine($"val1 = {val1}, val2 = {val2}");
        }
    }
}

3. Delegate / Event

1) Delegate

- Method를 값으로 갖는 타입

 int a = 3; // 3이라는 value를 가지는 타입 - value 타입
Student st = new Student(); // Student 객체를 갖는 타입 - reference 타입
delegate void MyDelegate(int a); // 함수를 값으로 갖는 타입 - delegate 타입

- delegate가 붙으면 method가 아니라 MyDelegate가 Student, int 처럼 type으로 선언된다.

 using Student;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Dele
    {
 
        // 2.
        delegate void MyDelegate(int val); // delegate type 맴버변수로 선언
        // 3.
        delegate int MyDelegate1(int val);
 
        public void Run()
        {
            int a = 3;
            Console.WriteLine(a);
 
            StudentC st = new StudentC();
            st.Name = "홍길동";
            Console.WriteLine(st);
 
            // 1. 그냥 메소드로 실행
            DelegateTest(3); // 정상적으로 호출됨
 
            // [ C언어에서 함수 포인터와 개념이 유사 ]
 
            // 2. delegate 사용. 
            // 클래스를 선언하듯이, MyDelegate타입을 쓸 수 있게 됨
            MyDelegate d = new MyDelegate(DelegateTest); // d변수는, 함수를 포인팅하는(가리키는) 변수가 됨.
            // 즉 하나의 메소드가, 매개변수로서 들어올 수 있도록 돕는다.
            d(4); // d가 DelegateTest를 가르킴. 즉, 이 변수 이름을 부른다 = 함수 호출
 
            // 3. 
            // MyDelegate d1 = new MyDelegate(DelegateTest1);
            // 위는 불가능. 왜냐하면 MyDelegate라는 타입은, 반환형식은 void, 파라미터는 int 하나를 가르키는 함수에 대해서만 가르킬 수 있다는 것. 이를 해결하기 위해서는 또 다른 delegate를 선언해야 함.
            MyDelegate1 d1 = new MyDelegate1(DelegateTest1);
 
        }
 
        private void DelegateTest(int myVal)
        {
            Console.WriteLine($"DelegateTest() called {myVal}");
        }
 
        private int DelegateTest1(int myVal)
        {
            return myVal + 1;
        }
 
    }
}

[ Windows Forms App 에서 Delegate 예시 ]

[ Form1.cs ]

 using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace WindowsFormsApp2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        // 이 버튼이 눌러지면, 이벤트가 발생하는데, 그 이벤트(delegate)에다가 button1_Click메소드를 만들고 이 메소드 명을 넣어준 것.
        // 컴퓨터 뒤에서는 delegate 행위가 수행되고 있는 것 (개발자 입장에서는 보이지 않음)
        // 즉 button 클래스에는 delegate가 있음. 이것이 button1_Click과 연결되게 된 것
        // 다시말해 button(return type : void, 매개변수 sender, e)의 delegate에 button1_Click메소드를 할당해준 것.
        private void button1_Click(object sender, EventArgs e)
        // [ object sender, EventArgs e를 사용한다는 것 중요 ]
        {
            textBox1.Text = "버튼이 눌러졌어요";
        }
        // delegate로 연결되어 callback이 이루어지도록 만드는 개념 = Event Driven 방식
    }
}

Click Event Handler : 변수명 - button_1_Click

2) Delegate를 이용한 ConsoleMenu 만들기

- CallBack

ex )

[ Program.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Program
    {
        static void Main(string[] args)
        {
            Dele d = new Dele();
            d.Run();
        }
    }
}

[ Dele.cs ]

 using Student;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Dele
    {
        ConsoleMenu Menu;
 
        public Dele()
        {
            Menu = new ConsoleMenu();
        }
 
 
        public void Run()
        {
            // 1. Menu1 : "1" or "Menu1" 입력 -> Delegate 호출
            // cf) menu는 1번을 눌렀을 때 무엇을 해야할지 아무것도 모른다. 그러나 그것에 등록된 Delegate를 호출해준다. 즉 Menu에 보편성이 생김.
            // 2. Menu2
            // ...
            // q : 종료
            // 입력 : n
 
            CreateMenu();
 
            // 무한루프 돌면서 메뉴를 보여주는 프로그램 - q를 누르면 죽어버림.
            for (; ; )
            {
                Menu.Show();
                Menu.Read();
            }
        }
 
        private void CreateMenu()
        {
           /* MenuItem item = new MenuItem("1","Menu_Title1",Menu_1_Callback);
            Menu.MenuList.Add(item);
            item = new MenuItem("2","Menu_Title2",Menu_2_Callback);*/
 
            // 줄여쓰기
            Menu.MenuList.Add(new MenuItem("1", "Menu_Title1", Menu_1_Callback)); 
            // delegate로, Menu_1_Callback이 들어가는 것
            Menu.MenuList.Add(new MenuItem("2", "Menu_Title2", Menu_2_Callback));
            Menu.MenuList.Add(new MenuItem("q", "프로그램 종료", Quit_Callback));
        }
 
 
        // [ 메뉴 1 구현 ]
        // delegate에서 구현한 시그니처를 그대로 받음.
        // = public delegate void MenuKeyPressDelegate(object sender, MenuArgs args);
 
        // ConsoleMenu에서는 MenuArgs가 아닌 MenuKeyPressArgs(retval)로 보냄.
        // MenuArgs는 MenuKeyPressArgs의 조상이기 때문에, 이를 가리킬 수 있다.
        private void Menu_1_Callback(object sender, MenuArgs args)
        {
            Console.WriteLine($"Menu_1_Callback 호출됨. sender={sender.ToString()} args={((MenuKeyPressArgs)args).MenuChar}");
            // MenuKeyPressArgs로 실제로는 보낸것을 MenuArgs로 받았기 때문에, 다시 자식으로 캐스팅해줌으로써 자식까지 보이도록 해줌.
        }
 
 
        // [ 메뉴 2 구현 ]
        private void Menu_2_Callback(object sender, MenuArgs args)
        {
            Console.WriteLine($"Menu_2_Callback 호출됨. sender={sender.ToString()} args={((MenuKeyPressArgs)args).MenuChar}");
        }
 
        // [ 프로그램 종료 구현 ]
        private void Quit_Callback(object sender, MenuArgs args)
        {
            Environment.Exit(0); // 프로그램 빠져나가기
            Console.WriteLine($"Quit_Callback 호출됨. sender={sender.ToString()} args={((MenuKeyPressArgs)args).MenuChar}");
            Console.WriteLine("Bye");
        }
    }
}

[ MenuItem.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class MenuItem
    {
        public delegate void MenuKeyPressDelegate(object sender, MenuArgs args);
        // MenuKeyPressDelegate가 불러지면, callback함수로 날라감. 즉 호출한 클래스에 있는 함수를 부르게 됨. 이 때, 해당 함수에게 seneder(누가 불렀는지)와, MenuArgs 클래스의 args매개변수 전달.
 
        // sender : Windows에서는 이벤트 핸들러가 불러줄 적에 사용하는 파라미터가 정형화되어 있음. 이러한 원리로 날라간다는 것을 설명하기 위해 이렇게 작성한 것.
 
 
        public string MenuChar { get; set; } // 1, 2, 3, ... , q
        public string MenuTitle { get; set; } // Menu1, Menu2, Menu3, ...
 
        public MenuKeyPressDelegate KeyPressDelegate { get; set; } // 특정 메뉴를 눌렀을 때, 불러올 함수 => func(sender, args)
 
 
        // 생성자 단축키 : ctor + tab + tab
        public MenuItem(string menu_char, string menu_title, MenuKeyPressDelegate dele)
        {
            MenuChar = menu_char;
            MenuTitle = menu_title;
            KeyPressDelegate = dele;
        }
 
        public MenuItem():this(null, null, null){ }
    }
}

[ ConsoleMenu.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class ConsoleMenu
    {
        public List<MenuItem> MenuList { get; set; }
        // (List 컬랙션을 활용) MenuItem을 계속 가질 수 있는 Array형태의 컬랙션
        // MenuList각각에는 MenuItem이 들어감
 
        public ConsoleMenu()
        {
            MenuList = new List<MenuItem>(); // 컬랙션 생성
        }
 
        // 호출한 부분의, MenuItem의 menu들을 보여줌
        public void Show()
        {
            foreach(MenuItem item in MenuList)
            {
                Console.WriteLine($"{item.MenuChar}.{item.MenuTitle}");
            }
            Console.WriteLine();
        }
 
        // menu 선택
        public void Read()
        {
            Console.Write("메뉴 선택 : ");
            string retVal = Console.ReadLine(); // 1, 2, ... ,q
            // 이 값들이 MenuList중 하나에 속해있을 것. 
 
            foreach (MenuItem item in MenuList)
            {
                // 1. MenuItem에서 MenuChar의 값 == 입력한 값
                // 2. MenuItem에서 KeyPressDelegate값이 null이 아닐 때 (Delegate 값을 가지고 있는가)
                if (item.MenuChar == retVal && item.KeyPressDelegate != null)
                {
                    item.KeyPressDelegate(this, new MenuKeyPressArgs(retVal)); 
                    // delegate 호출
                }
            }
        }
 
    }
}

[ MenuArgs.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class MenuArgs
    {
    }
 
    // Menu를 선택할 적에, 파리미터로 전달될 형식을 모델링하는 것.
    class MenuKeyPressArgs : MenuArgs
    {
        public string MenuChar { get; set; } // string으로 입력한 값을 돌려주겠다.
 
        public MenuKeyPressArgs(string menu_char)
        {
            MenuChar = menu_char;
        }
    }
}

3) EventHandler를 사용한 ConsoleMenu 프로그램 만들기

- Windows Forms 프로그램에서는 전부 다 EventHandler를 쓰게 됨.

- delegate(low level)보다 EventHandler(high level)를 사용하는 것이 더 효율적임.

[ Program.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Program
    {
        static void Main(string[] args)
        {
            Dele d = new Dele();
            d.Run();
        }
    }
}

[ Dele.cs ]

 using Student;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class Dele
    {
        ConsoleMenu Menu;
 
        public Dele()
        {
            Menu = new ConsoleMenu();
        }
 
 
        public void Run()
        {
            CreateMenu();
 
            for (; ; )
            {
                Menu.Show();
                Menu.Read();
            }
        }
 
        private void CreateMenu()
        {
            MenuItem item = new MenuItem("1", "Menu_Title1");
            item.MenuKeyPressEventHandler += Menu_1_Callback;
            Menu.MenuList.Add(item);
 
            item = new MenuItem("2", "Menu_Title2");
            item.MenuKeyPressEventHandler += Menu_2_Callback;
            Menu.MenuList.Add(item);
 
            item = new MenuItem("q", "프로그램 종료");
            item.MenuKeyPressEventHandler += Quit_Callback;
            Menu.MenuList.Add(item);
        }
 
 
        private void Menu_1_Callback(object sender, EventArgs args)
        {
            Console.WriteLine($"Menu_1_Callback 호출됨. sender={sender.ToString()} args={((MenuKeyPressArgs)args).MenuChar}");
        }
 
 
        private void Menu_2_Callback(object sender, EventArgs args)
        {
            Console.WriteLine($"Menu_2_Callback 호출됨. sender={sender.ToString()} args={((MenuKeyPressArgs)args).MenuChar}");
        }
 
        private void Quit_Callback(object sender, EventArgs args)
        {
            Environment.Exit(0); // 프로그램 빠져나가기
            Console.WriteLine($"Quit_Callback 호출됨. sender={sender.ToString()} args={((MenuKeyPressArgs)args).MenuChar}");
            Console.WriteLine("Bye");
        }
    }
}

[ MenuItem.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class MenuItem
    {
        // [ Delegate 사용 X ]
        // public delegate void MenuKeyPressDelegate(object sender, EventArgs args);
 
        // [ EventHandler 등록 ]
        public event EventHandler MenuKeyPressEventHandler; 
        // EventHandler 변수인, MenuKeyPressEventHandler
        // EventHandler는 이미 delegate를 모두 가지고 있음.
 
        public string MenuChar { get; set; } // 1, 2, 3, ... , q
        public string MenuTitle { get; set; } // Menu1, Menu2, Menu3, ...
 
        // [ Delegate 사용 X ]
        //public MenuKeyPressDelegate KeyPressDelegate { get; set; } 
 
        public MenuItem(string menu_char, string menu_title)
        {
            MenuChar = menu_char;
            MenuTitle = menu_title;
        }
 
        public MenuItem():this(null, null){ }
 
        public void CallEvent(object sender, string args)
        {
            // EventHandler는 자신이 선언된 쪽에서 처리가 되어야 함. 다른 클래스에서 처리하는 것은 허락하지 않음.
            // 따라서, ConsoleMenu.cs에서 사용할 수 없고, 여기서 사용해야 함.
 
            if (MenuKeyPressEventHandler != null)
            {
                MenuKeyPressEventHandler(sender, new MenuKeyPressArgs(args));
            }
        }
    }
}

[ ConsoleMenu.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
    class ConsoleMenu
    {
        public List<MenuItem> MenuList { get; set; }
 
        public ConsoleMenu()
        {
            MenuList = new List<MenuItem>();
        }
 
        // 호출한 부분의, MenuItem의 menu들을 보여줌
        public void Show()
        {
            foreach(MenuItem item in MenuList)
            {
                Console.WriteLine($"{item.MenuChar}.{item.MenuTitle}");
            }
            Console.WriteLine();
        }
 
        // menu 선택
        public void Read()
        {
            Console.Write("메뉴 선택 : ");
            string retVal = Console.ReadLine(); // 1, 2, ... ,q
 
            foreach (MenuItem item in MenuList)
            {
                if (item.MenuChar == retVal)
                {
                    item.CallEvent(this, retVal);
                }
            }
        }
 
    }
}

[ MenuArgs.cs ]

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace class_0804
{
/*    class MenuArgs
    {
    }*/
 
    class MenuKeyPressArgs : EventArgs 
     //.Net Framework에서는 EventArgs라는 것을 지원해줌. MenuArgs를 따로 지정할 필요 X
     // EventArgs를 상속하여, 여러 다양한 종류의 파라미터를 받을 수 있음.
    {
        public string MenuChar { get; set; } // string으로 입력한 값을 돌려주겠다.
 
        public MenuKeyPressArgs(string menu_char)
        {
            MenuChar = menu_char;
        }
    }
}

* 유의사항
- 아직 공부하고 있는 문과생 코린이가, 정리해서 남겨놓은 정리 및 필기노트입니다.
- 정확하지 않거나, 틀린 점이 있을 수 있으니, 유의해서 봐주시면 감사하겠습니다.
- 혹시 잘못된 점을 발견하셨다면, 댓글로 친절하게 남겨주시면 감사하겠습니다 :)

'문과 코린이의, [C#] 기록 > C# 이론' 카테고리의 다른 글

[문과 코린이의 IT 기록장] C# - BCL(Base Class Library) (System.String, System.IO Directory, File, System.Collections ArrayList, System.Collections.Generics.List<T>) (0)	2022.08.11
[문과 코린이의 IT 기록장] C# 네트워크 프로그래밍 (C# Network Programming Intro, 네트워크 기본 구조와 원리) (0)	2022.08.11
[문과 코린이의 IT 기록장] C# - 클래스 (클래스 상속, 모든 클래스의 조상 Object 클래스, 메서드 Overridding, 추상 클래스 (Abstract 클래스), 인터페이스 (Interface)) (0)	2022.08.05
[문과 코린이의 IT 기록장] C# - 배열 및 제어문(배열, 조건문 (IF / SWITCH), 반복문 (For / While / Do While)) (0)	2022.08.02
[문과 코린이의 IT 기록장] C# - C# 프로그램 구조(Visual Studio C# 구성, C# 프로젝트, 클래스와 인스턴스, 메서드(함수) 선언, 클래스 생성자, 클래스 프로퍼티(속성)) (0)	2022.07.28

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

벼리네 it 기록장

[문과 코린이의 IT 기록장] C# - 클래스 2 (구조체 , 제네릭 (Generic), Delegate / Event)

1. 구조체 (Struct)

1) 참조 형식(클래스)과 값 형식(구조체)에 대한 이해

2) 구조체 정의

3) 구조체가 클래스와 다른점

2. 제네릭 (Generic)

1) Generic 탄생 동기

2) Generic 사용법 : ArrayList -> List<T>

3) Generic class & Generic method

3. Delegate / Event

1) Delegate

2) Delegate를 이용한 ConsoleMenu 만들기

3) EventHandler를 사용한 ConsoleMenu 프로그램 만들기

'문과 코린이의, [C#] 기록 > C# 이론' 카테고리의 다른 글

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;

	namespace class_0804
	{
	class Program
	{
	static void Main(string[] args)
	{
	// Value Type의 특성
	// - 동작방법
	/*int a = 1;
	int b = 2;

	Console.WriteLine($"1. a = {a} b = {b}");
	int c = ValueTypeTest(a, b);
	Console.WriteLine($"2. a = {a} b = {b}");*/


	Console.WriteLine("클래스 : 참조 형식");
	Student1 st1 = new Student1();
	st1.Name = "Lee";
	Console.WriteLine(st1.Name);
	ReferenceTypeTest(st1);
	Console.WriteLine(st1.Name);

	Console.WriteLine("-----------------------------------");

	Console.WriteLine("구조체 : 값 형식");
	Student2 st2 = new Student2();
	st2.Name = "Lee";
	Console.WriteLine(st2.Name);
	ReferenceTypeTest(st2);
	Console.WriteLine(st2.Name);
	}



	static int ValueTypeTest(int a, int b) // 호출할 때 값을, copy해 준 것. (참조가 X)
	{
	Console.WriteLine($"3. a = {a} b = {b}");
	a++;
	b++;
	Console.WriteLine($"4. a = {a} b = {b}");
	return a + b;
	}

	static void ReferenceTypeTest(Student1 a)
	{
	a.Name = "Kim";
	}

	static void ReferenceTypeTest(Student2 a)
	{
	a.Name = "Kim";
	}

	}

	/// <summary>
	/// 참조 형식으로 학생 클래스입니다.
	/// </summary>
	class Student1
	{
	public string Name { get; set; }
	public int Age { get; set; }
	}

	struct Student2
	{
	public string Name { get; set; }
	public int Age { get; set; }
	}

	}

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;
	using Student;

	namespace class_0804
	{
	class generic
	{

	public void Run()
	{
	ArrayList list = new ArrayList();
	list.Add(4); // boxing 발생
	int a = (int)list[0]; // unboxing 발생

	PrintMe(3);
	PrintMe("String");
	}

	// [문제] 여러 종류의 Type이 존재할 때, 이렇게 함수를 다 나눠서 코드를 작성해야 할 것인가?
	// - 코드 중복이 굉장히 많이 발생
	private void PrintMe(int val)
	{
	Console.WriteLine($"val = {val}");
	}
	private void PrintMe(string val)
	{
	Console.WriteLine($"val = {val}");
	}


	}
	}

	int a = 3; // 3이라는 value를 가지는 타입 - value 타입
	Student st = new Student(); // Student 객체를 갖는 타입 - reference 타입
	delegate void MyDelegate(int a); // 함수를 값으로 갖는 타입 - delegate 타입

	using System;
	using System.Collections.Generic;
	using System.ComponentModel;
	using System.Data;
	using System.Drawing;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;
	using System.Windows.Forms;

	namespace WindowsFormsApp2
	{
	public partial class Form1 : Form
	{
	public Form1()
	{
	InitializeComponent();
	}

	// 이 버튼이 눌러지면, 이벤트가 발생하는데, 그 이벤트(delegate)에다가 button1_Click메소드를 만들고 이 메소드 명을 넣어준 것.
	// 컴퓨터 뒤에서는 delegate 행위가 수행되고 있는 것 (개발자 입장에서는 보이지 않음)
	// 즉 button 클래스에는 delegate가 있음. 이것이 button1_Click과 연결되게 된 것
	// 다시말해 button(return type : void, 매개변수 sender, e)의 delegate에 button1_Click메소드를 할당해준 것.
	private void button1_Click(object sender, EventArgs e)
	// [ object sender, EventArgs e를 사용한다는 것 중요 ]
	{
	textBox1.Text = "버튼이 눌러졌어요";
	}
	// delegate로 연결되어 callback이 이루어지도록 만드는 개념 = Event Driven 방식
	}
	}

[문과 코린이의 IT 기록장] C# - 클래스 2 (구조체 , 제네릭 (Generic), Delegate / Event)

1. 구조체 (Struct)

1) 참조 형식(클래스)과 값 형식(구조체)에 대한 이해

2) 구조체 정의

3) 구조체가 클래스와 다른점

2. 제네릭 (Generic)

1) Generic 탄생 동기

2) Generic 사용법 : ArrayList -> List<T>

3) Generic class & Generic method

3. Delegate / Event

1) Delegate

2) Delegate를 이용한 ConsoleMenu 만들기

3) EventHandler를 사용한 ConsoleMenu 프로그램 만들기

'문과 코린이의, [C#] 기록 > C# 이론' 카테고리의 다른 글

'문과 코린이의, [C#] 기록/C# 이론' Related Articles

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역