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 = 0;
            for (int i = 0; i < array.Length; i++)
            {
                sum += array[i];
            }
            return sum;
        }

        //这里定义了一个int类型的参数数组，参数数组和数组参数（上面的）的不同，
        //在于函数的调用，调用参数数组的函数的时候，我们可以传递过来任意多个参数，
        //然后编译器会帮我们自动组拼成一个数组，参数如果是上面的数组参数，那么这个数组我们自己去手动创建
        static int Plus(params int[] array)
        {
            int sum = 0;
            for (int i = 0; i < array.Length; i++) {
                sum += array[i];
            }
            return sum;
        }
        static void Main(string[] args)
        {
            int sum = Sum(new int[] {23, 4, 34, 32, 32, 42, 4});
            Console.WriteLine(sum);
            int sum2 = Plus(23, 4, 5, 5, 5, 32, 423, 42, 43,23,42,3);//参数数组就是帮我们 减少了一个创建数组的过程 
            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 = 0; i < sortArray.Length - 1; i++) {
                    if (compareMethod(sortArray[i],sortArray[i+1])) {
                        T temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        swapped = true;
                    }
                }
            } while (swapped);
        }
        static void Main(string[] args) {
            Employee[] employees = new Employee[]
            {
                new Employee("dsf",12), 
                new Employee("435dsf",234), 
                new Employee("234dsf",14), 
                new Employee("ds234f",234), 
                new Employee("dssfdf",90)
            };
            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 > 0)
            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();
    ...
}