C# 泛型 值类型和引用类型 堆和栈 装箱和拆箱 委托和事件 Equals 与== Attribute特性

 static void Main(string[] args)
        { 
            Action<int, int> action = new Action<int, int>(addVoid);    // Action<int, int> 这就是方法的原型

            action(1, 2);
            action.Invoke(2, 3);  //基本的使用方法和delege都是差不多的，包括异步的写法也是相同的，


            //但是他升级了，厉害之处是加入了lamda，   Action<int, int>就是声明委托原型  简化了写法,通过lamda  (n,m)=>{} 匿名函数的写法  
            Action<int, int> actionOne = new Action<int, int>((n, m) =>
            {
                Console.WriteLine("lamda方式1 计算结果{0}", (n + m));
            });

            actionOne.Invoke(4, 5);

            //lamda 搞法很优雅
            Action<int, int> actionTwo = (n, m) =>
            {
                Console.WriteLine("lamda方式2 计算结果{0}", (n + m));
            };
            actionTwo.Invoke(3, 4);

            Console.ReadKey();
        }


        static void addVoid(int a, int b)
        { 
            Console.WriteLine("计算结果{0}", (a + b));
        }

static void Main(string[] args)
        {
            Func<int> func = new Func<int>(ReturnOne);  //一个参数时候，就是返回值（无参数，有返回值），Func<int>这就是方法的原型了
            int res = func.Invoke();
            Console.WriteLine(" 计算结果{0}", res);

            Func<int> funcOne = () =>
            {
                return 1;
            };
            int resOne = funcOne.Invoke();
            Console.WriteLine("lamda方式1 计算结果{0}", res);
            
            Func<int> funcTwo = new Func<int>(() =>
            {
                return 2;
            });
            int resTwo = funcTwo.Invoke();
            Console.WriteLine("lamda方式2 计算结果{0}", resTwo);

            Func<int, int, int> funcThree = (n, m) =>
            {
                return n + m;
            };
            int resThree = funcThree.Invoke(1, 2); //参数只两个，最后的一个参数也是int，不过是输出参数，也就是返回值
            Console.WriteLine("lamda方式3 计算结果{0}", resThree);

            Func<int, int, int> funcFour = new Func<int, int, int>(add);

            int resFour = funcThree.Invoke(1, 3);  //调用封装好的方法
            Console.WriteLine("lamda方式4 计算结果{0}", resFour);

            Console.ReadKey();
        }

        static int add(int a, int b)
        {
            return a + b;
        }

        static int ReturnOne()
        {
            return 1;
        }
   }

//无返回值，无参数委托，不需要单独声明
Action act = this.DoNothing;

//无返回值，有参数委托，参数类型为泛型
Action<string> act = p => { };

//返回类型为string，参数类型为string的委托
Func<string,string> func = p => p;

//返回类型为bool，参数类型为string的委托
Func<string,bool> func = p => p.Equals('');

/// <summary>
    /// 扩展方法
    /// </summary>
    public static class DelegateExtend
    {
        /// <summary>
        /// 模仿Linq的Where操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="scoure">数据源</param>
        /// <param name="func">委托（自定义bool条件）</param>
        /// <returns></returns>
        public static IEnumerable<T> ExtWhere<T>(this IEnumerable<T> scoure, Func<T, bool> func)
        {
            //遍历数据源的数据
            foreach (var item in scoure)
            {
                //请求委托完成条件的筛选返回bool
                bool bResult = func(item);
                //把通过筛选提交的数据源，返回出去
                if (bResult)
                {
                    yield return item;
                }
            }
        }
    }

/// <summary>
    /// 实体模型
    /// </summary>
    public class Student
    {
        /// <summary>
        /// ID
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// 名称
        /// </summary>
        public string Name { get; set; }
    }

//查询出所有数据
            IEnumerable<Student> student = sql.QueryList<Student>();
            //定义一个匿名方法，并赋值给委托
            Func<Student, bool> func = delegate(Student s)
            {
                //自定义代码逻辑，返回bool类型
                return s.Id.Equals("1");
            };
            //传入委托
            IEnumerable<Student> list = student.ExtWhere(func);

　　　　　　  //第二种方法，使用linq语法（自定义逻辑）
            IEnumerable<Student> list1 = student.ExtWhere(p => p.Id.Equals("1"));

public class student
        {
            [ColumnAttribute("Uname")]  //这里就是调用了，去掉中括号，实际就是构造函数调用
            public string Name { get; set; }
        }
 
        public class ColumnAttribute : Attribute  
        {
            public string Name { get; private set; }
            
            public ColumnAttribute(string name)
            {
                this.Name = name;
            }
        }