04.델리게이트(delegate)

프랑스어 버전

using System;
using System.Collections.Generic;

namespace Csharp
{
    // delegate(델리게이트) : 함수 자체를 넘겨주는 방식. 형식의 이름을 내 맘대로..! (int float이 아니라 france)
    
    class Program
    {
        //int France()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int France();

        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 이름 : France가 delegate 형식의 이름이다!
        // 4. 입력 : void (왜냐하면 France()의 괄호속에 아무것도 없기 때문에)


        //콜백 방식(= 델리게이트)
        static void AppuyerSurleBouton(France france)
        {
            france();
        }

        //어떤 함수
        static int QuelqueFonction()
        {
            Console.WriteLine("putant");

            return 0;
        }

        static void Main(string[] args)
        {
            //델리게이트(어떤 함수)
            AppuyerSurleBouton(QuelqueFonction);
        }
    }
}

using System;
using System.Collections.Generic;

namespace Csharp
{
    // delegate(델리게이트) : 함수 자체를 넘겨주는 방식. 형식의 이름을 내 맘대로..! (int float이 아니라 france)

    class Program
    {
        //int France()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int France();

        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 이름 : France가 delegate 형식의 이름이다!
        // 4. 입력 : void (왜냐하면 France()의 괄호속에 아무것도 없기 때문에)


        //콜백 방식
        // 2. 어떤함수1(1.델리게이트)
        static void AppuyerSurleBouton(France france)
        {
            france();
        }

        // 3. 어떤 함수2
        static int QuelqueFonction()
        {
            Console.WriteLine("putant");

            return 0;
        }

        static void Main(string[] args)
        {
            // 4. 어떤 함수1(어떤 함수2)
            //방식1
            AppuyerSurleBouton(QuelqueFonction);

            //방식2
            France fr = new France(QuelqueFonction);

            fr();
        }
    }
}

 

방식1의 장점은 직관적이다.

 

그렇다면 방식2의 장점은 무엇일까?

 

바로 체인형식이다.

 

using System;
using System.Collections.Generic;

namespace Csharp
{
    // delegate(델리게이트) : 함수 자체를 넘겨주는 방식. 형식의 이름을 내 맘대로..! (int float이 아니라 france)

    class Program
    {
        //int France()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int France();

        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 이름 : France가 delegate 형식의 이름이다!
        // 4. 입력 : void (왜냐하면 France()의 괄호속에 아무것도 없기 때문에)


        //콜백 방식
        // 2. 어떤함수1(1.델리게이트)
        static void AppuyerSurleBouton(France france)
        {
            france();
        }

        // 3. 어떤 함수2
        static int QuelqueFonction()
        {
            Console.WriteLine("putant");

            return 0;
        }

        static int QuelqueFonction2()
        {
            Console.WriteLine("putant2");

            return 0;
        }

        static void Main(string[] args)
        {
            // 4. 어떤 함수1(어떤 함수2)
            //방식1
            AppuyerSurleBouton(QuelqueFonction);

            //방식2 (= 체인 형식)
            France fr = new France(QuelqueFonction);

            fr += QuelqueFonction2;

            fr();
        }
    }
}

함수를 계속 추가할 수 있다.

 

using System;
using System.Collections.Generic;

namespace Csharp
{
    // delegate(델리게이트) : 함수 자체를 넘겨주는 방식. 형식의 이름을 내 맘대로..! (int float이 아니라 france)

    class Program
    {
        //int France()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int France();

        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 이름 : France가 delegate 형식의 이름이다!
        // 4. 입력 : void (왜냐하면 France()의 괄호속에 아무것도 없기 때문에)


        //콜백 방식
        // 2. 어떤함수1(1.델리게이트)
        static void AppuyerSurleBouton(France france)
        {
            france();
        }

        // 3. 어떤 함수2
        static int QuelqueFonction()
        {
            Console.WriteLine("putant");

            return 0;
        }

        static int QuelqueFonction2()
        {
            Console.WriteLine("putant2");

            return 0;
        }

        static void Main(string[] args)
        {
            // 4. 어떤 함수1(어떤 함수2)
            //방식1
            AppuyerSurleBouton(QuelqueFonction);

            AppuyerSurleBouton(QuelqueFonction2);


            //방식2 (= 체인 형식)
            France fr = new France(QuelqueFonction);

            fr += QuelqueFonction2;

            fr();

            //방식3
            AppuyerSurleBouton(fr);
        }
    }
}

 

 

원본 버전

using System;
using System.Collections.Generic;

namespace Csharp
{
    // delegate(델리게이트) : 함수 자체를 넘겨주는 방식. 형식의 이름을 내 맘대로..! (int float이 아니라 france)

    class Program
    {
        //int OnClicked()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int France();
        
        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 이름 : France가 delegate 형식의 이름이다!
        // 4. 입력 : void (왜냐하면 France()의 괄호속에 아무것도 없기 때문에)


        //콜백 방식
        static void ButtonPressed(France france)
        {
            france();
        }


        static void Main(string[] args)
        {           

        }
    }
}

 

using System;
using System.Collections.Generic;

namespace Csharp
{
    // delegate(델리게이트) : 함수 자체를 넘겨주는 방식. 형식의 이름을 내 맘대로..! (int float이 아니라 france)
    
    class Program
    {
        //지금까지는 코드를 짤 때, 순차적으로, 직관적으로 코드를 만들었다.
        //그런데 상황에 따라, 순차적인게 아니라, 상대방에게 거꾸로 무언가를 해달라고 하는 상황이 빈번히 일어난다.

        //업체 사장 - 사장님의 비서
        //             우리의 연락처 / 용건 - 연락 달라고(= 콜백을 달라고)

        //ex : UI

        static void ButtonPressed()
        {
            //PlayerAttack();
        }

        //이렇게 함수를 바로 구현하면 되는데, 구현하기 힘든 경우가 더 많다.        

        //이유 1 : UI로직과, 게임로직이 얽히고 섥히게 된다.
        //         그래서 게임로직과 Ui로직은 서로 분리 시켜야 하는게 장기적인 관점에서 좋다.
        //이유 2 : 안의 코드를 수정할 수 없는 경우가 빈번하게 발생한다.

        static void Main(string[] args)
        {

        }
    }
}

 

 

콜백 방식

using System;
using System.Collections.Generic;

namespace Csharp
{
    class Program
    {
        //지금까지는 코드를 짤 때, 순차적으로, 직관적으로 코드를 만들었다.
        //그런데 상황에 따라, 순차적인게 아니라, 상대방에게 거꾸로 무언가를 해달라고 하는 상황이 빈번히 일어난다.

        //업체 사장 - 사장님의 비서
        //             우리의 연락처 / 용건 - 연락 달라고(= 콜백을 달라고)

        //ex : UI


        //콜백 방식
        static void ButtonPressed(/* 1. 함수 자체를 인자로 넘겨주고*/)
        {
            //2. 함수를 호출();
        }


        static void Main(string[] args)
        {
            ButtonPressed(/**/);
        }
    }
}

 

using System;
using System.Collections.Generic;

namespace Csharp
{
    class Program
    {
        //지금까지는 코드를 짤 때, 순차적으로, 직관적으로 코드를 만들었다.
        //그런데 상황에 따라, 순차적인게 아니라, 상대방에게 거꾸로 무언가를 해달라고 하는 상황이 빈번히 일어난다.

        //업체 사장 - 사장님의 비서
        //             우리의 연락처 / 용건 - 연락 달라고(= 콜백을 달라고)

        //ex : UI

        //int OnClicked()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int OnClicked();

        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 입력 : void (왜냐하면 OnClicked()의 괄호속에 아무것도 없기 때문에)
        // 4. 이름 : OnClicked이 delegate 형식의 이름이다!


        //콜백 방식(= 델리게이트)
        static void ButtonPressed(OnClicked clickedFunction)
        {
            clickedFunction();
        }

        //어떤 함수
        static int TestDelegate()
        {
            Console.WriteLine("Hello Delegate");

            return 0;
        }

        static void Main(string[] args)
        {
            //델리게이트(어떤 함수)
            ButtonPressed(TestDelegate);
        }
    }
}

 

using System;
using System.Collections.Generic;

namespace Csharp
{
    class Program
    {
        //지금까지는 코드를 짤 때, 순차적으로, 직관적으로 코드를 만들었다.
        //그런데 상황에 따라, 순차적인게 아니라, 상대방에게 거꾸로 무언가를 해달라고 하는 상황이 빈번히 일어난다.

        //업체 사장 - 사장님의 비서
        //             우리의 연락처 / 용건 - 연락 달라고(= 콜백을 달라고)

        //ex : UI
        
        //int OnClicked()는 함수가 아니라 형식이다(ex : void나 int처럼)
        delegate int OnClicked();
        //이 코드를 4개의 부분으로 자르면,
        // 1. delegate : 형식은 형식인데, 함수 자체를 인자로 넘겨주는 그런 형식
        // 2. 반환 : int
        // 3. 입력 : void (왜냐하면 OnClicked()의 괄호속에 아무것도 없기 때문에)
        // 4. 이름 : OnClicked이 delegate 형식의 이름이다!

        //콜백 방식
        static void ButtonPressed(OnClicked clickedFunction)
        {
            clickedFunction();
        }

        static int TestDelegate()
        {
            Console.WriteLine("Hello Delegate");
            
            return 0;
        }

        static int TestDelegate2()
        {
            Console.WriteLine("Hello Delegate2");

            return 0;
        }


        static void Main(string[] args)
        {
            OnClicked clicked = new OnClicked(TestDelegate);

            clicked += TestDelegate2;


            //TestDelegate()실행 + TestDelegate2()실행
            clicked();

            //TestDelegate()실행 + TestDelegate2()실행
            ButtonPressed(clicked);

            //TestDelegate()실행
            ButtonPressed(TestDelegate);

            //TestDelegate2()실행
            ButtonPressed(TestDelegate2);

        }
    }
}