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

1. 委托使用

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

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

　　(2) 定义委托

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

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

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

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) 实例委托方法的实现

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

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关键字，后面紧跟方法参数的签名，后面是方法体

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

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的标记，前面是方法参数的签名，后面是方法体

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

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，代码如下：

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

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方法中的代码是：

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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: 此委托封装的方法的返回值类型。

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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)文件读写的案例代码：只作为参考，可自行研究

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

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();               }          }