委托，文件流，扩展方法学习笔记

1. 委托使用

　　(1) 什么是委托？(安全的函数指针)

　　　　通俗：就是一个能存放符合某种格式(方法签名)的方法的指针的清单

　　(2) 定义委托

     　　public delegate int AddDel(int a,int b);

　　(3) 静态委托方法的实现，一个简单的加法实现

 　　namespace DelegateDemo

　　{

            //约束的指向方法的签名，也就是一个强类型的指针

            public  delegate int AddDel(int a,int b);

            class Program

            {

                   static void Main(string[] args)

                   {

                          //定义一个委托的变量，注意指向第一个方法的时候一定要用new，后面就可以使用+=了

                          AddDel del = new AddDel(AddFunc);  //指向一个方法

                          //使用委托

                          Console.WriteLine(del(2, 3));

                          Console.ReadKey();

                   }

                   static int AddFunc(int a, int b)

                   {

                          return a + b;

                   }

            }

     }

　　(4) 实例委托方法的实现

　namespace DelegateDemo

     {

              //约束的指向方法的签名，也就是一个强类型的指针

            public  delegate int AddDel(int a,int b);

            class Program

            {

                   static void Main(string[] args)

                   {

                          //实例方法

                          Program p = new Program();

                            AddDel del = new AddDel(p.AddInstence);

                          Console.WriteLine(del(2, 3));

                          Console.ReadKey();

                   }

                   //实例方法

                     public int AddInstence(int a, int b)

                   {

                          return a + b;

                   }

            }

     }

　　(5) 可以将这段代码放到Reflect中查看以下，你会发现一些特性的

　　(6) 委托的使用：匿名方法

　　　　1)如果在程序中方法非常简单，并且不怎么重复使用，这就考虑做成匿名方法

    　　 2)匿名方法：第一必须有delegate关键字，后面紧跟方法参数的签名，后面是方法体

        namespace DelegateDemo

            {

                   //约束的指向方法的签名，也就是一个强类型的指针

                   public  delegate int AddDel(int a,int b);

                   class Program

                   {

                          static void Main(string[] args)

                          {

                                 //匿名方法

                                 //如果在程序中方法非常简单，并且不怎么重复使用，这就考虑做成匿名方法

                                 AddDel delNoName = delegate(int a, int b) { return a + b; };

                                 Console.WriteLine(delNoName(2, 3));

                                 Console.ReadKey();

                          }

                   }

            }

　　(7) Lambda表达式继续简化

　　　　1) => Lambda的标记，前面是方法参数的签名，后面是方法体

             namespace DelegateDemo

              {

                     //约束的指向方法的签名，也就是一个强类型的指针

                     public  delegate int AddDel(int a,int b);

                     class Program

                     {

                            static void Main(string[] args)

                            {

                                   //匿Lambda

                                   //第一种写法

                                   AddDel delLambda = (int a, int b) => { return a + b; };

                                   //第二种类型

                                   AddDel delLambda1 = (a, b) => { return a + b; };

                                   //第三种写法

                                   //如果方法体里面只有一行代码，那么Lambda就会自动将表达式的值直接返回回去

                                   //Lambda方法的参数的类型可以省略，因为在委托中已经定义了，方法的签名的格式，所以在编译的时候会自动推断Lambda里面的类型

                                   //Lambda本质就是匿名函数，由匿名函数发展而来

                                   AddDel delLambda2 = (a, b) => a + b;

                                   Console.WriteLine(delLambda(2, 3));

                                   Console.ReadKey();

                            }

                     }

              }

2.扩展方法

　　(1) this:关键字是对那个类型进行扩展，必须指定一个类型，在使用扩展方法的时候，this指定的参数不用传递参数

　　(2)在一个控制台项目中新建一个类ListExt.cs，代码如下：

public static class ListExt

     {

            //把查询结果是否符合我们要求的逻辑抽象到了一个del委托里面去

            public static List<string> MyFindAll(this List<string> list, Predicate<string> del)

            {

                   //遍历List集合中得的每一个元素，并调用del委托执行，看此方法返回的参数true的话放到一个结果集合众

                   List<string> resultList = new List<string>();

                   //遍历原始的集合

                   foreach (var item in list)

                   {

                          //调用传递过来的委托校验元素是否符合我们需要的元素

                          bool isOk = del(item);

                          if (isOk)

                          {

                                 resultList.Add(item);

                          }

                   }

                   return resultList;

            }

     }

     (3)在Main方法中的代码是：

          namespace DelegateDemo

            {

                   public  delegate int AddDel(int a,int b);

                   class Program

                   {

                          static void Main(string[] args)

                          {

                                 //传递委托

                                 List<string> list = new List<string>() { "5", "1", "13", "8", "9" };

                                 //隐式推断类型

                                 //var result = list.MyFindAll(s => string.Compare(s, "3") >= 0);

                                 //Predicate<string> 类型实例

                                 var result = list.MyFindAll(IsStrok);

                                 foreach (var item in result)

                                 {

                                        Console.WriteLine(item);

                                 }

                                 Console.ReadKey();

                          }

                          static bool IsStrok(string s)

                          {

                                 return string.Compare(s, "3") >= 0;

                          }

                   }

            }

3. 泛型委托

　　(1) Reflect中查看Func方法：public delegate TResult Func<in T, out TResult>(T arg);，带两个参数的

     　　1)封装一个具有一个参数并返回 TResult 参数指定的类型值的方法。

    　　 2)arg: 此委托封装的方法的参数。

  　　   3)T: 此委托封装的方法的参数类型。

    　　 4)TResult: 此委托封装的方法的返回值类型。

class Program

     {

            static void Main(string[] args)

            {

                   Func<string, bool, bool> funcDemo = new Func<string, bool, bool>(FuncD);

            }

            static bool FuncD(string s, bool b)

            {

                   return true;

            }

     }

　　(2)Reflect中查看Action方法：ublic delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);

     　　1)封装一个方法，该方法具有两个参数并且不返回值。

     　　2)arg1:此委托封装的方法的第一个参数。

     3)arg2:此委托封装的方法的第二个参数。

     4)T1: 此委托封装的方法的第一个参数类型。

     5)T2:此委托封装的方法的第二个参数类型。

4. FileStream文件流

　　(1) FileStream对象表示在磁盘或者网络路径上执行文件的流

　　(2) 使用FileStream类对文件系统上的文件进行读取，写入，打开和关闭操作

　　(3) FileStream对输入输出进行缓冲，从而提高性能

　　(4) 为什么不使用File.ReadAllText()?好处之一就是：对于大文件来说，FIleStream可以对文件采取分段读取，即每次只读到一部分到内存里面

　　(5) 字符串和字节数组的转换

    　　 1)字节数组转换成字符串：String

           　　 System.Text.Encoding.UTF8.GetString(byte[])

     　　2)字符串转换成字节数组：byte[]

           　　 System.Text.Encoding.UTF8.GetButes(String)

　　(6)文件读写的案例代码：只作为参考，可自行研究

public partial class frmMain : Form

     {

            public frmMain()

            {

                   InitializeComponent();

            }

            private void btnCheckFile_Click(object sender, EventArgs e)

            {

                   using (OpenFileDialog ofd = new OpenFileDialog())

                   {

                          //设定文件流要读取那个类型

                          //ofd.Filter = "*.txt|(*.txt)|(*.doc)|(*.doc)";

                          if (ofd.ShowDialog() == DialogResult.OK)

                          {

                                 txtFileName.Text = ofd.FileName;

                          }

                   }

            }

            private void btnReadFile_Click(object sender, EventArgs e)

            {

                   if (txtFileName.Text == "")

                   {

                          MessageBox.Show("请您选择文件信息");

                          return;

                   }

                   using (FileStream fsRead = new FileStream(txtFileName.Text, FileMode.OpenOrCreate, FileAccess.Read))

                   {

                          using (StreamReader reader = new StreamReader(fsRead, Encoding.Default))

                          {

                                 while (!reader.EndOfStream)

                                 {

                                        string str = reader.ReadLine() + "\r\n";

                                        this.rtbFileContent.AppendText(str);

                                 }

                          }

                   }

            }

            private void btnSave_Click(object sender, EventArgs e)

            {

                   if (rtbWriteFile.Text == "")

                   {

                          MessageBox.Show("请您填写要写入文档的内容");

                          return;

                   }

                   using (SaveFileDialog sfd = new SaveFileDialog())

                   {

                          if (sfd.ShowDialog() == DialogResult.OK)

                          {

                                 using (StreamWriter writer = new StreamWriter(sfd.FileName))

                                 {

                                        writer.Write(this.rtbWriteFile.Text);

                                        //将内存中的数据写入到磁盘中

                                        writer.Flush();

                                 }

                          }

                   }

                   MessageBox.Show("文件写入成功，请您检查");

            }

            private void btnClose_Click(object sender, EventArgs e)

            {

                   this.Close();

            }

       }