知识点锦集

一. 多项目开发：

1. 建立项目：

两种方式：

（1）项目和解决方案一起建立

（2）先建立解决方案，然后添加项目

2. 有需要用到的公用类，建立类库，其他项目引用时，先添加引用，在命名控件引用：

（1）添加类库

（2）添加引用：

（3）引用类方法：

3. 配置文件读取：

只有读取主项目（当前运行项目）的config才起作用

4. 调用第三方类，直接添加引用即可，如需查询具体的代码，可反编译；

二、索引器：

索引器没有名字，索引器的内部本质 this[参数] {get; set;}

索引器不仅能根据数字索引还能根据字符串索引；

允许多个索引器参数；

三、密封类和静态类：

1、密封类无法创建子类：sealed

2、静态类： static 无法创建子类，只能声明static成员；

3. static 成员：可以在静态类中，也可以被非静态类创建，使用时：类名.方法()

4. string 类扩展方法：

四、委托：

1、 delegate 类型名称() 使用时先实例化，然后传入参数；

namespace ConsoleApp12
{
    class Program
    {
        static void Main(string[] args)
        {
            MyDel myDel = new MyDel(GetName);
          // 或者  MyDel myDel =GetName;
            myDel("chen", 1);   
        }

        static string GetName(string name,int num)
        {
            return name + num;
        }
    }
    delegate string MyDel(string name, int num);
}

　　2、一般平时开发时，不需要自定义委托；

.NET内置泛型委托： func 和action ：对于没有返回值的委托用Action ，所有有返回值的委托用Func ，返回值在最后一个

        static void Main(string[] args)
        {
            Action a1 = F1;
            Action<string> a2 = F2;
            Func<string,int> f1 = F3;
             
        }

        static void F1()
        {
            Console.WriteLine("F1");
        }
        static void F2(string s1)
        {
            Console.WriteLine("F2");
        }
        static int F3(string name)
        {
            return 1;
           
        }

3、匿名方法：

匿名方法就是没有名字的方法 MyDelegate p=delegate(int s) {s=10}

五、 ref 和out

六、 lambda 表达式

练习1：

        static void Main(string[] args)
        {
            //无返回值
            Action<int> a1 = delegate (int i)  { Console.WriteLine(i); };
            Action<int> a2 =  (int i)=>{ Console.WriteLine(i);};
            Action<int> a3 = i => { Console.WriteLine(i); };  //只有一个参数
            a1(3333);
            a2(4444);

            //有返回值
            Func<int, string, bool> f1 = delegate (int i, string name) { return true; };
            Func<int, string, bool> f2 =  (int i, string name)=> {  return true; };
            Func<int, string, bool> f3 = (i, name) => { return true; };
            Func<int, string, bool> f4 = (i, name) => true;  //有返回值且只有一行代码，可以省略return 和大括号
            f1(1, "chen");
            f2(1, "chen");
            
            Console.ReadKey();

        }

练习2：

        static void Main(string[] args)
        {
          

            int[] nums = new int[] { 3, 88, 6, 9 };
            //1. 
            // int m = GetMax(nums, compareInt);
            //2/
            // Func<int, int, bool> f = delegate (int i1, int i2) { return i1 > i2; };
            // int m=GetMax(nums,f)
            //3. 
            int m = GetMax(nums, (i1, i2) => i1 > i2 );

            Console.WriteLine(m);
            Console.ReadKey();
             

        }
        static bool compareInt(int i1,int i2)
        {
            return i1 > i2;
        }


        static T GetMax<T>(T[] objs,Func<T,T,bool> compareFunc)
        {
            T max = objs[0];
            for (int i = 0; i < objs.Length; i++)
            {
                if(compareFunc(objs[i],max))
                max = objs[i];
            }
            return max;
        }

练习3：

    static class JiHeExt
    {
        public static IEnumerable<T> MyWhere<T>(this IEnumerable<T> data,Func<T,bool> func)
        {
            List<T> resultList = new List<T>();
            foreach(T item in data)
            {
                if (func(item))
                {
                    resultList.Add(item);
                }
            }
            return resultList;

        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            int[] nums = new int[] { 3, 88, 6, 9 };
            IEnumerable<int> r1 = nums.MyWhere(i => i > 10);
            foreach (int item in r1)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();


        } 


    }

练习4：

        static void Main(string[] args)
        {
            List<int> list1 = new List<int> { 1, 2,3,8,16,99 };
           // IEnumerable<int> data=  list1.Where(i => i > 10);   //where 对数据按照lambda表达式进行过滤
            IEnumerable<string> data = list1.Select(i => i +"你好");  //select 则对集合中的数据进行处理，生成一个新的集合
            foreach (var item in data)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

        }

练习5：

class Program
    {
        static void Main(string[] args)
        {
            Person[] p = new Person[]
            {
                new Person{Name="chen",Age=12},
                new Person{Name="chen2",Age=24},
                new Person{Name="chen3",Age=12}
            };

           int e = p.Sum(i => i.Age);

           List<Person> ps = p.ToList();
           Person[] ps4 = p.ToArray();

Console.WriteLine(e); Console.ReadKey(); } } class Person { public string Name { get; set; } public int Age { get; set; } }

六、扩展方法：

七、委托组合：

    class Program
    {
        static void Main(string[] args)
        {
            Mydel d1 = F1;
            Mydel d2 = F2;
            Mydel d3 = F3;
            Mydel d4 = d1 + d2 + d3;
            d4(8);
          //  Console.WriteLine(d4);
            Console.ReadKey();
        } 
        static void F1(int i)
        {
            Console.WriteLine("我是F1："+i);
        }
        static void F2(int i)
        {
            Console.WriteLine("我是F2：" + i);
        }
        static void F3(int i)
        {
            Console.WriteLine("我是F3：" + i);
        }


    }
    delegate void Mydel(int i);

八、事件：

   class Person
    {

        private int age;
        public int Age {
            get
            {
                return this.age;
            }
            set
            {
                this.age = value;
                if(value%12==0)
                {
                    if(OnBenMingNian!=null)
                    {
                        OnBenMingNian(); //调用添加的组合的方法
                    }
                }
            }

        }
        public event  Action OnBenMingNian;  // event  委托类型  事件的名字
      //  public Action OnBenMingNian;//加上event就是事件，不加event就是委托；
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person();
            p1.OnBenMingNian += BMN;//方法的参数返回值要和事件的委托一致
            p1.Age = 5;
            Console.WriteLine(p1.Age);
            p1.Age = 24;
            Console.WriteLine(p1.Age);
            p1.Age = 55;
            Console.WriteLine(p1.Age);


            //  Console.WriteLine(d4);
            Console.ReadKey();
        } 
        static void BMN()
        {
            Console.WriteLine("本命年到了");
        }

    }

事件和委托的关系：反编译看，事件是由一个私有的委托变量和add 和remove方法组成的

事件、索引器、属性本质上都是方法；面试题：接口中可以定义什么？接口中可以定义方法，事件，属性和索引，因为他们本质上都是方法