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();
        }
    }