C#易忘点

下面是自己总结的一些C#语言方面用的少容易忘的地方，总结一下，在用的时候看一下。（仅针对本人）

参数数组

定义一个函数，用来取得数字的和，但是数字的个数不确定。

解决方案： 1，定义一个函数，参数传递过来一个数组； 2，定义一个参数个数不确定的函数，这个时候我们就要使用参数数组。

参数数组相比于数组参数的区别：params

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace _050_参数数组__定义一个参数个数不确定的函数_ {
     class Program {
         //如果一个函数定义了参数，那么在调用这个函数的时候，一定要传递对应类型的参数，否则无法调用（编译器编译不通过）
         static int Sum(int[] array)
         {
             int sum = ;
             for (int i = ; i < array.Length; i++)
             {
                 sum += array[i];
             }
             return sum;
         }
 
         //这里定义了一个int类型的参数数组，参数数组和数组参数（上面的）的不同，
         //在于函数的调用，调用参数数组的函数的时候，我们可以传递过来任意多个参数，
         //然后编译器会帮我们自动组拼成一个数组，参数如果是上面的数组参数，那么这个数组我们自己去手动创建
         static int Plus(params int[] array)
         {
             int sum = ;
             for (int i = ; i < array.Length; i++) {
                 sum += array[i];
             }
             return sum;
         }
         static void Main(string[] args)
         {
             int sum = Sum(new int[] {, , , , , , });
             Console.WriteLine(sum);
             int sum2 = Plus(, , , , , , , , ,,,);//参数数组就是帮我们 减少了一个创建数组的过程
             Console.WriteLine(sum2);
             Console.ReadKey();
         }
     }
 }

委托

委托(delegate)是一种存储函数引用的类型。

委托的定义很简单，声明一个函数，然后在前面加上 delegate 关键字，这样就声明了一个委托

委托的使用分两步：声明，定义

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _053_委托的使用 {
    //定义一个委托跟函数差不多，区别在于
    //1,定义委托需要加上delegate关键字
    //2,委托的定义不需要函数体
    public delegate double MyDelegate(double param1, double param2);
    class Program {
        static double Multiply(double param1, double param2)
        {
            return param1*param2;
        }
 
        static double Divide(double param1, double param2)
        {
            return param1/param2;
        }
        static void Main(string[] args)
        {
            MyDelegate de;//利用我们定义的委托类型声明了一个新的变量
            de = Multiply;//当我们给一个委托的变量赋值的时候，返回值跟参数列表必须一样，否则无法赋值
 
            Console.WriteLine(de(2.0, 34.1));
            de = Divide;
            Console.WriteLine( de(2.0,34.1) );
            Console.ReadKey();
        }
    }
}

Action委托：返回值为void，参数可以为0个或多个   Action[<param...>] xxx = 某函数

Func委托：有一个返回值，参数可以为0个或多个    Func<[param...],returnType> xxx = 某函数

多播委托：就是定义一个委托后，不止绑定某一个函数，使用+=，-=符号来添加删除绑定的函数。要注意的是，多播委托中，中间如果某一个函数执行出错，后面的都不会执行

委托的使用：比如要定义一个针对学生名及学生成绩的排序（也可能是其它情况），以前的排序方法，需要我们针对不同的情况写不同的排序方法。现在有了委托后，我们可以传入一个类型不定的数组，传入一个委托类型的排序方法，在这个排序方法中写好排序就行。

 namespace _007_冒泡排序拓展 {
     class Employee {
         public string Name { get; private set; }
         public int Salary { get; private set; }
 
         public Employee(string name, int salary)
         {
             this.Name = name;
             this.Salary = salary;
         }
         //这里定义了一个针对Employee的比较方法
         public static bool Compare(Employee e1, Employee e2)
         {
             if (e1.Salary > e2.Salary) return true;
             return false;
         }
 
         public override string ToString()
         {
             return Name + ":" + Salary;
         }
     }
 }

 namespace _007_冒泡排序拓展 {
     class Program {
　　　　　　 //这里定义了一个通用的排序方法
         static void CommonSort<T>(T[] sortArray, Func<T,T,bool>  compareMethod)
         {
             bool swapped = true;
             do {
                 swapped = false;
                 for (int i = ; i < sortArray.Length - ; i++) {
                     if (compareMethod(sortArray[i],sortArray[i+])) {
                         T temp = sortArray[i];
                         sortArray[i] = sortArray[i + ];
                         sortArray[i + ] = temp;
                         swapped = true;
                     }
                 }
             } while (swapped);
         }
         static void Main(string[] args) {
             Employee[] employees = new Employee[]
             {
                 new Employee("dsf",),
                 new Employee("435dsf",),
                 new Employee("234dsf",),
                 new Employee("ds234f",),
                 new Employee("dssfdf",)
             };
             CommonSort<Employee>(employees,Employee.Compare);
             foreach (Employee em in employees)
             {
                 Console.WriteLine(em);
             }
             Console.ReadKey();
         }
     }
 }

Lambda表达式：凡是能用委托表达的都能使用Lambda表达式来表达，反正式子中有这玩意"=>"，也没见用这玩意咋样，还要难理解些，不用，谁用谁煞笔

事件：事件是基于委托的，有了委托才会有事件。下面举一个例子，有两个类，丈夫和妻子，妻子类有个方法是看丈夫在玩游戏没，丈夫类有个方法是观察妻子的动向。在以往的写法中，每当妻子调用她的方法后，丈夫也要调用自身的方法，这样在本例中还算好的，如果换成其它的一对多的关系，那么代码量会很大，且维护起来很麻烦。有了委托后（注意，这里说的还是委托，还没有用到事件），我们在创建丈夫后，将丈夫的方法绑定到妻子的一个委托上，这样妻子每次检查时丈夫都会观察到并执行相应函数。

 namespace ConsoleApp1
 {
     class Wife//妻子
     {
         //这里声明一个委托用来绑定丈夫的观察函数
         public Action bindfunc;
         public void Coming()
         {
             Console.WriteLine("妻子：去看看老公在玩游戏没");
             if(bindfunc != null)
             {
                 bindfunc();
             }
         }
     }
 }

 namespace ConsoleApp1
 {
     class Husband//丈夫
     {
         public Husband(Wife wife)
         {
             // 在构造丈夫的时候，就把自身的函数绑定到妻子的delegate上
             wife.bindfunc = See;
         }
 
         public void See()
         {
             Console.WriteLine("丈夫：盯到看到，媳妇来老");
         }
     }
 }

 namespace ConsoleApp1
 {
     class Program
     {
         static void Main(string[] args)
         {
             Wife wife = new Wife();
             Husband husband = new Husband(wife);
             wife.Coming();
         }
     }
 }

嗯嗯，关于事件event，它就是把上面在妻子中声明的委托  public Action bindfunc 改成 public event Action bindfunc，就是加了个event表示而已，那它有啥作用呢。如果不用event标识，那妻子中的委托bindfunc我们可以使用妻子的实例随手调用，用event声明后，它就是一个事件，不能随手用。

属性

我们习惯上把类中的字段设置为私有的，这样外接不能够修改字段的值，然后我们通过定义属性来设置和取得字段中的值

 private int age;
 public int Age
 {
     set{age = value;}
     get{return age;}
 }

从上面可以看到，属性包含两个块，get块和set块。访问属性和访问字段一样，当取得属性的值的时候，就会调用属性中的get块，所以get块，当我们去给属性设置值的时候，就会调用属性中的set块

属性需要注意的地方：

1:、另外，set块和get块可以只提供一个（两个都不提供也行，那相当于该属性没有用），如果只提供set块表示只写，只提供get块表示只读

2、set块和get块可以设置为私有的，设置为私有的块只能在类的内部访问（当然该属性也可以设置为私有，这样该属性只能在类的内部使用）

 public string name
 {
     private set{name = value;}
     get{return name;}
 }

3、我们也可以不用创建字段，直接设置属性，这样编译器会帮我们自动创建

 public int Age{get;set;}

4、属性相对于以前单独创建函数来设置和获取字段值，不同是它可以在设置的时候，做一些需要的操作，比如判断

 public int Age
 {
      set
     {
          if(value > )
             age = value;
     }
 }

虚方法和隐藏方法

虚方法：在父类中使用virtual关键字声明函数，在子类中使用override关键字声明该函数

隐藏方法：不适用virtual关键字和override关键字声明

定义2个类，Enemy和Boss，Boss继承自Enemy

 class Enemy
 {
     public void Run()
     {
         print("父类Run");
     }
     public virtual void Eat()
     {
         print("父类Eat");
     }
 }

 class Boss:Enemy
 {
     public void Run()
     {
         print("子类Run");
     }
     public override void Eat()
     {
         print("子类Eat");
     }
 }

 class Test
 {
     static void Main(string[] args) {
         Enemy e1 = new Boss();
         e1.Run();    //父类Run
         e1.Eat();    //子类Eat
 
         Boss b1 = new Boss();
         b1.Run();    //子类Run
         b1.Eat();    //子类Eat
     }
 }

可以看到，如果是隐藏方法，那么如果使用父类声明子对象，调用的方法还是父类的方法。因为，隐藏方法只是隐藏，父类中的方法还在。

如果是虚方法，那么调用后都是执行子类中的代码。因为，虚方法重写后父类中的方法就不存在了。

使用虚方法还有一个重要的作用，那就是当声明一个函数的时候，如果当时并不知道具体的实现，只知道以后子类会用到它，那么我们可以先把它声明为虚方法，等着以后子类去实现。

 class Test
 {
     public void Use()
     {
         UseThis();
     }
     public virtual void UseThis()
     {
     }
 }

抽象类

抽象类其实和前边说的虚方法有关。虚方法中，用virtual关键字声明后，在子类中可以重写也可以不重写。抽象类使用abstract关键字声明函数（注意：函数使用abstract声明后，那么类自动称为抽象类，也需要使用abstract声明，编译器会提示的），子类中必须使用关键字override实现该函数。

注意，抽象类可以声明子类对象，但是不能直接使用抽象类实例化对象。

 abstract class Test
 {
     public abstract void Use();
 }

接口

接口是特殊的抽象类，在抽象类中可以定义字段和普通的方法，但是在接口中只能定义方法，且不允许提供接口中任何成员的实现方式，不允许声明成员修饰符，接口中的成员都是共有的。

说白了，接口中就是声明了一些公有方法，让继承该接口的子类自己去实现。

 public interface Test
 {
     public void Use();
     public void Do();
     ...
 }