首页 > 代码库 > 一些概念的随笔(转)

一些概念的随笔(转)

delegate Boolean moreOrlessDelgate(int item);        class Program        {            static void Main(string[] args)            {                var arr = new List<int>() { 1, 2, 3, 4, 5, 6,7,8 };                var d1 = new moreOrlessDelgate(More);                            Print(arr, d1);                Console.WriteLine("OK");                var d2 = new moreOrlessDelgate(Less);                Print(arr, d2);                Console.WriteLine("OK");                Console.ReadKey();            }            static void Print(List<int> arr,moreOrlessDelgate dl)            {                foreach (var item in arr)                {                    if (dl(item))                    {                        Console.WriteLine(item);                    }                }            }            static bool More(int item)            {                if (item > 3)                {                     return true;                 }                return false;            }            static bool Less(int item)            {                if (item < 3)                {                    return true;                }                return false;            }        }

 简单的委托代码

这段代码中

      <1>首先定义了一个委托类型

        delegate Boolean moreOrlessDelgate(int item);

        你看到了,委托和类是一个级别的,确实是这样:委托是一种类型

        和class标志的类型不一样,这种类型代表某一类方法。

        这一句代码的意思是:moreOrlessDelgate这个类型代表返回值为布尔类型,输入参数为整形的方法

      <2>有类型就会有类型的实例  

        var d1 = new moreOrlessDelgate(More);     
        var d2 = new moreOrlessDelgate(Less);

        这两句就是创建moreOrlessDelgate类型实例的代码,

        它们的输入参数是两个方法

      <3>有了类型的实例,就会有操作实例的代码   

        Print(arr, d1);
        Print(arr, d2);

        我们把前面两个实例传递给了Print方法

        这个方法的第二个参数就是moreOrlessDelgate类型的

        在Print方法内用如下代码,调用委托类型实例所指向的方法

        dl(item)

 

 

简单的泛型

var intList = new List<int>() { 1,2,3};              intList.Add(4);              intList.Insert(0, 5);              foreach (var item in intList)              {                  Console.WriteLine(item);              }              Console.ReadKey();

 如果这里使用Hashtable、Queue或者Stack等非泛型的容器

        就会导致装箱操作,损耗性能。因为这些容器只能存储Object类型的数据

 

List<T>、Dictionary<TKey, TValue>等泛型类型都是.net类库定义好并提供给我们使用的

        但在实际开发中,我们也经常需要定义自己的泛型类型

public static class SomethingFactory<T>          {              public static T InitInstance(T inObj)              {                  if (false)//你的判断条件                  {                      //do what you want...                      return inObj;                  }                  return default(T);              }          }

 

var a1 = SomethingFactory<int>.InitInstance(12);              Console.WriteLine(a1);              Console.ReadKey();

 这就是一个自定义的静态泛型类型,

        此类型中的静态方法InitInstance对传入的参数做了一个判断

        如果条件成立,则对传入参数进行操作之后并把它返回

        如果条件不成立,则返回一个空值

        注意:

          [1]

            传入参数必须为指定的类型,

            因为我们在使用这个泛型类型的时候,已经规定好它能接收什么类型的参数

            但在设计这个泛型的时候,我们并不知道使用者将传递什么类型的参数进来

          [2]

            如果你想返回T类型的空值,那么请用default(T)这种形式

            因为你不知道T是值类型还是引用类型,所以别擅自用null

 

 

泛型约束

        很多时候我们不希望使用者太过自由

        我们希望他们在使用我们设计的泛型类型时

        不要很随意的传入任何类型

        对于泛型类型的设计者来说,要求使用者传入指定的类型是很有必要的

        因为我们只有知道他传入了什么东西,才方便对这个东西做操作

        让我们来给上面设计的泛型类型加一个泛型约束

public static class SomethingFactory<T> where T:MyObj

 使用SomethingFactory的时候就只能传入MyObj类型或MyObj的派生类型啦

        注意:

          还可以写成这样

          where T:MyObj,new()

          来约束传入的类型必须有一个构造函数。        

 

泛型的好处

      <1>算法的重用

        想想看:list类型的排序算法,对所有类型的list集合都是有用的

      <2>类型安全

      <3>提升性能

        没有类型转化了,一方面保证类型安全,另一方面保证性能提升

      <4>可读性更好

 

泛型委托

Predicate泛型委托

        把上面例子中d1和d2赋值的两行代码改为如下:    

              //var d1 = new moreOrlessDelgate(More);              var d1 = new Predicate<int>(More);
              //var d2 = new moreOrlessDelgate(Less);              var d2 = new Predicate<int>(Less);

        把Print方法的方法签名改为如下:    

            //static void Print(List<int> arr, moreOrlessDelgate<int> dl)            static void Print(List<int> arr, Predicate<int> dl)

        然后再运行方法,控制台输出的结果和原来的结果是一模一样的。

        那么Predicate到底是什么呢?

        来看看他的定义:    

          // 摘要:          //     表示定义一组条件并确定指定对象是否符合这些条件的方法。          //          // 参数:          //   obj:          //     要按照由此委托表示的方法中定义的条件进行比较的对象。          //          // 类型参数:          //   T:          //     要比较的对象的类型。          //          // 返回结果:          //     如果 obj 符合由此委托表示的方法中定义的条件,则为 true;否则为 false。          public delegate bool Predicate<in T>(T obj);

        看到这个定义,我们大致明白了。

        .net为我们定义了一个委托,

        这个委托表示的方法需要传入一个T类型的参数,并且需要返回一个bool类型的返回值

        有了它,我们就不用再定义moreOrlessDelgate委托了,

        而且,我们定义的moreOrlessDelgate只能搞int类型的参数,

        Predicate却不一样,它可以搞任意类型的参数

        但它规定的还是太死了,它必须有一个返回值,而且必须是布尔类型的,同时,它必须有一个输入参数

        除了Predicate泛型委托,.net还为我们定义了Action和Func两个泛型委托

 

 

Action泛型委托

        Action泛型委托限制的就不那么死了,

        他代表了一类方法:

        可以有0个到16个输入参数,

        输入参数的类型是不确定的,

        但不能有返回值,

        来看个例子:      

              var d3 = new Action(noParamNoReturnAction);              var d4 = new Action<int, string>(twoParamNoReturnAction);

         注意:尖括号中int和string为方法的输入参数

 
            static void noParamNoReturnAction()            {                //do what you want            }            static void twoParamNoReturnAction(int a, string b)            {                //do what you want            }
 

 

 

Func泛型委托

        为了弥补Action泛型委托,不能返回值的不足

        .net提供了Func泛型委托,

        相同的是它也是最多0到16个输入参数,参数类型由使用者确定

        不同的是它规定要有一个返回值,返回值的类型也由使用者确定

        如下示例:      

          var d5 = new Func<int, string>(oneParamOneReturnFunc);

        注意:string类型(最后一个泛型类型)是方法的返回值类

 static string oneParamOneReturnFunc(int a)            {                //do what you want                return string.Empty;            }

 

匿名方法
为了得到序列中较大的值
我们定义了一个More方法      
      var d1 = new Predicate<int>(More);

然而这个方法,没有太多逻辑(实际编程过程中,如果逻辑较多,确实应该独立一个方法出来)那么能不能把More方法中的逻辑,直接写出来呢?C#2.0之后就可以了,请看下面的代码:

    (2)使用      

            var arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 };            //var d1 = new moreOrlessDelgate(More);            //var d1 = new Predicate<int>(More);            var d1 = new Predicate<int>(delegate(int item)            {

          //可以访问当前上下文中的变量
          Console.WriteLine(arr.Count);

                if (item > 3)

                {                    return true;                }                return false;            });            Print(arr, d1);            Console.WriteLine("OK");
我们传递了一个代码块给Predicate的构造函数其实这个代码块就是More函数的逻辑

(3)好处

<1>代码可读性更好

<2>可以访问当前上下文中的变量这个用处非常大,如果我们仍旧用原来的More函数想要访问arr变量,势必要把arr写成类级别的私有变量了用匿名函数的话,就不用这么做了。

 

Lambda表达式

List<int> arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };            arr.ForEach(new Action<int>(delegate(int a) { Console.WriteLine(a); }));            arr.ForEach(new Action<int>(a => Console.WriteLine(a)));

 匿名方法的代码如下:

      delegate(int a) { Console.WriteLine(a); }

      使用lambda表达式的代码如下:

      a => Console.WriteLine(a)

      这里解释一下这个lambda表达式

      <1>

        a是输入参数,编译器可以自动推断出它是什么类型的,

        如果没有输入参数,可以写成这样:

        () => Console.WriteLine("ddd")

      <2>

        =>是lambda操作符

      <3>

        Console.WriteLine(a)是要执行的语句。

        如果是多条语句的话,可以用{}包起来。

        如果需要返回值的话,可以直接写return语句

 

扩展方法

如果想给一个类型增加行为,一定要通过继承的方式实现吗?

来看看这段代码:    

          public static void PrintString(this String val)          {              Console.WriteLine(val);          }

      消费这段代码的代码如下:    

            var a = "aaa";            a.PrintString();            Console.ReadKey();

      我想你看到扩展方法的威力了。

      本来string类型没有PrintString方法

(1)先决条件

        <1>扩展方法必须在一个非嵌套、非泛型的静态类中定义

        <2>扩展方法必须是一个静态方法

        <3>扩展方法至少要有一个参数

        <4>第一个参数必须附加this关键字作为前缀

        <5>第一个参数不能有其他修饰符(比如ref或者out)

        <6>第一个参数不能是指针类型

      (2)注意事项

        <1>跟前面提到的几个特性一样,扩展方法只会增加编译器的工作,不会影响性能(用继承的方式为一个类型增加特性反而会影响性能)

        <2>如果原来的类中有一个方法,跟你的扩展方法一样(至少用起来是一样),那么你的扩展方法奖不会被调用,编译器也不会提示你

        <3>扩展方法太强大了,会影响架构、模式、可读性等等等等....

 

迭代器

我们每次针对集合类型编写foreach代码块,都是在使用迭代器

      这些集合类型都实现了IEnumerable接口

      都有一个GetEnumerator方法

      但对于数组类型就不是这样

      编译器把针对数组类型的foreach代码块

      替换成了for代码块。

      来看看List的类型签名:    

      public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

      IEnumerable接口,只定义了一个方法就是:    

      IEnumerator<T> GetEnumerator();

    (2)迭代器的优点:

      假设我们需要遍历一个庞大的集合

      只要集合中的某一个元素满足条件

      就完成了任务

      你认为需要把这个庞大的集合全部加载到内存中来吗?

      当然不用(C#3.0之后就不用了)!

      来看看这段代码:      

        static IEnumerable<int> GetIterator()        {            Console.WriteLine("迭代器返回了1");            yield return 1;            Console.WriteLine("迭代器返回了2");            yield return 2;            Console.WriteLine("迭代器返回了3");            yield return 3;        }

      消费这个函数的代码如下:      

            foreach (var i in GetIterator())            {                if (i == 2)                {                    break;                }                Console.WriteLine(i);            }            Console.ReadKey();

      输出结果为:      

      迭代器返回了1      1      迭代器返回了2

      大家可以看到:

      当迭代器返回2之后,foreach就退出了

      并没有输出“迭代器返回了3”

      也就是说下面的工作没有做。

    (3)yield 关键字

      MSDN中的解释如下:

      在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。

      也就是说,我们可以在生成迭代器的时候,来确定什么时候终结迭代逻辑

      上面的代码可以改成如下形式:      

          static IEnumerable<int> GetIterator()          {              Console.WriteLine("迭代器返回了1");              yield return 1;              Console.WriteLine("迭代器返回了2");              yield break;              Console.WriteLine("迭代器返回了3");              yield return 3;          }

     (4)注意事项

      <1>做foreach循环时多考虑线程安全性      

        在foreach时不要试图对被遍历的集合进行remove和add等操作

        任何集合,即使被标记为线程安全的,在foreach的时候,增加项和移除项的操作都会导致异常

        (我在这里犯过错)

      <2>IEnumerable接口是LINQ特性的核心接口

        只有实现了IEnumerable接口的集合

        才能执行相关的LINQ操作,比如select,where等

        这些操作,我们接下来会讲到。

 

LINQ

  1.查询操作符

    (1)源起

      .net的设计者在类库中定义了一系列的扩展方法

      来方便用户操作集合对象

      这些扩展方法构成了LINQ的查询操作符

    (2)使用

      这一系列的扩展方法,比如:

      Where,Max,Select,Sum,Any,Average,All,Concat等

      都是针对IEnumerable的对象进行扩展的

      也就是说,只要实现了IEnumerable接口,就可以使用这些扩展方法

      来看看这段代码:      

            List<int> arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };            var result = arr.Where(a => { return a > 3; }).Sum();            Console.WriteLine(result);            Console.ReadKey();

      这段代码中,用到了两个扩展方法。

      <1>

        Where扩展方法,需要传入一个Func<int,bool>类型的泛型委托

        这个泛型委托,需要一个int类型的输入参数和一个布尔类型的返回值

        我们直接把a => { return a > 3; }这个lambda表达式传递给了Where方法

        a就是int类型的输入参数,返回a是否大于3的结果。

      <2>

        Sum扩展方法计算了Where扩展方法返回的集合的和。

    (3)好处

      上面的代码中

      arr.Where(a => { return a > 3; }).Sum();

      这一句完全可以写成如下代码:

      (from v in arr where v > 3 select v).Sum();

      而且两句代码的执行细节是完全一样的

      大家可以看到,第二句代码更符合语义,更容易读懂

      第二句代码中的where,就是我们要说的查询操作符。

    (4)标准查询操作符说明

      <1>过滤

        Where

        用法:arr.Where(a => { return a > 3; })

        说明:找到集合中满足指定条件的元素

        OfType

        用法:arr.OfType<int>()

        说明:根据指定类型,筛选集合中的元素

      <2>投影

        Select

        用法:arr.Select<int, string>(a => a.ToString());

        说明:将集合中的每个元素投影的新集合中。上例中:新集合是一个IEnumerable<String>的集合

        SelectMany

        用法:arr.SelectMany<int, string>(a => { return new List<string>() { "a", a.ToString() }; });

        说明:将序列的每个元素投影到一个序列中,最终把所有的序列合并

      <3>还有很多查询操作符,请翻MSDN,以后有时间我将另起一篇文章把这些操作符写全。      

  2.查询表达式

    (1)源起

      上面我们已经提到,使用查询操作符表示的扩张方法来操作集合

      虽然已经很方便了,但在可读性和代码的语义来考虑,仍有不足

      于是就产生了查询表达式的写法。

      虽然这很像SQL语句,但他们却有着本质的不同。

    (2)用法

      from v in arr where v > 3 select v

      这就是一个非常简单的查询表达式

    (3)说明:

      先看一段伪代码:      

      from [type] id in source      [join [type] id in source on expr equals expr [into subGroup]]      [from [type] id in source | let id = expr | where condition]      [orderby ordering,ordering,ordering...]      select expr | group expr by key      [into id query]

      <1>第一行的解释:

        type是可选的,

        id是集合中的一项,

        source是一个集合,

        如果集合中的类型与type指定的类型不同则导致强制转化

      <2>第二行的解释:        

        一个查询表达式中可以有0个或多个join子句,

        这里的source可以不等于第一句中的source

        expr可以是一个表达式

        [into subGroup] subGroup是一个中间变量,

        它继承自IGrouping,代表一个分组,也就是说“一对多”里的“多”

        可以通过这个变量得到这一组包含的对象个数,以及这一组对象的键

        比如:        

        from c in db.Customers            join o in db.Orders on c.CustomerID            equals o.CustomerID into orders            select new            {                c.ContactName,                OrderCount = orders.Count()            };

      <3>第三行的解释:     

        一个查询表达式中可以有1个或多个from子句

        一个查询表达式中可以有0个或多个let子句,let子句可以创建一个临时变量

        比如:        

            from u in users             let number = Int32.Parse(u.Username.Substring(u.Username.Length - 1))             where u.ID < 9 && number % 2 == 0             select u

        一个查询表达式中可以有0个或多个where子句,where子句可以指定查询条件

      <4>第四行的解释:

        一个查询表达式可以有0个或多个排序方式

        每个排序方式以逗号分割

      <5>第五行的解释:

        一个查询表达式必须以select或者group by结束

        select后跟要检索的内容

        group by 是对检索的内容进行分组

        比如:        

            from p in db.Products              group p by p.CategoryID into g              select new {  g.Key, NumProducts = g.Count()}; 

      <6>第六行的解释:

        最后一个into子句起到的作用是

        将前面语句的结果作为后面语句操作的数据源

        比如:        

            from p in db.Employees             select new             {                 LastName = p.LastName,                 TitleOfCourtesy = p.TitleOfCourtesy             } into EmployeesList             orderby EmployeesList.TitleOfCourtesy ascending             select EmployeesList;

 

一些概念的随笔(转)