委托、接口、列表

实践/后端/C#基础/24.委托.md

@@ -0,0 +1,185 @@
+> 委托
+- 当要把方法传递给其他方法时，就需要使用委托。
+  
+
+> 声明委托
+- 使用委托时
+    - 首先必须定义要使用的委托，对于委托，定义它就是告诉编译器这种类型的委托表示哪种类型的方法。
+    - 然后，必须创建该委托的一个或多个实例。编译器在后台将创建表示该委托的一个类。
+- 声明委托的语法如下：
+```
+delegate void IntMethodInvoker(int x)；
+声明了一个委托IntMethodInvoker，并指定该委托的每个实例都可以包含一个方法的引用，该方法带有一个int参数，并返回void。
+委托的类型安全性非常高。在定义委托时，必须给出它所表示的方法的签名和返回类型等全部细节。
+```
+- 理解委托的一种好方式是把委托视为给方法的签名和返回类型指定名称。
+
+ 
+```
+定义一个委托TwoLongsOp，该委托表示的方法有两个long型参数，返回类型为double。
+delegate double TwoLongsOp(long first,long second);
+或者定义一个委托，它表示的方法不带参数，返回一个string型的值
+delegate string GetAStringent();
+```
+- 实际上，“定义一个委托”是指“定义一个新类”，委托实现为派生自基类System.MulticastDelegate的类，System.MulticastDelegate又派生自基类System.Delegate。
+
+> 使用委托
+- 在int值上调用ToString()方法的一种相当复杂的方式
+```
+private delegate string GetAString();
+public static void Main()
+{
+    int x=40；
+    GetAString firstStringMethod=newGetAString(x.ToString);
+    WriteLine($"String is (fistStringMethod{})");
+}
+```
+> 简单的委托示例
+- 定义一个类MathOperations，它有两个静态方法，对double类型的值执行两种操作。然后使用该委托调用这些方法。
+```
+class MathOperation
+{
+    public static double MultiplyByTwo(double value)=>value*2;
+    public static double Square(double value)=>value*value;
+}
+调用这些方法
+using static System.Console；
+namespace Wrox.ProCSharp.Delegates
+{
+    delegate double DoubleOp(double x);
+    class Program
+    {
+        static void Main()
+        {
+            DoubleOp[] operations=
+            {
+                MathOperation.MultiplyByTwo,
+                MathOperations.Square
+            };
+            for(int i=0;i<operations.Length;i++)
+            {
+                WriteLine($"Using operations[{i}]:");
+                ProcessAndDisplayNumber(operations[i],2.0);
+                ProcessAndDisplayNumber(operations[i],7.94);
+                ProcessAndDisplayNumber(operations[i],1.414);
+                WriteLine();
+            }
+        }
+        static void ProcessAndDisplayNumber(DoubleOp action,double value)
+        {
+            double result =action(value);
+            WriteLine($"Value is {value},result of operation is {result}");
+        }
+    }
+}
+```
+
+> Action<T>和Func<T>委托
+
+- 泛型Action<T>委托表示引用一个void返回类型的方法。这个委托类存在不同的变体，可以传递至多16种不同的参数类型。没有泛型参数的Action类可调用没有参数的方法。Action<in T>调用带一个参数的方法，Action<in T1,in T2>调用带两个参数的方法，Action<in T1,in T2，in T3,in T4,in T5,in T6,in T7,in T8>调用8个参数的方法。
+- Func<T>允许调用带返回类型的方法。与Action<T>类似，Func<T>也定义了不同的变体，至多也可以传递16个参数类型和一个返回类型。Func<out TResult>委托类型可以调用带返回类型且无参数的方法，Func<in T,out TResult>调用带一个参数的方法，func<in T1,in T2,in T3,in T4,out TResult>调用4个参数的方法。
+
+- delegate double DoubleOp(double x);
+- 除了声明自定义委托DoubleOp之外，还可以使用Func<int T,out TResult>委托。可以声明一个该委托类型的变量，或者声明该委托类型的数组
+```
+<double ,double>[] operations=
+{
+    MathOperations.MultiplyByTwo,
+    MathOperations.Square
+};
+使用委托，并将ProcessAndDisplayNumber()方法作为参数：
+static void ProcessAndDisplayNumber(Func<double,double>action,double value)
+{
+    double result=action(value);
+    WriteLine{$"Value is{value},result of operation is {result}"}
+}
+```
+**BubbleSorter示例**
+- 编写一个类BubbleSorter，它实现一个静态方法Sort(),这个方法的第一个参数是一个对象数组，把该数组按照升序重新排列。
+- 进行冒泡排序的方法如下：
+```
+bool swapped=true;
+do
+{
+    swapped=false;
+    for(int i=0;i<sortArray.Length-1;i++)
+    {
+        if(sortArray[i]>sortArray[i+1])
+        {
+            int temp=sortArray[i];
+            sortArray[i]=sortArray[i+1];
+            sortArry[i+1]=temp;
+            swapped=true;
+        }
+    }
+
+    
+}while(swapped);
+```
+- 定义BubbleSorter类
+```
+class BubbleSorter
+{
+    static public void Sort<T>(IList<T> sortArray,Func<T,T,bool>comparison)
+    {
+        bool swapped=true;
+        do
+        {
+            swapped=false;
+            for (int i=0;i<sortArray.Count-1;i++)
+            {
+                if(comparison(sortArray[i+1],sortArry[i]))
+                {
+                    T temp=sortArray[i];
+                    sortArray[i]=sortArray[i+1];
+                    sortArray[i+1]=temp;
+                    swapped=true;
+                }
+            } 
+        }while(swapped);
+    }
+}
+```
+- 为了使用这个类，需要定义另一个类，从而建立要排序的数组。假定Mortimer Phones移动电话公司有一个员工列表，要根据他们的薪水进行排序。每个员工分别由类Employee的一个实例表示，
+```
+class Employee
+{
+    public Employee(string name,decimal salary)
+    {
+        Name=name;
+        Salary=salary;
+    }
+    public string Name{get;}
+    public decimal Salary{get;private set;}
+    public override string ToString()=>$"{Name},{Salary:C}";
+    public static bool CompareSalary(Employee e1,Employee e2)=>e1.Salary<e2.Salary;
+}
+```
+- 为了匹配Func<T,T,bool>委托的签名，在这个类中必须定义CompareSalay，它的参数是两个Employee引用，并返回一个布尔值。
+```
+using static System.Console;
+
+namespace Wrox.ProCSharp.Delegates
+{
+    class Program
+    {
+        static void Main()
+        {
+            Employee[] employees=
+            {
+                new Employee("Bugs Bunny",20000),
+                new Employee("Elmer Fudd",10000),
+                new Employee("Daffy Duck",25000),
+                new Employee("Wile Coyote",1000000.38m),
+                new Employee("Foghorn Leghorn",23000),
+                new Employee("RoadRunner",50000)
+            };
+            BubbleSorter.Sort(employee，Employee.CompareSalary);
+            foreach(var employee in employees)
+            {
+                WriteLine(employee);
+            }
+        }
+    }
+}
+```

实践/后端/C#基础/25.接口、列表.md

@@ -0,0 +1,115 @@
+>集合接口和类型
+- 大多数接口都可在System.Collections和System.Collections.Generic名称空间中找到。泛型集合类位于System.Collections.Generic名称空间中；
+  
+**接口及说明**
+- IEnumerable<T>:如果将foreach语句用于集合，就需要IEnumerable接口，这个接口定义了方法GetEnumerator(),它返回一个实现了IEnumerator接口的枚举。
+- ICollection<T>:ICollection<T>接口由泛型集合实现。使用这个接口可以获得集合中的元素个数，把集合复制到数组中(CopyTo()方法)，还可以从集合中添加和删除元素（Add()、Remove()、Clear()）
+- IList<T>:用于可通过位置访问其中的元素列表，这个接口定义了一个索引器，可以在集合的指定位置插入或删除某些项（Insert()和RemoveAt()方法）.IList<T>接口派生自ICollection<T>接口
+- ISet<T>:该接口由集实现。集允许合并不同的集，获得两个集的交集，检查两个集是否重叠。ISet<T>接口派生自ICollection<T>接口
+- IDictionary<TKey,TValue>:由包含键和值得泛型集合类实现。使用这个接口可以访问所有的键和值，使用键类型的索引器可以访问某些项，还可以添加或删除某些项
+- ILookup<TKey,TValue>:类似于IDictionary<TKey,TValue>接口，实现该接口的集合有键和值，且可以通过一个键包含多个值
+- IComparer<T>:由比较器实现，通过Comparer()方法给集合中的元素排序
+- IEqualityComparer<T>:由一个比较器实现，该比较器可用于字典中的键，使用这个接口，可以对对象进行相等性比较
+
+
+> 列表
+
+- 例子：将Racer类中的成员用作要添加到集合中的元素，以表示一级方程式的一位赛车手。这个类有5个属性：Id、Firstname、Lastname、Country和Wins的次数。在该类的构造函数中，可以传递赛车手的姓名和获胜次数，以设置成员。重写ToString()是为了返回赛车手的姓名。Racer类也实现了泛型接口IComparable<T>,为Racer类中的元素排序，还实现了IFormattable接口
+```
+public class Racer:IComparable<Racer>,IFormattable
+{
+    public int Id{get;}
+    public string FirstName{get;set;}
+    public string LastName{get;set;}
+    public string Country{get;set;}
+    public int Wins{get;set;}
+
+    public Racer(int id,string firstName,string lastName,string country):this(id,firstName,lastName,country,wens:0)
+    {}
+    public Racer(int id,string firstName,string lastName,string country,int wins)
+    {
+        Id=id;
+        FirstName=firstName;
+        LastName=lastName;
+        Country=country;
+        Wins=wins;
+    }
+    public override string ToString()=>$"{FirstName}{LastName}";
+    public string ToString(string format,IFormatProvider formatProvider)
+    {
+        if(format==null)format="N";
+        switch {format.ToUpper()}
+        {
+            case "N":
+            return ToString();
+            case "F":
+            return FirstName;
+            case "L"
+            return LastName;
+            case "W"
+            return $"{ToString()},Wins:{Wins}";
+            case "C":
+            return $"{ToString()},Country:{Country}",
+            case "A"
+            return $"{ToString()},Country:{Country} Wins:{Wins}";
+            default:
+            throw new FormatException(String.Format(formatProvider,$"Format(format)is not supported"));
+        }
+    }
+    public string ToString(string format)=>ToString(format,null);
+    public int CompareTo(Racer other)
+    {
+        int compare=LastName?.CompareTo(other?.LastName)??-1;
+        if(compare==0)
+        {
+            return FirstName?.CompareTo(other?.FirstName)??-1;
+        }
+        return compare;
+    }
+}
+```
+
+> 创建列表
+- 集合初始值设定项
+```
+var intList=new List<int>(){1,2};
+var stringList=new List<string>(){"one","two"};
+```
+- 添加元素
+  - 使用Add()方法可以给列表添加元素
+  ```
+  var intList=new List<int>();
+  intList.Add(1);
+  intList.Add(2);
+
+  var stringList=new List<string>();
+  stringList.Add("one");
+  stringList.Add("two");
+  ```
+- 插入元素
+```
+racers.Insert(3,new Racer(6,"Phil","Hill","USA"，3))；
+方法InsertRange()提供了插入大量元素的功能，类似于前面的AddRanger()方法。
+```
+
+- 访问元素
+   - 实现了IList和IList<T>接口的所有类都提供了一个索引器，所以可以使用索引器，通过传递元素号来访问元素。
+   - 可以使用Count属性确定元素个数，再使用for循环遍历集合中的每个元素，并使用索引器访问每一项：
+    ```
+    for (int i=0;i<racers.Count;i++>)
+    {
+        WriteLine(racers[i]);
+    }
+    ```
+   - 因为List<T>集合类实现了IEnumerable接口，所以也可以使用foreach语句遍历集合中的元素
+    ```
+    foreach(var r in racers)
+    {
+        WriteLine(r);
+    }
+    ```
+- 删除元素
+- 搜索
+
+
+