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>扩展方法太强大了,会影响架构、模式、可读性等等等等....

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。