c#初体验

虚方法、抽象类、接口区别：虚方法：父类可能需要实例化，父类方法需要方法体，可以找到一个父类
抽象类：抽象方法，父类不能实例化，且父类方法不能实现方法体，不可以找出一个父类，需要抽象
接口：多继承
length:是指所有维度的长度
count：是指一维的长度
字符串具有不可变性，虽然是引用类型，但分配的是两个空间
字典和hashtable的区别是字典要指定键值对的类型
类的默认：internal  方法，属性，字段默认private

filestream的write是覆盖掉开头的长度，file stream是全部覆盖
c#方法（1）：成员访问修饰符   返回值    方法名称（参数）
{//方法的内容}
类的i为2，共享静态变量，类的实例中有副本故为1
Main中不能直接访问非静态变量static，可通过类的实例调用
在c#中不允许类的实例调用类的静态函数public static int i成员
方法（2）：
方法的参数传递机制 ：值参数value Parameter    引用参数Rference  Parameter    输出参数Output Parameter    

 类的构造1:
构造器的名称跟类型相同，构造器没有返回值即类型为void
局部变量必须初始化赋值，而类的成员变量无须
类被实例化得时候会自动执行构造器里面的内容
如果没有初始化类的成员变量，在类被实例化之后，类的成员变量会被清零即int 为0 string为空
类的构造2:
B继承A，类A如果有参数构造器就不会再自动生成无参构造器，故一般编程要写一个带参构造器都要有一个无参构造器
执行特定A的构造器可以用base
类的析构3:
类型转换
check
可能发生溢出cheched
uncheck
允许溢出unchecked
**************************************************
新
程序集就是项目

c#对大小写敏感
*****************************************************
1.命名空间

数组1

简化数组 int [] arr={1,2,3};

0代表逗号后面第一个变量，1代表逗号后面第二个变量

new一个外面类，然后调用类中的方法

数组2

命名空间
using System;
namespace CG
{
    class test
    {
        static void Main()
        {
            A.A1.PrintName a = new A.A1.PrintName();
            A.A2.PrintName b = new A.A2.PrintName();
            a.intro();
            b.intro();
            Console.ReadKey();
        }
    }
    namespace A
    {
        namespace A1
        {
            public class PrintName
            {
                public void intro()
                {
                    Console.WriteLine("my name is a1");
                }
            }

        }
        namespace A2
        {
            public class PrintName
            {
                public void intro()
                {
                    Console.WriteLine("my name is a2");
                }
            }
        }
    }
}

方法2

using System;
class Method
{
    public static void VMethod(int i = 0)
    {
        i++;
    }
    public static void RMethod(ref int i)
    {
        i++;
    }
    public static void OMethod(out int i)
    {
         i = 9;
        i++;
    }
    static void Main()
    {
        int i = 0;
        VMethod(i);
        Console.WriteLine("i="+i);
            int j=0;
        RMethod(ref j);
        Console.WriteLine("j=" + j);
        int k=0;
        OMethod(out k);
        Console.WriteLine("k=" + k);
        Console.ReadKey();
    }
}

使用out必须在方法内部将其初始化，使用ref必须在方法之前也就是main中声明
ref（传递地址，类似指针）和out效果一样
params可变数量关键字（后面常加数组）

using System;
class Method
{
    static int addi(params int[] values)
    {
        int sum = 0;
        foreach (int i in values)
            sum += i;
        return sum;
    }

    static void Main()
    {
        Console.WriteLine(addi(1,2,3));
        Console.ReadKey();
    }
}

数组相当于一个引用类型参数
C#的值类型包括：结构体（数值类型，bool型，用户定义的结构体），枚举，可空类型。

C#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串。

using System;
class test
{
    static void PrintfArr(int[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
        {
            arr[i] = i;
        }
    }
    static void Main()
    {
        int[] arr = { 100, 200, 300, 400 };
        PrintfArr(arr);

        foreach (int i in arr)
            Console.Write(i + ",");Console.ReadKey();

    }
}

string对象虽然是引用类型参数，但是它不可变，所以在方法里新建一个副本

字符：

{0,3}打印第一个字符，右对齐（空间为3）
C#中英文和中文占两个字节
类class

类的构造
类默认继承object类调用base函数

构造器没有返回值，构造器名称必须和类名相同，构造器是一种特殊的方法
类的实例化如果没有赋值给变量，默认int类为0，string类为空

using System;
class A
{
    public string s;
   public  int i;
}
class test
{
    static void Main()
    {
        A a = new A();
        Console.WriteLine("{0}:{1}", a.s, a.i);
        Console.ReadKey();
    }
}

this指的并不是类本身，而是类实例化以后产生的对象

using System;
class A
{   public int i;
    public string s;
    public A()
    {

    }
    public A(int i)
    {
        this.i = i;
    }
    public A(string s)
    {
        this.s= s;
    }
    public A(int i,string s)
    {
        this.i = i;
        this.s = s;
    }
}
class test
{
    static void Main()
    {
    A a=new A();
   Console.WriteLine(a.i);
    Console.WriteLine(a.s);
    A b = new A(1);
    Console.WriteLine(b.i);
    Console.WriteLine(b.s);
    A c = new A("s");
    Console.WriteLine(c.i);
    Console.WriteLine(c.s);
    A d = new A(1,"s");
    Console.WriteLine(d.i);
    Console.WriteLine(d.s);
    Console.ReadKey();
}
}

解决雍余
使用本无参构造器用this关键字

using System;
namespace CG
{
    class A
    {
        public A()
    {
        Console.WriteLine("22");
    }
}
    class B:A
    {
        public B()
    {
        Console.WriteLine("11");
    }
}
    class test
    {
    static void Main()
{

    B bb=new B();
        Console.ReadKey();
}
    }
}

类b继承类a，必须调用类A的无参构造器
要是类A有被加有参构造器，那么就不会自动生成无参构造器
要写带参构造器就一定要写无参构造器
using System;
namespace CG
{
    class A
    {
        public A()
        {
            Console.WriteLine("我是类A的无参构造器");
        }
    }
    class B : A
    {
        public B()
        {
            Console.WriteLine("我是类B的无参构造器");
        }
    }
    class test
    {
        static void Main()
        {
            B b = new B();
            Console.ReadKey();
        }
    }
}

using System;
namespace CG
{
    class A
    {
        public A()
        {
            Console.WriteLine("我是类A的无参构造器");
        }
        public A(int i)
        {
            Console.WriteLine("我是类A的有参构造器");
        }

    }
    class B : A
    {
        public B()
        {
            Console.WriteLine("我是类B的无参构造器");
        }
        public B(int i):base(i)
        {
            Console.WriteLine("我是类B的有参构造器");
        }
    }
    class test
    {
        static void Main()
        {
            B b = new B(4);
            Console.ReadKey();
        }
    }
}

在类B中使用指定的构造器使用base关键字
  对类A进行加载之前时，static静态类也被默认加载

实例化类的时候，static类只执行一次
类的析构：值类型在堆栈超出范围就被清理，而引用类型等待托管堆等待被清理
垃圾回收机制

using System;

class A
{
    public A()
    {
        Console.WriteLine("Creating A");
    }
    ~A()
    {
        Console.WriteLine("Destroying A");
    }
}
class test
{
    static void Main()
    {
        new A();
        GC.Collect();
    Console.ReadKey();
    }
}

new一个空A以后要等到应用程序被关闭才一起被释放掉
尽量不要用GC

托管资源自己的类永远等待垃圾回收机制的处理，而dispose（boolean disposing）的是 托管资源引用其他非托管资源的类

using System;
public class MyResourse : IDisposable
{
    private bool disposed = false;
    public void Dispose()
    {
        Dispose(true);
    }
    public void Close()
    {
        Dispose(true);
    }
    ~MyResourse()
    {
        Dispose(false);
    }

    private void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                Console.WriteLine("调用所引用对象的dispose（）方法");
            }
            Console.WriteLine("释放类本身所使用的非托管资源");
        }
        disposed = true;
        if (disposing)
        {
            GC.SuppressFinalize(this);
        }
    }
}
public class test
{
    static void Main()
    {
        MyResourse mr = new MyResourse();
        try
        { Console.WriteLine("调用mr释放资源"); }
        finally
        {
            mr.Dispose();
            Console.ReadKey();
        }
    }
}

简化操作using

类的修饰符

default默认  public公共的 private私有的  internal 内部的  protected保护的  protected  internal

2.把入口函数写在另外一个类里（程序集）

子类

程序集内

internal：当父类和子类在同一个程序集的时候可以访问父类的internal成员，而不在同一个程序集的时候不可以访问
而protecteded internal（父类和子类）在不同程序集也可以访问

类型转换

检查溢出

checked语句

using System;
class Fruit
{    

}
class Apple : Fruit
{
    public int i = 1;

}
class Conversions
{
    static void Main()
    {
        Fruit a = new Apple();
        Apple f = (Apple)a;

        Console.WriteLine(f.i);
        Console.ReadKey();

    }
}

属性（简化读取和设置）

value是隐藏参数

属性参数用=传进来，方法用（）传进来
using System;
class Person
{
    private string Name;
    public string name
    {
        get
        {
            return Name;
        }
        set
        {
            Name = value;
        }
    }
    class test
    {
        static void Main()
        {
            Person z = new Person();
            z.name="张三";
            Console.WriteLine(z.name);
            Console.ReadKey();
        }
    }
}

类的私有字段和属性命名相同在大小写敏感例如vb.net中会出现错误

记录访问修改次数

静态属性和静态字段只能通过类名来访问
 索引器（有参属性）

首先声明了一个arrclass类的数组
使用this关键字
public  string  this 【int index】
返回值是string  ，参数是int

using System;
class IndexClass
{
    private string [] name=new string [10];
    public string this[int index]
    {
        get { return name[index]; }
        set { name[index] = value; }
    }
}
class test
{
    static void Main()
    {
        IndexClass b = new IndexClass();
        b[0] = "张三";
        Console.WriteLine("b[0]="+b[0]);
        Console.ReadKey();
    }
}

索引器这里只需要new一个实例，而数组类需要new多个
（索引器事务索引值可以为其他）在
hashtable中加值是通过add方法（key，value）
通过值找键   dictionaryEnter寻找
Convert.ToInt32、int.Parse的区别
https://zhidao.baidu.com/question/298960445.html

using System;
using System.Collections;
class IndexClass
{
    private Hashtable name = new Hashtable();
    public string this[int index]
    {
        get { return name[index].ToString(); }
        set { name.Add(index, value); }
    }
    public int this[string  aname]
    {
        get
        {
            foreach (DictionaryEntry d in name)
            {
                if (d.Value.ToString() == aname)
                {
                    return Convert.ToInt32(d.Key);
                }
            }
            return -1;
        }
        set { name.Add(value, aname); }
    }
}
class test
{
    static void Main()
    {
        IndexClass b = new IndexClass();
        b[400] = "张三";
        Console.WriteLine(b["张三"]);
        Console.ReadKey();
    }
}

没有hashtable
using System;
class ArrClass
{
    private readonly string name;
    public ArrClass(string name)
    {
        this.name = name;

}
    public string Name
    {
        get{return name;}
    }

}
class Indexclass
{
    private string [] name= new string[10];
    public string this[int index]
    {
        get { return name[index];}
        set{name[index]=value;}
    }
}
class test
{
    static void Main()
    {
        ArrClass[] a=new ArrClass[10];
        a[0]=new ArrClass("张三");
         a[1]=new ArrClass("李四");
         a[2]=new ArrClass("王五");
        Console.WriteLine("0:"+a[0].Name);
         Console.WriteLine("1:"+a[1].Name);
         Console.WriteLine("2:"+a[2].Name);
         Console.WriteLine("2222222222222:");
           Indexclass b=new Indexclass ();
        b[0]="张三";
        b[1]="张三";
        b[2]="张三";
          Console.WriteLine("0:"+b[0]);
         Console.WriteLine("1:"+b[1]);
         Console.WriteLine("2:"+b[2]);
        Console.ReadKey();

    }
}

有：using System;
using System.Collections;
class IndexClass
{
    private Hashtable name = new Hashtable();
    public string this[int index]
    {
        get { return name[index].ToString(); }
         set{name.Add(index,value);}
    }
    public int this[string Name]
    {
        get
        {
            foreach (DictionaryEntry d in name)
            {
                if (d.Value.ToString() == Name)
                {
                    return Convert.ToInt32(d.Key);
                }
            }
            return 8;
        }
        set { name.Add(value, Name); }
    }

}
class test
{
    static void Main()
    {
        IndexClass b = new IndexClass();
        b[100]="张三";
        Console.WriteLine(b[100]);
        Console.WriteLine(b["张三"]);

        Console.ReadKey();
    }
}

using System;
using System.Collections;
class IndexClass
{
    private Hashtable name = new Hashtable();
    public string this[int index]
    {
        get { return name[index].ToString(); }
        set { name.Add(index, value); }
    }
    public int this[string  aname]
    {
        get
        {
            foreach (DictionaryEntry d in name)
            {
                if (d.Value.ToString() == aname)
                {
                    return Convert.ToInt32(d.Key);
                }
            }
            return -1;
        }
        set { name.Add(value, aname); }
    }
}
class test
{
    static void Main()
    {
        IndexClass b = new IndexClass();
        b[400] = "张三";
        Console.WriteLine(b["张三"]);
        Console.ReadKey();
    }
}

 属性的名字可以随便取，而索引器的名称必须是this
new的时候只能用类的实例名

C#中最小的单位是字节byte
委托

using System;
delegate void EatDelegate(string food);
class MyDelegate
{
    static void ZsEat(string food)
    {
        Console.WriteLine("张三吃"+food);
    }
    static void Main()
    {
        EatDelegate zs=new EatDelegate(ZsEat);
        zs("西瓜");
        Console.ReadKey();
    }
}

委托链不需要实例化

using System;
delegate void EatDelegate(string food);
class MyDelegate
{
   static void ZsEat(string food)
    {
        Console.WriteLine("张三吃"+food);
    }
   static void LiSi(string food)
   {
       Console.WriteLine("李四吃" + food);
   }
   static void WanWu(string food)
   {
       Console.WriteLine("王五吃" + food);
   }

    static void Main()
    {
        EatDelegate Zs = new EatDelegate(ZsEat);
        EatDelegate Ls = new EatDelegate(LiSi);
        EatDelegate Wu = new EatDelegate(WanWu);
        EatDelegate all;
        all = Zs + Ls + Wu;
        all("西瓜");
        Console.ReadKey();
    }
}

像这种只有几句话的委托方法，简化方法
直接把方法写在委托链里面
委托2

using System;
delegate void EatDelegate(string food);
class Man
{
    private string name;
    public Man(string name)
    {
        this.name = name;
    }
    public void eat(string food)
    {
        Console.WriteLine(name+"吃"+food);
    }
}
class Party
{
    static void eatTogther(string food, params EatDelegate[] values)
    {
        if (values == null)
        {
            Console.WriteLine("座谈会结束");
        }
        else
        {
            EatDelegate eatChain = null;
            foreach (EatDelegate ed in values)
                eatChain += ed;
            eatChain(food);
        }
    }
    static void Main()
    {
        Man ZS = new Man("张三");
        Man Ls = new Man("李四");
        Man Ww = new Man("王五");
        EatDelegate zs = new EatDelegate(ZS.eat);
        EatDelegate ls = new EatDelegate(Ls.eat);
        EatDelegate Wu = new EatDelegate(Ww.eat);

        eatTogther("西瓜",zs,ls, Wu);
        Console.ReadKey();
    }
}

事件

事件的委托标识符必须和方法一样（即上图中的Publish（）要和Receive一致）
事件的本质其实就是一个委托链

using System;
class Publisher
{
    public delegate void Publish();
    public event Publish OnPublish;
    public void issue()
    {
        if (OnPublish != null)
        {
            Console.WriteLine("发行刊物");
            OnPublish();
        }
    }
}
class Subscriber
{
    public void Receive()
    {
        Console.WriteLine("订阅者已经收到了刊物");
    }
}
class Story
{
    static void Main()
    {
        Publisher Pub = new Publisher();
        Subscriber zs = new Subscriber();
        Pub.OnPublish += new Publisher.Publish(zs.Receive );
        Pub.issue();
        Console.ReadKey();
    }
}

using System;
class Publisher  //出版社
{
    public delegate void Publish();//声明事件所需的代理
    public event Publish OnPublish;//事件的声明
    public void issue()//触发事件的方法
    {
        if (OnPublish != null)
        {
            Console.WriteLine("发行刊物");
            OnPublish();
        }
    }
}
class Subscriber//订阅者
{
    public void Receive()//定义事件处理程序
    {
        Console.WriteLine("收到！！！");
    }

}
class Story
{
    static void Main()
    {
        Publisher Pub = new Publisher();
        Subscriber zs = new Subscriber();
        Pub.OnPublish += new Publisher.Publish(zs.Receive);
        Pub.issue();
        Console.ReadKey();

    }
}

事件2

事件拥有返回值也就失去了它的意义，所以事件的委托定义类型为void

方法2还没看懂
虚方法

多态

virtual虚方法   用override重写
当我们用override重写B中的F方法后，就算A.F也是重写后的B.F

using System;
class Employee
{
    protected string Name;
    public Employee() { }
    public Employee(string name)
    {
        Name = name;
    }
    public virtual void StartWork()
    {
        Console.Write(Name+"开始工作");
    }
}
class Manager : Employee
{
    public Manager(string name) : base(name) { }
        public override void StartWork()
        {
            Console.WriteLine(Name + "给员工下达任务");
        }
}
class test
{
    static void Main()
    {
        Employee [] emp=new Employee[2];
        emp[0] = new Employee("张三");
        emp[1] = new Manager("李四");
        foreach (Employee ed in emp)
            ed.StartWork();
        Console.ReadKey();
    }
}

抽象类

抽象类的子类必须实现父类的抽象方法，除非子类也是抽象类，要声明抽象方法，必须使用抽象类，抽象方法不能被声明为私有的

抽象类的抽象属性和方法一样没有方法主体但子类必须实现

using System;
abstract class A
{
    public abstract void F();
    protected int _x;
    public abstract int x
    {
        get;
        set;
    }}
    class B : A
    {
        public override void F()
        { }
        public override int x
        {
            get { return _x; }
            set { _x = value; }
        }

    }

class test
{
    static void Main()
    {
        B b=new B();
        b.x=4;
        Console.WriteLine(b.x);
        Console.ReadKey();
    }
}

如果子类的用途差不多使用虚方法（包装在基类里），如果子类的用途差异大，则使用抽象方法

接口interface （接口可以理解为一种特殊的抽象类）
在接口内的方法没有主体，一个类如果继承了一个方法，那么必然实现接口内的方法

在接口内声明的方法没有方法的主体，以()结束

using System;
interface DriverLicence
{
    void GetLincence();
}
class Teacher : DriverLicence
{
    public void GetLincence()
    {
        Console.WriteLine("获得驾驶执照");

    }

}
class test
{
    static void Main()
    {
        Teacher zs = new Teacher();
        zs.GetLincence();
        Console.ReadKey();

    }
}

c#中接口命名必须使用大写I开头

using System;
interface IDriverLicenceB
{
    void GetLincence();
}
interface IDriverLicenceA : IDriverLicenceB
{
     new void GetLincence();
}
class Student : IDriverLicenceB
{
    public void GetLincence()
    {
        Console.WriteLine("获得驾驶执照");

    }

}
class Teacher : IDriverLicenceA
{
    public void GetLincence()
    {
        Console.WriteLine("获得驾驶执照");

    }

}
class test
{
    static void DriveCar(string name, IDriverLicenceB o)
    {
        IDriverLicenceB dl = o as IDriverLicenceB;//强制类型转换成接口
        if (dl != null)
        {
            Console.WriteLine(name + "开动了卡车");
        }
        else
        {
            Console.WriteLine("没有驾照，不能开车");
        }
    }
    static void DriveBus(string name, IDriverLicenceB o)
    {
        IDriverLicenceA dl = o as IDriverLicenceA;//强制类型转换成接口
        if (dl != null)
        {
            Console.WriteLine(name + "开动了客车");
        }
        else
        {
            Console.WriteLine("没有驾照，不能开车");
        }
    }
    static void Main()
    {
        Teacher t = new Teacher();

        DriveCar("教师", t);
        DriveBus("教师", t);
        Student s = new Student();

        DriveCar("学生", s);
        DriveBus("学生", s);
        Console.ReadKey();

    }
}

为什么使用接口https://blog.csdn.net/alincea/article/details/83503455
方案：调用B接口中GetLincence
1.启用不同名字，但是必须实现这个接口的所有基接口方法
2.

接口完全限定名即在实现方法前面加上接口的名字

完全限定不能通过类名来访问
 对类来说是私有的，对接口来说是公有的

接口的多态

接口的多重继承中比较重要的原则：如果B隐藏重写了A中的F（）方法，那么任何路径都不能从IBC通往A中的F（）方法

访问的是c中的F方法

IComparable接口

对象使用Sort必须实现IComparable接口
为什么使用is不使用as：判断用is，使用用as

_name.CompareTo是string内部的方法
 类型（type）
对象就是类的实例

什么时候使用值类型：（结构体）

装箱与拆箱，就是值类型与引用类型的转换
值类型在栈上，  引用类型在堆上操作

 不能直接转换成不是装箱前的类型，要间接

注：Console.WriteLine()中应用了string.Concat(object,object,object)这三个参数都会转换成object类型
3次装箱（int转object），1次拆箱（object转int(int是值类型)）
简化：输出o可以不用装箱
使用.ToString转变成字符串类型，即应用类型，又节省了一次装箱

这里的i并不用进行装箱

执行了装箱操作
gettype()执行了object中的gettype方法所以要进行装箱操作，若值类型使用tostring（自己也有）则没有进行装箱操作
arraylist.add方法传的参数是object类型的，如果使用值类型参数传进去，则要进行装箱操作

雍余，把结构体装进arraylist里面还有诡异的事情，改进：
perpson找不到

改进

数组里面可以放值类型也可以放引用类型，无需进行装箱和拆箱操作
改进

泛型的使用

T代表类型

c#加深学习
委托
using System;
namespace teat
{
    class Program
    {
        public delegate double daili(double Value);
        public class JiSuan
        {
            public static double Shen2(double value)
            {
                return value * 2;
            }
            public static double XiaoShen(double value)
            {
                return value * value;
            }
            public static double demol(daili temp,double value)
            {
                double a = temp(value);
                return a;

            }
        }
        static void Main(string[] args)
        {
            daili daili1 = new daili(JiSuan.XiaoShen);
            daili daili2 = JiSuan.Shen2;
            Console.WriteLine(JiSuan.demol(daili1,3));
            Console.WriteLine(JiSuan.demol(daili2, 3));
            Console.ReadKey();
        }
    }
}

委托的改进
using System;
namespace teat
{
    class Program
    {
        public delegate double daili(double Value);
        public class JiSuan
        {
            public static double Shen2(double value)
            {
                return value * 2;
            }
            public static double XiaoShen(double value)
            {
                return value * value;
            }
            public static double demol(daili temp,double value)
            {
                double a = temp(value);
                return a;

            }
            public static double demo2(Func<double, double> temp2, double value)//改进
            {
                return temp2(value);
            }
        }
        static void Main(string[] args)
        {
            daili daili1 = new daili(JiSuan.XiaoShen);
            daili daili2 = JiSuan.Shen2;
            Console.WriteLine(JiSuan.demol(daili1,3));
            Console.WriteLine(JiSuan.demol(daili2, 3));
            Console.WriteLine(JiSuan.demo2(JiSuan.XiaoShen,3));
            Console.ReadKey();
        }
    }
}

lambda表达式
using System;
namespace lambda表达式
{
    class Program
    {
        static void Main()
        {
            Func<double, double, double> temp = (double a, double b) => a * b;
            Console.WriteLine(temp(2,5));
            Console.ReadKey();
        }
    }
}

拓展方法例子
using System;
namespace 拓展方法例子
{
    class Program
    {
        static void Main()
        {
            string t = "ceshi";
            Console.WriteLine(t.tuozhan("我是参数"));
            Console.ReadKey();
        }
    }
    public static class Stu
    {
        public static string tuozhan(this string a, string para)
        {
            return a + "为string类型进行拓展" + para;
        }
    }
}

例外，以下是几个例外的运算符：
①那些返回单个元素或者返回一个数值的运算符，如First或者Count。
②转换运算符：ToArray、ToList、ToDictionary、ToLookUp等等ToXXX方法。
以上这些运算符都会触发LINQ语句立即执行，因为他们的返回值类型不支持延迟加载。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Linq延迟状态终止
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> arr = new List<string>() { "abc", "bcd", "eff" };
            var linq = (from r in arr where r.StartsWith("b") select r).ToList();//使用了ToList方法已经终止linq的延时,把结果存在linq变量里面去了
            Console.WriteLine("one");
            foreach (string t in linq)
            {
                Console.WriteLine(t);
            }

            arr.AddRange(new string[] { "bbb", "b2" });//这时尽管添加元素,但是之前已经使用ToList方法,不会影响Linq变量的结果了
            Console.WriteLine("two");
            foreach (string t in linq)
            {
                Console.WriteLine(t);
            }

            Console.ReadKey();
        }
    }
}

作业
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class A  //个人信息
{
    public A(String Name) { name = Name; }
    public string name { get; set; }
    public int age { get; set; }
    public string school { get; set; }
    public List<FamilyPerson> family { get; set; }
}
public class FamilyPerson//家庭成员信息
{

    public String name { get; set; }
    public String relation { get; set; }
    public int Age { get; set; }
    public String place { get; set; }
    public String department { get; set; }
}
class test
{
    static void Main()
    {
        List<FamilyPerson> family = new List<FamilyPerson>();
        //第一个人
        A zhangsan = new A("张三");
        zhangsan.school = "中大";
        zhangsan.age = 23;
        FamilyPerson zhangsan_dad = new FamilyPerson();
        zhangsan_dad.name = "张波";
        zhangsan_dad.relation = "爸爸";
        zhangsan_dad.Age = 46;
        zhangsan_dad.place = "腾讯";
        zhangsan_dad.department = "研发";
        FamilyPerson zhangsan_mom = new FamilyPerson();
        zhangsan_mom.name = "李娜";
        zhangsan_mom.relation = "妈妈";
        zhangsan_mom.Age = 44;
        zhangsan_mom.place = "百度";
        zhangsan_mom.department = "销售";
        FamilyPerson zhangsan_brothersmall = new FamilyPerson();
        zhangsan_brothersmall.name = "张锦";
        zhangsan_brothersmall.relation = "弟弟";
        zhangsan_brothersmall.Age = 21;
        zhangsan_brothersmall.place = "比亚迪";
        zhangsan_brothersmall.department = "售后";
        FamilyPerson zhangsan_brother = new FamilyPerson();
        zhangsan_brother.name = "张浩";
        zhangsan_brother.relation = "哥哥";
        zhangsan_brother.Age = 25;
        zhangsan_brother.place = "华为";
        zhangsan_brother.department = "销售";
        family.Add(zhangsan_dad);//加入
        family.Add(zhangsan_mom);
        family.Add(zhangsan_brothersmall);
        family.Add(zhangsan_brother);
        zhangsan.family = family;
        Console.Write("  姓名：" + zhangsan.name);
        Console.Write("  年龄：" + zhangsan.age);
        Console.WriteLine("  学校：" + zhangsan.school);
        Console.Write("  姓名：" + zhangsan_dad.name);
        Console.Write("  关系：" + zhangsan_dad.relation);
        Console.Write("  年龄：" + zhangsan_dad.Age);
        Console.Write("  单位：" + zhangsan_dad.place);
        Console.WriteLine("  部门：" + zhangsan_dad.department);
        Console.Write("  姓名：" + zhangsan_mom.name);
        Console.Write("  关系：" + zhangsan_mom.relation);
        Console.Write("  年龄：" + zhangsan_mom.Age);
        Console.Write("  单位：" + zhangsan_mom.place);
        Console.WriteLine("  部门：" + zhangsan_mom.department);
        Console.Write("  姓名：" + zhangsan_brothersmall.name);
        Console.Write("  关系：" + zhangsan_brothersmall.relation);
        Console.Write("  年龄：" + zhangsan_brothersmall.Age);
        Console.Write("  单位：" + zhangsan_brothersmall.place);
        Console.WriteLine("  部门：" + zhangsan_brothersmall.department);
        Console.Write("  姓名: " + zhangsan_brother.name);
        Console.Write("  关系：" + zhangsan_brother.relation);
        Console.Write("  年龄: " + zhangsan_brother.Age);
        Console.Write("  单位: " + zhangsan_brother.place);
        Console.WriteLine("  部门： " + zhangsan_brother.department);

        //第二个人
        A yansi = new A("严四");
        yansi.school = "中大";
        yansi.age = 23;
        FamilyPerson yansi_dad = new FamilyPerson();
        yansi_dad.name = "严波";
        yansi_dad.relation = "爸爸";
        yansi_dad.Age = 46;
        yansi_dad.place = "腾讯";
        yansi_dad.department = "研发";
        FamilyPerson yansi_mom = new FamilyPerson();
        yansi_mom.name = "刘娜";
        yansi_mom.relation = "妈妈";
        yansi_mom.Age = 44;
        yansi_mom.place = "百度";
        yansi_mom.department = "销售";
        Console.Write("  姓名：" + yansi.name);
        Console.Write("  年龄：" + yansi.age);
        Console.WriteLine("  学校：" + yansi.school);
        Console.Write("  姓名："+yansi_dad .name);
        Console.Write("  关系：" + yansi_dad.relation);
        Console.Write("  年龄：" + yansi_dad.Age);
        Console.Write("  单位：" + yansi_dad.place);
        Console.WriteLine("  部门：" + yansi_dad.department);
        Console.Write("  姓名：" + yansi_mom.name);
        Console.Write("  关系：" + yansi_mom.relation);
        Console.Write("  年龄：" + yansi_mom.Age);
        Console.Write("  单位：" + yansi_mom.place);
        Console.WriteLine("  部门：" + yansi_mom.department);

        //第三个人
        A liwu = new A("李五");
         liwu.name = "李五";
        liwu.school = "仲恺";
        liwu.age = 23;
        Console.Write("  姓名：" + liwu.name);
        Console.Write("  年龄：" + liwu.age);
        Console.WriteLine("  学校：" + liwu.school);
        FamilyPerson liwu_dad = new FamilyPerson();
        liwu_dad.name = "李波";
        liwu_dad.relation = "爸爸";
        liwu_dad.Age = 46;
        liwu_dad.place = "腾讯";
        liwu_dad.department = "研发";
        Console.Write("  姓名：" +liwu_dad.name);
        Console.Write("  关系：" + liwu_dad.relation);
        Console.Write("  年龄：" + liwu_dad.Age);
        Console.Write("  单位：" + liwu_dad.place);
        Console.WriteLine("  部门：" + liwu_dad.department);
       FamilyPerson liwu_mom = new FamilyPerson();
        liwu_mom.name = "陈娜";
        liwu_mom.relation = "妈妈";
        liwu_mom.Age = 44;
        liwu_mom.place = "百度";
        liwu_mom.department = "销售";
        Console.Write("  姓名：" + liwu_mom.name);
        Console.Write("  关系：" + liwu_mom.relation);
        Console.Write("  年龄：" + liwu_mom.Age);
        Console.Write("  单位：" + liwu_mom.place);
        Console.WriteLine("  部门：" + liwu_mom.department);
         FamilyPerson liqi_yeye= new FamilyPerson();
        liqi_yeye.name = "李祺";
        liqi_yeye.relation = "爷爷";
        liqi_yeye.Age = 66;
        liqi_yeye.place = "无";
        liqi_yeye.department = "无";
        Console.Write("  姓名：" + liqi_yeye.name);
        Console.Write("  关系：" + liqi_yeye.relation);
        Console.Write("  年龄：" + liqi_yeye.Age);
        Console.Write("  单位：" + liqi_yeye.place);
        Console.WriteLine("  部门：" + liqi_yeye.department);
        Console.ReadKey();
    }
}