C# delegate

C++의 함수 포인터 같은 기능이 없나 찾아보다 delegate를 발견

형식 :

한정자 delegate 반환식 함수명( 매개변수 );

이해 :

객체 처럼 변수를 선언한 후 메모리에 올라가 있는 함수를 대입시켜 주면 된다.

namespace Csharp_Study
{
    public delegate int delCalculator(int a, int b);

    class Calculator
    {
        public int Plus(int a, int b)
        {
            return a + b;
        }

        public int Minus(int a, int b)
        {
            return a - b;
        }
    }

    class main
    {
        static int Mul(int a, int b)
        {
            return a * b;
        }

        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            delCalculator pFunc;
            pFunc = Mul;
            
            Console.WriteLine(pFunc(4, 5));
        }
    }
}

일반화 DELEGATE

템플릿으로 사용가능하다

namespace GenericDelegate
{
    delegate int Compare(T a, T b);

    class MainApp
    {
        static int AscendCompare(T a, T b) where T : IComparable
        {
            return a.CompareTo(b);
        }

        static int DescendCompare(T a, T b) where T : IComparable
        {
            return a.CompareTo(b) * -1;
        }

        static void BubbleSort(T[] DataSet, Compare Comparer)
        {
            int i = 0;
            int j = 0;
            T temp;

            for (i = 0; i < DataSet.Length - 1; i++)
            {
                for (j = 0; j < DataSet.Length - (i + 1); j++)
                {
                    if (Comparer(DataSet[j], DataSet[j + 1]) > 0)
                    {
                        temp = DataSet[j + 1];
                        DataSet[j + 1] = DataSet[j];
                        DataSet[j] = temp;
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            int[] array = { 3, 7, 4, 2, 10 };

            Console.WriteLine("Sorting ascending...");
            BubbleSort(array, new Compare(AscendCompare));

            for (int i = 0; i < array.Length; i++)
                Console.Write("{0} ", array[i]);

            string[] array2 = { "abc", "def", "ghi", "jkl", "mno" };

            Console.WriteLine("\nSorting descending...");
            Compare fCompare = DescendCompare;
            BubbleSort(array2, fCompare);

            for (int i = 0; i < array2.Length; i++)
                Console.Write("{0} ", array2[i]);

            Console.WriteLine();
        }
    }
}

delegate 체인

delegate를 +=, -= 연산자로 연결해서 쓸 수있다.

namespace DelegateChains
{
    delegate void Notify(string message);

    class Notifier
    {
        public Notify EventOccured;
    }

    class EventListener
    {
        private string name;
        public EventListener(string name)
        {
            this.name = name;
        }

        public void SomethingHappend(string message)
        {
            Console.WriteLine("{0}.SomethingHappened : {1}", name, message);
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Notifier notifier = new Notifier();
            EventListener listener1 = new EventListener("Listener1");
            EventListener listener2 = new EventListener("Listener2");
            EventListener listener3 = new EventListener("Listener3");

            notifier.EventOccured += listener1.SomethingHappend;
            notifier.EventOccured += listener2.SomethingHappend;
            notifier.EventOccured += listener3.SomethingHappend;
            notifier.EventOccured("You've got mail.");

            Console.WriteLine();

            notifier.EventOccured -= listener2.SomethingHappend;
            notifier.EventOccured("Download complete.");

            Console.WriteLine();

            notifier.EventOccured = new Notify(listener2.SomethingHappend) 
                                  + new Notify(listener3.SomethingHappend);
            notifier.EventOccured("Nuclear launch detected.");

            Console.WriteLine();

            Notify notify1 = new Notify(listener1.SomethingHappend);
            Notify notify2 = new Notify(listener2.SomethingHappend);

            notifier.EventOccured =
                (Notify)Delegate.Combine( notify1, notify2);
            notifier.EventOccured("Fire!!");

            Console.WriteLine();

            notifier.EventOccured = 
                (Notify)Delegate.Remove( notifier.EventOccured, notify2);                
            notifier.EventOccured("RPG!");
        }
    }
}

익명 delegate

함수명이 없이 일회용으로 함수를 만들어 사용한다.

namespace AnonymouseMethod
{
    delegate int Compare(int a, int b);

    class MainApp
    {
        static void BubbleSort(int[] DataSet, Compare Comparer)
        {
            int i = 0;
            int j = 0;
            int temp = 0;

            for (i = 0; i < DataSet.Length - 1; i++)
            {
                for (j = 0; j < DataSet.Length - (i + 1); j++)
                {
                    if (Comparer(DataSet[j], DataSet[j + 1]) > 0)
                    {
                        temp = DataSet[j + 1];
                        DataSet[j + 1] = DataSet[j];
                        DataSet[j] = temp;
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            int[] array = { 3, 7, 4, 2, 10 };

            Console.WriteLine("Sorting ascending...");
            BubbleSort(array, delegate(int a, int b)
                              {
                                if (a > b)
                                    return 1;
                                else if (a == b)
                                    return 0;
                                else
                                    return -1;
                              });

            for (int i = 0; i < array.Length; i++)
                Console.Write("{0} ", array[i]);

            int[] array2 = { 7, 2, 8, 10, 11 };
            Console.WriteLine("\nSorting descending...");
            BubbleSort(array2, delegate(int a, int b)
                               {
                                 if (a < b)
                                     return 1;
                                 else if (a == b)
                                     return 0;
                                 else
                                     return -1;
                               });

            for (int i = 0; i < array2.Length; i++)
                Console.Write("{0} ", array2[i]);

            Console.WriteLine();
        }
    }
}