观看视频后的笔记

泛型

2.0 泛型的好处和原理
泛型：解决代码重用，满足不同类型的参数 可以用相同的方法，接口，或者类
          调用的时候 不需要声明类型，由编译器推断出来
          但是 类型参数和参数必须匹配 

泛型的思想 就是延迟声明
延迟声明：把参数类型的声明推迟到调用的时候声明
架构设计有一句话： 延迟 ，推迟一切可以推迟的东西

System.Collections.Generic.List`1[System.Int32]
___ ` 表示 占位符， 有几个类型参数 就显示几

IL：中间语言

{}叫做code block，代码块。
代码块的作用有两个，一个是作为界符，比如一个if包含多个语句，那么如果没有{}，就不知道if内执行的语句和if后执行的语句怎么区分
另一个是控制变量作用域

泛型约束，基类约束：
1 在泛型方法内可以直接使用基类的属性和方法
2 调用的时候，只能传递基类或者基类的子类

泛型约束 目标 就是 让上边调用者 更少的犯错

in 逆变，out 协变 只存在泛型接口或者泛型委托中  作用 扩展泛型的使用
out 协变 只能是返回结果 用于父类可以实例子类
in  逆变 只能是参数 用于子类可以实例父类

反射

原理：ado.net提供的帮助类库，可以读取我们编译生成的metadata（元数据）里面的信息

作用一：通过配置文件App.config+简单工厂，可以把项目变成可配置的，可扩展

操作

引用命名空间 using System.Reflection;

//1 动态加载  默认加载当前路径的dll文件，不需要后缀

Assembly assembly = Assembly.Load("Ruanmou.DB.Sqlserver");

//2 获取类型 （获取类型信息的方式不止一个）

Type typeDBHelper = assembly.GetType("Ruanmou.DB.Sqlserver.DBHelper");

//3 创建对象

object oDBHelper = Activator.CreateInstance(typeDBHelper);

　　

简单工厂

原理：把创建对象的代码转移到另一个类，好处就是逻辑独立

案例

  public class SimpleFactory
    {        //IDBHelper 配置文件里面的key
        private static string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelper"];

        public static IDBHelper CreateDBHelper()
        {
            string dllName = IDBHelperConfig.Split(',')[1];
            string className = IDBHelperConfig.Split(',')[0];

            Assembly assembly = Assembly.Load(dllName);
            Type type = assembly.GetType(className);
            object oObject = Activator.CreateInstance(type);
            return (IDBHelper)oObject;

        }
    }

　　

 委托和Lambda

 委托是一种类型

委托的声明

public delegate void NoReturnNoPara();//无参

public delegate void NoReturnNoPara(int id,string str);//有参

 不影响到我们编译 不需要升级运行环境 由编译器提供（转中间语言）的快捷方式叫语法糖

 如果是调用当前实例方法用this识别

 lambda表达式：是一个匿名方法，是一个方法
                          左边是参数    中间=>（goes to）  右边是方法体   C#3.0

 {
    NoReturnWithPara method = new NoReturnWithPara(
             (int id, string name) =>//goes to
                 //lambda表达式：本质是一个匿名方法，是一个方法
                 {
                     Console.WriteLine(nameOut);
                     Console.WriteLine("{0} {1} DoNothing");
                  });
      method.Invoke(4, "Nine");
 }

 {
     NoReturnWithPara method = new NoReturnWithPara(
                 (id, name) =>
                   //去掉参数类型，原因是委托的约束
                   {
                     Console.WriteLine("{0} {1} DoNothing");
                    });
     method.Invoke(5, "小昶");
}

 {
     //如果方法体只有一行，那么可以去掉大括号和分号,多行不行
     //如果参数只有一个  可以去掉小括号
     //如果没有参数，直接用小括号

     NoReturnWithPara method = new NoReturnWithPara((id, name) => Console.WriteLine("{0} {1} DoNothing", id, name));
     method.Invoke(6, "梦醒时分");
}　　

//匿名类
 var model = new
  {
    Id = 1,
    Name = "Alpha Go",
    Age = 21,
    ClassId = 2
  };  匿名类 只读 不能修改

扩展方法:静态类 静态方法  第一个参数类型前面加上this

 可以将 ExtendShow.ToInt(ivalue);换成 ivalue.ToInt() 

    定义的类

 public static class ExtendShow
    {
        public static int ToInt(this int? iParameter)
        {
            return iParameter ?? 0;
        }

        public static void NoShow(this LambdaShow show)
        {
            Console.WriteLine("这里是扩展的 NoShow");
        }
}

　　调用

{
          int? ivalue = null;
          int? ivalue2 = 1;

          int i = ExtendShow.ToInt(ivalue);
          int i2 = ivalue.ToInt();
 
}

sql添加数据后，返回新增的ID，两种方式

1：insert ；select @@identity

2：insert into [{0}] output insertd.id values({1})

封装 继承 多态

“面向对象的方法主要是把事物给对象化，

包括其属性和行为。

面向对象编程更贴近实际生活的思想。

总体来说面向对象的底层还是面向过程，

面向过程抽象成类，

然后封装，方便使用就是面向对象，（万物皆对象）。”

封装：隐藏对象的属性和实现的细节，仅对外提供公开字段，公共方法

好处：防止对外错误的修改 重用性更高 

继承：好处（代码的重用）一个类只能有一个父类，继承之后可以拥有父类的属性和一切行为，好的坏的都得要

多态：多个类可以继承自同一个类。

注意：子类中如果重写了父类的方法(多态)，那么父类中的这个方法将不会再调用。

抽象类

 抽象类是一个类，里面可以包含一切类可以包含的
 抽象成员 必须包含在抽象类里面，抽象类还可以包含普通成员
 继承抽象类后，必须显示的override其抽象成员
 抽象类不能直接实例化，声明的对象只能使用抽象类里的方法，不能用子类新增的方法
 父类只有一个
 is a

 抽象方法一定要写在抽象类中

 public abstract class BasePhone

{

  public abstract string Brand();

}

接口

接口不是类，里面可以包含属性、方法、事件 不能包含字段，委托，不能用访问修饰符（因为默认都是public）
接口只能包含没有实现的方法
实现接口的话，必须实现全部方法
接口不能直接实例化，声明的对象只能使用接口里的方法，不能用子类新增的方法
接口可以实现多个
can do 

接口叫实现，抽象类叫继承

接口不需要override关键字，抽象类需要override

抽象类/类就是用来描述是个什么东西

模板化，减少一定代码量

接口就是用来表示我们能做什么，能干什么

功能化，增加一定灵活性

 "抽象类是对象的抽象，然接口是一种行为规范"。

virtual ：虚方法

/// <summary>
/// virtual  虚方法  必须包含实现 但是可以被重载
/// </summary>
public virtual void VirtualMethod()
{
   Console.WriteLine("ParentClass VirtualMethod");
}

调用对象原则和就近原则

普通方法是由编译时决定的
虚方法是由运行时决定的 

重载 方法名一样，参数个数不一样，参数类型不一样，返回值类型可以不相同，编译时多态

重写（override），方法名的相同，相同的参数 ，相同的返回值类型，只有虚方法和抽象方法才能被覆（重）写，运行时多态

sealed 密封之后不能在被override

public sealed override void AbstractMethod()
{
   Console.WriteLine("ChildClass AbstractMethod");
}

委托（二）和事件

委托是一种类型，可以放在类外和里面。

继承了一个特殊类（MulticastDelegate，多步委托），不能被任何类继承，由编译器和其他工具派生

C#中的多线程都是基于委托的

委托  把方法包裹成了一个变量  等我们需要的时候再去执行它

//方法放到委托内
//2 委托的实例化 
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
method.Invoke();//3 委托的调用
method();
//方法
private void DoNothing()
{
     Console.WriteLine("This is DoNothing");
}

 +=就是发生这个事件的来同时要通知你，-=就是发生这个事件不再来通知你了。

事件是一个特殊的委托

cat.MiaoAction += new Stealer().Hide;
cat.MiaoAction -= new Stealer().Hide;

 设计时用外键，创建数据库取消，程序保证外键关系

 一定要用外键的话，常用的有支付和流水

SOA 面向服务架构  减低成本 

OOP 面向对象  （属性和行为）。

AOP 面向切面

POP 面向过程编程

SOAP 

Remote/{*pathInfo} ：路由器中  {*pathInfo}  表示所有路径

读写分离：

二八原则：20%写，80%读

 NoSql：非关类型系数据库 

autosave 自动把数据保存硬盘

C#----语言

.net Framework -----平台

包含

BCL 基础类库

CLR：公共语言运行库

编程工具

asp.net ----框架 

又分：asp.net web from 和  asp.net MVC

C#满足.net Framework 约束

JIT 即时编译器，机器玛

序列化就是把数据转成字符串

反序列化就说把数据转成对象