C# 委托原理刨析、事件原理刨析，外加兩者對比

namespace ConsoleApp.DelegateTest
{
    //例：表示無參數，無返回。
    public delegate void MethodtDelegate();
    //例：表示有兩個參數，並返回int型。
    public delegate int MethodtDelegate(int x, int y);
}

static void Main(string[] args)
        {
            MethodtDelegate methodt = Test;
            //例1：直接調用
            methodt(1,2);
            //例2：假設作為參數傳遞，進行調用。比如回調函數場景
            InvokeTest(methodt);
        }
        public static int Test(int a, int b)
        {
            return a + b;
        }
        public static void InvokeTest(MethodtDelegate methodt)
        {
            //以下兩種方式都可以調用
            var sum = methodt(1, 2);
            var sum = methodt.Invoke(1, 2);
        }

//例：表示有傳入參數int,string,bool無返回值的委托
Action<int,string,bool> 

//表示無參，返回值為int的委托，
Func<int> 
//表示傳入參數為object, string 返回值為int的委托
Func<object,string,int> 

    public static class Logger
    {
        public static Action<string> WriteMessage;

        public static void LogMessage(string msg)
        {
            WriteMessage(msg);
        }
    }

    public class FileLogger
    {
        public FileLogger()
        {
            Logger.WriteMessage += LogMessage;
        }

        public void DetachLog() => Logger.WriteMessage -= LogMessage;
        // make sure this can't throw.
        private void LogMessage(string msg)
        {
            try
            {
                Console.WriteLine($"FileLogger\t{msg}");
            }
            catch (Exception)
            {
                // Hmm. We caught an exception while
                // logging. We can't really log the
                // problem (since it's the log that's failing).
                // So, while normally, catching an exception
                // and doing nothing isn't wise, it's really the
                // only reasonable option here.
            }
        }
    }

   public class DBLogger
    {
        private readonly string name;
        public DBLogger(string name)
        {
            this.name = name;
            Logger.WriteMessage += LogMessage;
        }

        public void DetachLog() => Logger.WriteMessage -= LogMessage;
        // make sure this can't throw.
        private void LogMessage(string msg)
        {
            try
            {
                Console.WriteLine($"DBLogger{name}\t{msg}");
            }
            catch (Exception)
            {
                // Hmm. We caught an exception while
                // logging. We can't really log the
                // problem (since it's the log that's failing).
                // So, while normally, catching an exception
                // and doing nothing isn't wise, it's really the
                // only reasonable option here.
            }
        }
    }

static void Main(string[] args)
        {
            //添加一個文件記錄器和兩個資料庫記錄器
            new FileLogger();
            new DBLogger("DB1");
            var a = new DBLogger("DB2");
            //調用委托
            Logger.LogMessage("add失敗");
    
            //刪除此資料庫記錄器
            a.DetachLog();
            Console.WriteLine("======DetachLogDB2========");
            //調用委托
            Logger.LogMessage("add失敗");
        }

        static void Main(string[] args)
        {
            int count1 = 0;//委托1的參數
            int count2 = 0;//委托2的參數
            //實例化委托1
            Action<int> action1 = (p) =>
            {
                p++;
                Console.WriteLine("action1：" + p);
            };
            //實例化委托2
            Action action2 = () =>
            {
                count2++;
                Console.WriteLine("action2：" + count2);
            };
            //迴圈5此
            for (int i = 0; i < 5; i++)
            {
                action1(count1);//調用委托1
                action2();//調用委托2
                Console.WriteLine("---------------------------分割線");
            }
            Console.WriteLine("count1 最終值：" + count1);
            Console.WriteLine("count2 最終值：" + count2);
        }

    internal class Program
    {
        static void Main(string[] args)
        {
            int b = 888888888;
            Func<int> action = () =>
            {
                return b++;
            };
            var a = action.Invoke();
        }
    }

    internal class Program
    {
        public class DisplayClass
        {
            public int b;
            public int Invoke()
            {
                return b++;
            }
        }
        public class _Func<T>
        {
            private readonly DisplayClass displayClass;
            public _Func(DisplayClass display)
            {
                displayClass = display;
            }
            public T Invoke()
            {
                object b = displayClass.Invoke();
                return (T)b;
            }
        }
        static void Main(string[] args)
        {
            var display = new DisplayClass();
            display.b = 888888888;
            var actionTest = new _Func<int>(display);
            var a = actionTest.Invoke();
        }
    }