MVC系列随笔二

-》Linq
1.隐式类型 var a=1;var b="哈哈";在不知道类型的状况下使用，IL会根据赋值类判断类型，不会影响效率。由于IL产生的中间同样。var 必须赋值。
2.匿名类型 var entity= new {title="我是匿名类型",fun="我颇有用"};
 把一个对象的属性copy到匿名对象中，不用显示指定属性的名字，原始的属性名字会被copy到匿名对象中。
 监视entity会发现它的类型就是Anonymous Type（匿名类型）
 不要试图在建立匿名对象的方法外面访问它的属性
 在特定的网站，序列化和反序列化JSON时有用
3.自动属性
4.对象初始化器 var obj=new Obj{id=GUID.NewGuid(),title="哈哈"}; var arr=List<int>(){1,2,3,4,5};
5.委托
6.泛型
   装箱：值类型转换为object类型; 拆箱：Object转换为值类型   装箱操做会致使性能损耗 泛型能解决这个问题
   Hashtable Queue Stack等非泛型容器会装箱，这些容器只能存储Object类型的数据
   List<T>、Dictionary<TKey,TValue>都是泛型

   自定义泛型
   public static class SomethingFactory<T>
   {
  public  static T InitInstance(T inObj)
  {
   if(false)
   {
    return  inObj;
   }
   return default(T);
  }
   }
   泛型约束：public static class SomethingFactory<T> where T:MyObj 只能传入MyObj类型或MyObj派生类
     或这样写：where T:MyObj,new()约束传入的类型必须有一个构造函数
 泛型的好处

　　　　　　<1>算法的重用

　　　　　　　　想一想看：list类型的排序算法，对全部类型的list集合都是有用的

　　　　　　<2>类型安全

　　　　　　<3>提高性能

　　　　　　　　没有类型转化了，一方面保证类型安全，另外一方面保证性能提高

　　　　　　<4>可读性更好
7.泛型委托
 委托基本归为3类：
 <1>Predicate泛型委托
 var d1=new Predicate<int>(More);
 定义：表示定义一组条件并肯定指定对象是否符合这些条件的方法
    obj 要按照由此委托表示的方法中定义的条件进行比较的对象
    T 要比较的对象的类型
    返回结果 若是obj 符合由此委托表示的方法中定义的条件，则为true;不然为false
    pubic delegate bool Predicate<in T>(T obj);
    缺点定义太死，必须有一个返回值，必须有一个参数
 <2>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
        　　　　}
 <3>Func泛型委托
 弥补Action泛型委托，不能返回值的不足，规定要有一个返回值，返回值的类型也由使用者肯定
 var d5=new Func<int,string>(oneParamOneReturnFunc);
 注意：string 类型(最后一个泛型类型)是方法的返回值类型
     static string oneParamOneReturnFunc(int a)
        　　　　{
            　　　　//do what you want
            　　　　return string.Empty;
        　　　　}
8.匿名方法
   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");
   　  <1>代码可读性更好

　　　　　　<2>能够访问当前上下文中的变量
9.扩展方法
   扩展方法是静态类中的静态方法
   public static class MyClass
   {
  public static void ExtString(this String val)
  {
   Console.WriteLine(val);
  }
   }
   var a="aaa";
   a.ExtString();
   ----aaa----
      <1>扩展方法必须在一个非嵌套、非泛型的静态类中定义

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

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

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

　　　　　　　　<5>第一个参数不能有其余修饰符（好比ref或者out）

　　　　　　　　<6>第一个参数不能是指针类型
      注意事项

　　　　　　　　<1>跟前面提到的几个特性同样，扩展方法只会增长编译器的工做，不会影响性能（用继承的方式为一个类型增长特性反而会影响性能）

　　　　　　　　<2>若是原来的类中有一个方法，跟你的扩展方法同样（至少用起来是同样），那么你的扩展方法奖不会被调用，编译器也不会提示你

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