C#中的特殊数据类型

一、c#中的特殊数据类型

C#中特殊数据类型有class类型、结构类型、数组类型、枚举类型、集合类型、委托类型、事件、Lambda表达式、接口类型。

1、class类型

1.1类定义

class Student : person//继承
{
    //默认构造函数，vs IDE中输入ator+tab两下可自动生成构造函数代码段
    public Student()
    {
        //给字段赋值等初始化操作
    }
    //自定义构造函数，b为可选参数
    public Student(int a, string b = 5)
    {
        //初始化操作
    }
    public Student(int a)//自定义构造函数
    {
        //初始化操作
    }
    //静态构造函数-安全的给静态字段赋值且只能被定义一个（采用普通构造函数每次实例化类对象时静态字段的值会被重置）
    static Student{aCuu=0.04}//不允许访问修饰符，不接受参数

//static关键字用来定义静态成员，这些成员只能通过类级别而不是对象引用调用。
//static关键字，静态字段由所有类实例共享
public static double aCuu = 0.04;
public string petName;//字段，最好定义成私有的以保护
public void Name(string name) { }---方法
 
 }
 
 //静态类-只包含静态成员，不能够使用new(分配新内存)关键字来创建类对象-适合做工具类
 static class Student { }

1.2访问修饰符

类型成员隐式私有的，而类是隐式内部的。

private、protected、protected internal访问修饰符可以应用到嵌套类型上，非嵌套类型只能用public internal修饰符定义。

public	可以从对象、派生类、外部其它程序集访问
private	定义类访问
protected	定义类及子类可以访问，外部类无法通过点操作符访问
internal	只能在当前程序集中访问
protected internal	在定义该项的程序集、类及派生类中可用

1.3 this 关键字

提供对当前类实例的访问。

串联构造函数，使类更容易维护和简明。

    class Motorcycle
    {
        public int driverIntensity;
        public string drivername;
        //构造函数
        public Motorcycle(){}
        public Motorcycle(int intensity) : this(intensity, "") { }            
        public Motorcycle(string name):this(0,name) { }
        //所有工作的主构造函数
        public Motorcycle(int intensity,string name)
        { 
            //操作
        }
    }

2、结构类型

结构类型可以看成是轻量级的类类型，但是不能像类一样继承

  struct point 
  {
        //字段
        public int x;
        //方法
        public void Increment()
        {
        }  
    }

    //创建结构变量
    point p1;
    p1.x = 5;//需要为每一个共有字段成员赋值
            point p2 = new point();

3、数组类型

一组相同类型的数据点：int[] myInt=new int[3]

int[] myInt=new int[3]{1,2,3}  #初始化

3.1 特殊数组

隐式数组	var a=new[]{1,2,3}
object数组	object[] myob=new[3]{1,"string",new DateTime(2017,8,28)}
多维数组	int[,] myArray=new int[6,6]

4、枚举类型

System.Enum类中包含有一些对枚举类型操作的方法

 enum Emptype:Byte
    {
        manager=12,//=0,可任意，可不连续
        student,
        teancher
    }

    Emptype ee = Emptype.manager;
    Enum.GetUnderlyingType(ee.GetType());//返回枚举类型值的数据类型
            Console.WriteLine(ee.ToString());//获取枚举名字
            Console.WriteLine((Byte)ee);//根据底层类型强制转换获取其数值

            Array enumData = Enum.GetValues(ee.GetType());//获取所有枚举值
    Console.WriteLine("this enum has {0} nums:", enumData.Length);
            Console.WriteLine("name{0};value{1}", enumData.GetValue(1));

 5、集合类型-数据容器

System.Collections与System.Collection.Generic命名空间

　　简单数组通常是固定大小的，而集合类本身的尺寸是动态的，类似于python中的list类型，很多集合提供了更强的类型安全，进行了高度优化，可以以内存高效的方式处理所包含的数据。

　　集合可划分为两大种类：非泛型集合和泛型集合

5.1泛型集合System.Collections常用类

ArrrayList	动态大小对象集合，对象按顺序列出	Ilist/Icollection/IEnumerable/ICloneable
BitArray	管理位值的简单数组，位值bool类型	ICollection/IEnumerable/ICloneable
Hashtable	表示键值对的集合	IDictionary/Icollection/IEnumerable/ICloneable
Queue	FIFO队列	ICollection/IEnumerable/ICloneable
SortedList	键值对集合按键排序	IDictionary/Icollection/IEnumerable/ICloneable
Stack	后进先出	ICollection/IEnumerable/ICloneable

System.Collections中类所支持的关键接口

ICollection	为所有非泛型集合定义基本特性（大小、枚举、线程安全）
ICloneable	允许实现它的对象向调用者返回它的副本
IDictionary	非泛型集合使用键值对表示其内容
IEnumerable	返回实现了IEnumerable接口的对象
IEnumerator	允许子类型以foreach形式迭代
IList	为顺序列表中的对象提供添加、移除和索引项的行为

示例代码：

class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            //集合：很多数据的一个集合
            //数组：长度不可变、类型单一
            list.Add(true);
            list.Add(1);
            list.Add(2);
            list.Add("张三");
            Person person = new Person();
            list.Add(person);
            list.Add(new int[] { 1, 2, 3 });
            list.AddRange(list);
            list.AddRange(new int[] { 234, 23432 });//此种方法可以直接输出
            for(int i=0; i<list.Count; i++)
            {
                if(list[i] is Person )
                {
                    ((Person)list[i]).SayKello();
                }
                else if(list[i] is int[])
                {
                     for(int j=0;j<((int[])list[i]).Length;j++)
                    {
                        Console.WriteLine(((int[])list[i])[j]);
                    }
                }   //麻烦
                else
                {
                    Console.WriteLine(list[i]);
                }
                
            }
            Console.ReadKey();   
            //List元素打印出来的是所在类对应的命名空间
        }

        class Person
        {
            public void SayKello()
            {
                Console.Write("你好"+"
");
            }
        }

       
    }
//其他类的用法类似，有相应的文档

HashTable示例：

  static void Main(string[] args)
        {

            //键值对集合类似于字典，根据键去找值，就像根据拼音去找汉字
            Hashtable ht = new Hashtable();
            ht.Add(1,"张三");
            ht.Add(2,"小王");
            ht.Add(false,"错误的");
            for (int i = 0; i < ht.Count; i++)
            {
                object a = ht[i];
                Console.WriteLine(a);
            }
            //不能全部显示（0和false)
            Console.ReadKey();
            Console.WriteLine(ht[false]);

            //也可以采用foreach循环遍历
            foreach (var item in ht.Keys)   
            {
                //C#是一门强类型语言：代码中每一个变量类型必须有明确的定义
                //int n = 15;
                //string ste = "sfdd";
                //bool n5 = true;
                //double n6 = 230.23;
                //Console.WriteLine(n.GetType());
                //Console.WriteLine(ste.GetType());
                //Console.WriteLine(n5.GetType());
                //Console.WriteLine(n6.GetType());
                //Console.ReadKey();

                //根据值推断出类型
                //var n = 15;
                //var ste = "sfdd";
                //var n5 = true;
                //var n6 = 230.23;

                //Console.WriteLine(n.GetType());
                //Console.WriteLine(ste.GetType());
                //Console.WriteLine(n5.GetType());
                //Console.WriteLine(n6.GetType());
                //Console.ReadKey();
                //var input; 声明var变量的时候必需给它赋值
                //input = "人民";
                Console.WriteLine(ht[item]);
            }
            Console.ReadKey();


        }

5.2非泛型集合

　　相比较于泛型集合，非泛型集合更为常用，经典的泛型集合常常存在如下问题：

1)频繁的装箱拆箱操作，当数据量过大时会降低程序效率：

　　.NET包含一个特殊的Object类，可以接受任意的数据类型的值，当所传递或所赋值的类型不是一个特定的数据类型时，object类就提供了一种传递参数和赋值的通用方法。赋给object的值必须作为引用类型，并存放砸托管堆中，简言之装箱就是值类型转换为引用类型；拆箱就是引用类型转换为值类型。

　　值类型：包括原类型（Sbyte、Byte、Short、Ushort、Int、Uint、Long、Ulong、Char、Float、Double、Bool、Decimal）、枚举 (enum) 、结构 (struct)。

　　引用类型：包括类、数组、接口、委托、字符串等

　　一下特殊情况需要注意：

隐式转换总会成功的情况	显式引用转换可能会抛出异常的情况
从派生类到基类	从基类到派生类
从派生接口到基接口	从接口到接口（基接口到派生接口或者俩接口没有关系）
从类到接口（该类实现了接口）	从接口到类（该类实现了该接口或该类未封闭）
从Null到任何类	从类到接口（该类未实现该接口且该类未封闭）

 class Program
    {
        int a = 3;
        object ob = a;//装箱操作
        int b = (int)ob;//拆箱操作
    }

 2）类型安全问题，所有的类型都可以转换成object类，在特定的情况下存在类型安全问题。

 5.3泛型集合

只有类、结构、接口和委托可以使用泛型，枚举类型不可以。

1）System.Collection.Generic命名空间

 2)初始化语法

 class Point
        {
            int x;
            int y;
            public Point(int x, int y)
            {
                this.x = x;
                this.y = y;
            }

        }
class Program
    {
        static void Main(string[] args)
        {
            List<Point> myOfpoint = new List<Point>
            {
                new Point(1,2),
                new Point(3,4)
            };
        }
    }

3）List<T>类

常见用法见：http://www.cnblogs.com/AdaLoong/p/5528917.html

4）Stack<T>类---后进先出

包含Push和Pop方法，可以向栈中压入数据或弹出数据，在观察栈时得到的永远是栈顶对象，可以通过调用peek()来显示。

http://www.cnblogs.com/deom/p/5349317.html

5）Queue<T>类---先进先出

http://www.cnblogs.com/jiahuafu/archive/2013/01/05/2845640.html

Dequeue()---移除并返回开始出的对象；

Enqueue()---在末未添加一对象；

peek()---返回开始出的对象但是不移除。

6）SortedSet<T>类---自动排序

必须通知SortedSet<T>类按照何种方式排序，可以向其构造函数传递一个实现了IComparer<T>泛型接口的参数，比如一个实现了该泛型接口的类。

http://blog.sina.com.cn/s/blog_621e24e20100zqmq.html

class sortByage:IComparer<Person>
    {
        public int Compare(Person firstperson,Person secondperson)
        {
            if (firstperson.age > secondperson.age)
                return 1;
            if (firstperson.age < secondperson.age)
                return -1;
            else
                return 0;
        }
    }
 class Person
    {
        string firstname;
        string lastname;
        public int age;      
        public Person(string firstname,string lastname,int age)
        {
            this.firstname = firstname;
            this.lastname = lastname;
            this.age = age;
        }
    }
static void Main(string[] args)
        {
            SortedSet<Person> mysortedOfperson = new SortedSet<Person>(new sortByage())
            {
              new Person("wangming","zhang",112),
              new Person("xiaogang","wang",13),
              new Person("xiaohong","li",56)
            };
            //按照年龄排序
            foreach (Person p in mysortedOfperson)
            {
                Console.WriteLine(p.age);
            }
            Console.ReadKey();
        }

 7）System.Collections.ObjectModel命名空间

该命名空间也是以泛型为核心

两个比较有用的类

ObservableCollection<T>	表示能在添加、移除项或者刷新整个列表时提供通知的动态数据集合
ReadOnltObservableCollection<T>	表示ObservableCollection<T>的只读版本

　　ObservableCollection<T>与List<T>具有相同的核心接口，不同的是ObservableCollection<T>实现了名为CollectionChanged的事件，该事件在添加、移除项或者刷新整个列表时触发。

　　CollectionChanged定义为委托，该委托可以调用一类方法（第一个参数为object,第二个参数为NotifyCollectionChangedEventArgs）。

　　

class Program
    {
        static void Main(string[] args)
        {
            ObservableCollection<Person> mysortedOfperson = new ObservableCollection<Person>()
            {
              new Person("wangming","zhang",112),
              new Person("xiaogang","wang",13),
              new Person("xiaohong","li",56)
            };
            //按照年龄排序
            //绑定collentionchanged事件
            mysortedOfperson.CollectionChanged += people_collentionchanged;
            mysortedOfperson.Add(new Person("jfoda", "ad", 12));
            Console.ReadKey();
            
        }
        static void people_collentionchanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            //触发事件的行为是什么
            Console.WriteLine("Action for this event:{0}", e.Action);
            if(e.Action==System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                Console.WriteLine("here are the new item:");
                foreach (Person p in e.NewItems)
                {
                    Console.WriteLine(p.ToString());
                }
            }
        }

    }
    class Person
    {
        string firstname;
        string lastname;
        public int age;      
        public Person(string firstname,string lastname,int age)
        {
            this.firstname = firstname;
            this.lastname = lastname;
            this.age = age;
        }
    }

6、委托类型delegate

委托类型用来定义和响应应用程序中的回调，使用回调程序员可以使用一个函数返回报告给程序中的另一个函数，使用这种方法，windows开发者可以可以处理按钮单击、鼠标移动、菜单选择以及内存中两个实体的双向通信。本质上委托是个类型安全的对象，它指向一个以后会被调用的方法（或者多个方法），可以不用手工创建一个thread对象去条用其它thread上的方法，委托类型有三个重要的信息：

1）它所调用的方法和名称

2）该方法的参数（可选）

3）该方法的返回值类型（可选）

6.1、委托类型的定义

public delegate int BinaryOp(int x,int y)

使用delegate关键字，就间接创建了一个类，这个类是“MulticastDelegate”,下表显示了所有委托对象都有的核心成员。

例1：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 委托简例
{
    public delegate int BinaryOp(int x, int y);
    //创建一个包含委托指向方法的类
    public class SimpleMath
    {
        public int Add(int x, int y)
        {
            return x + y;
        }
    }
    class Program
    {
        //显示委托对象所维护的方法名称及对应的类名称
        static void DisplayDelegateInfo(Delegate delObj)
        {
            //输出委托调用列表中每个成员的名称
            foreach (Delegate d in delObj.GetInvocationList())
            {
                Console.WriteLine("Method name:{0}", d.Method);
                Console.WriteLine("Type name:{0}", d.Target);
            }
            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            //实例化一个委托对象
            BinaryOp bp = new BinaryOp(new SimpleMath().Add);//指向的是非静态方法要生成实例
            //BinaryOp bp = new BinaryOp(SimpleMath.Add);//指向的是静态方法则不需要，只需给出内存地址即可
            Console.WriteLine("10+10={0}", bp(10, 10));
            Console.ReadKey();
            DisplayDelegateInfo(bp);
        }
    }
}

例2

//声明委托
    public delegate void Mydel();
    public delegate void Mydel2(int num1, int num2);
    public delegate string Mydel3(string s);
    //声明委托用于演示匿名方法
    public delegate string ProcessString(string S);
    class Program
    {
        static void Main(string[] args)
        {          
            TestDel t = new TestDel();
            #region 简单实例化委托与调用委托
            Console.WriteLine("------以下是简单使用委托演示----");
            t.MyMethod();

            //实例化委托，用一个方法实例化
            //该方法签名要与委托签名一致
            Mydel del0 = new Mydel(t.MyMethod);
            //调用委托
            del0();
            //另一种实例化方法
            Mydel del1 = t.MyMethod;
            del1();

            //用静态方法进行实例化
            del1 = TestDel.MyStaticMethod;
            del1();
            //以下代码效果相同
            //类TestDel中重载了多种MyMethod方法，委托自动识别一致参数类型的方法
            Mydel2 del2 = new Mydel2(t.MyMethod);
            del2(10,20);
            Mydel2 del121 = t.MyMethod;
            del121(10, 20);
            Mydel3 del3 = new Mydel3(t.MyMethod);
            del3("adfa");
            #endregion

            #region 匿名实例化weit
            Console.WriteLine("-----以下是匿名调用委托--");
            //用匿名方法实例化委托，不需函数名，直接就是参数+函数体
            ProcessString p = delegate(string inputString)
              {
                  return inputString.ToUpper();
              };
             //通过委托调用匿名方法
            Console.WriteLine(p("wefewe"));
            #endregion
    
            #region 委托多播演示
            Console.WriteLine("---------以下是多播演示--------");
            Mydel mydel1 = t.MyMethod;
            Mydel mydel2 = t.MyMethod2;
            Mydel mydel3 = TestDel.MyMethod3;
            //委托类型必须一致才能相加
            Mydel allmydel = mydel1 + mydel2 + mydel3;
            allmydel();
            allmydel -= mydel3;
            allmydel();
            #endregion

            #region 委托作为参数演示
            Console.WriteLine("-------以下委托作为参数演示--------");
            Mydel3 paraMydel3 = t.MyMethod;
            TestDel.MyParamMethod("aaa", paraMydel3);
            #endregion


            #region 委托作为返回值
            Console.WriteLine("----以下委托作为返回值演示-----");
            //returnMydel指向ReturnMyMethod的返回值
            Mydel3 returnMydel = t.ReturnMyMethod();
            //returnMydel1指向t.MyMethod
            Mydel3 returnMydel1 = t.MyMethod;
            Console.WriteLine(returnMydel("sssssss"));
            #endregion          

        }

    }
    public class TestDel
    {
        #region 普通方法
        public static void MyStaticMethod()
        {
            Console.WriteLine("My Static Method");
        }
        public void MyMethod()
        {
            Console.WriteLine("MyMethod");
        }
        public void MyMethod2()
        {
            Console.WriteLine("My Method 22222222222");
        }
        public static void MyMethod3()
        {
            Console.WriteLine("My Method 3333333333333");
        }
        public void MyMethod(int num1, int num2)
        {
            Console.WriteLine(num1 + num2);
        }
        public string MyMethod(string s)
        {
            return s.ToUpper();
        }
        #endregion
        /// <summary>
        /// 委托作为方法参数
        /// </summary>
        /// <param name="s"></param>
        /// <param name="del3"></param>
        public static void MyParamMethod(string s, Mydel3 del3)
        {
            Console.WriteLine(del3(s));
        }
        /// <summary>
        /// 委托作为返回值
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public Mydel3 ReturnMyMethod()
        {
            ///返回符合委托规范的方法
            return MyMethod;
        }

    }

6.2使用委托发送对象通知状态

类似于通过回调函数返回状态信息

namespace 委托通知
{
    //使用委托来定义car类，他可以通知外部实体当前引擎状态
    /// <summary>
    /// （1）定义将通知发送给调用者的委托类型
    /// （2）声明car类中每个委托类型的成员变量
    /// （3）在car上创建副主函数使得调用者能指定由委托成员变量保存的方法
    /// （4）修改Accelerate()方法以在适当的情形下调用委托的调用列表
    /// </summary>
    public class Car
    {
        //内部状态数据
        public int CurentSpeed;
        public int MaxSpeed;
        public string name;
        //汽车能不能用
        private bool carIsdead;
        //类构造函数
        public Car() { }
        public Car(string name,int currentspeed,int maxspeed=100)
        {
            this.name = name;
            this.CurentSpeed = currentspeed;
            this.MaxSpeed = maxspeed;
        }
        //定义委托类型
        public delegate void CarEngineHandler(string msdForCar);
        //定义每个委托类型的成员变量
        private CarEngineHandler listOfhandlers;
        //向调用者添加注册函数
        public void RegisterWithCarEngine(CarEngineHandler methodTocall)
        {
            if (listOfhandlers == null)
                listOfhandlers = methodTocall;
            else
                listOfhandlers += methodTocall;//支持多路广播
        }
        //实现Accelerate()方法
        public void Accelerate(int delta)
        {
            if(carIsdead)
            {
                if(listOfhandlers!=null)
                {
                    listOfhandlers("sorry,this car is dead");
                }
            }
            else
            {
                CurentSpeed += delta;
                //不能超过最大速度
                if(5==(MaxSpeed-CurentSpeed) && listOfhandlers != null)
                {
                    listOfhandlers("this speed is nearly to the maxspeed");
                }
                if (CurentSpeed > MaxSpeed)
                {
                    carIsdead = true;
                }
                else
                    Console.WriteLine("current speed:{0}", CurentSpeed);
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //首先创建一个car对象
            Car mycar = new Car("xiaowang",10);
            //现在告诉汽车他想要向我们发送信息是应该调用哪个方法
            mycar.RegisterWithCarEngine(new Car.CarEngineHandler(OnCarEngineEvent));
            //方法组转换语句---传递与委托类型一致的函数
            //mycar.RegisterWithCarEngine(CallMeHere);
            //加速，触发事件
            Console.WriteLine("*******speed up********");
            for(int i=0;i<6;i++)
            {
                mycar.Accelerate(20);
                Console.ReadKey();
            }
            //要传入事件的方法
        }
        public static void OnCarEngineEvent(string msg)
        {
            Console.WriteLine("feedback information:{0}", msg);
        }
        static void CallMeHere(string msg)
        {
            Console.WriteLine("feedback information:{0}", msg);
        }
    }
}

 6.2实现多路广播---见6.1

6.3泛型委托

泛型参数

      public delegate void MyDelegate<T>(T mycan);-------对应一类函数

泛型Action<>和Func<>委托------框架内置的委托

泛型Action：可以指向多至16个参数并返回void的方法，需要制定各个参数的具体类型。

Func<>委托:可以指向多至16个参数并且具有自定义返回值。

Func<int,int,int> functarget=new Func<int,int,int>(Add);

Add中本有两个参数，Func<int,int,int>最后一个参数是返回值。

7、事件

event关键字在变已处理的时候，它会自动的提供注册和注销方法以及任何必要的委托类型成员变量，这些成员变量是私有的，不能从出发事件的对象访问。

定义事件：

1）定义委托类型----事件触发时要调用的方法；

2）用相关委托声明这个事件----使用event关键字。

namespace 委托通知
{
    //使用委托来定义car类，他可以通知外部实体当前引擎状态
    /// <summary>
    /// （1）定义将通知发送给调用者的委托类型
    /// （2）声明car类中每个委托类型的成员变量
    /// （3）在car上创建副主函数使得调用者能指定由委托成员变量保存的方法
    /// （4）修改Accelerate()方法以在适当的情形下调用委托的调用列表
    /// </summary>
 namespace 委托通知
{
    //使用委托来定义car类，他可以通知外部实体当前引擎状态
    /// <summary>
    /// （1）定义将通知发送给调用者的委托类型
    /// （2）声明car类中每个委托类型的成员变量
    /// （3）在car上创建副主函数使得调用者能指定由委托成员变量保存的方法
    /// （4）修改Accelerate()方法以在适当的情形下调用委托的调用列表
    /// </summary>
    public class Car
    {
        //内部状态数据
        public int CurentSpeed;
        public int MaxSpeed;
        public string name;
        //汽车能不能用
        private bool carIsdead;
        //类构造函数
        public Car() { }
        public Car(string name, int currentspeed, int maxspeed = 100)
        {
            this.name = name;
            this.CurentSpeed = currentspeed;
            this.MaxSpeed = maxspeed;
        }
        //定义委托类型
        public delegate void CarEngineHandler(string msdForCar);
        //定义每个委托类型的成员变量
        private CarEngineHandler listOfhandlers;
        //向调用者添加注册函数
        public void RegisterWithCarEngine(CarEngineHandler methodTocall)
        {
            if (listOfhandlers == null)
                listOfhandlers = methodTocall;
            else
                listOfhandlers += methodTocall;//支持多路广播
        }
        //实现Accelerate()方法
        public void Accelerate(int delta)
        {
            if (carIsdead)
            {
                if (listOfhandlers != null)
                {
                    listOfhandlers("sorry,this car is dead");
                }
            }
            else
            {
                CurentSpeed += delta;
                //不能超过最大速度
                if (5 == (MaxSpeed - CurentSpeed) && listOfhandlers != null)
                {
                    listOfhandlers("this speed is nearly to the maxspeed");
                }
                if (CurentSpeed > MaxSpeed)
                {
                    carIsdead = true;
                }
                else
                    Console.WriteLine("current speed:{0}", CurentSpeed);
            }
        }
    }
    public class newCar
    {
        //内部状态数据
        public int CurentSpeed;
        public int MaxSpeed;
        public string name;
        //汽车能不能用
        private bool carIsdead;
        //类构造函数
        public newCar() { }
        public newCar(string name, int currentspeed, int maxspeed = 100)
        {
            this.name = name;
            this.CurentSpeed = currentspeed;
            this.MaxSpeed = maxspeed;
        }
        //定义委托用来与car的时间协作
        public delegate void CarEngineNewHandles(string msg);
        //汽车可以发送的事件
        public event CarEngineNewHandles Exploded;
        public event CarEngineNewHandles AbouttoBlow;

        public void NewAccelerate(int delta)
        {
            if (carIsdead)
            {
                if (Exploded != null)
                {
                    Exploded("sorry,this car is dead");
                }
            }
            else
            {
                CurentSpeed += delta;
                //不能超过最大速度
                if (5 == (MaxSpeed - CurentSpeed) && AbouttoBlow != null)
                {
                    AbouttoBlow("this speed is nearly to the maxspeed");
                }
                if (CurentSpeed > MaxSpeed)
                {
                    carIsdead = true;
                }
                else
                    Console.WriteLine("current speed:{0}", CurentSpeed);
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //////////////////////////////////////////////////////////////////////////使用委托回调
            //首先创建一个car对象
            Car mycar = new Car("xiaowang", 10);
            //现在告诉汽车他想要向我们发送信息是应该调用哪个方法
            mycar.RegisterWithCarEngine(new Car.CarEngineHandler(OnCarEngineEvent));
            //方法组转换的---传递与委托类型一致的函数
            //mycar.RegisterWithCarEngine(CallMeHere);
            //加速，触发事件
            Console.WriteLine("*******speed up********");
            for (int i = 0; i < 6; i++)
            {
                mycar.Accelerate(20);
                Console.ReadKey();
            }

            ////////////////////////////////////////////////////////////////////////// 使用事件回调

            //调用者监听传入的事件
            ///先要使用+=h和-=注册和删除事件
            newCar c1 = new newCar("wangming", 30);
            //注册事件处理程序
            c1.AbouttoBlow += new newCar.CarEngineNewHandles(CarIsAboutToBlow);
            c1.AbouttoBlow += new newCar.CarEngineNewHandles(CarIsAmostAboutToBlow);


            newCar.CarEngineNewHandles d = new newCar.CarEngineNewHandles(OnCarEngineEvent);
            c1.Exploded += d;

            for (int i = 0; i < 6; i++)
            {
                c1.NewAccelerate(30);
                Console.ReadLine();
            }

            ///使用方法组转换简化
            newCar c2 = new newCar("wangming", 30);
            //注册事件处理程序
            c2.AbouttoBlow += CarIsAboutToBlow;
            c2.AbouttoBlow += CarIsAmostAboutToBlow;
            newCar.CarEngineNewHandles d2 = new newCar.CarEngineNewHandles(OnCarEngineEvent);
            c2.Exploded += d2;

        }

        
        public static void OnCarEngineEvent(string msg)
        {
            Console.WriteLine("feedback information:{0}", msg);
        }
        public static void CarIsAboutToBlow(string msg)
        {
            Console.WriteLine("car is about to blow");
        }
        public static void CarIsAmostAboutToBlow(string msg)
        {
            Console.WriteLine("car is about to blow");
        }
    }


}

    public class newCar
    {
        //内部状态数据
        public int CurentSpeed;
        public int MaxSpeed;
        public string name;
        //汽车能不能用
        private bool carIsdead;
        //类构造函数
        public newCar() { }
        public newCar(string name, int currentspeed, int maxspeed = 100)
        {
            this.name = name;
            this.CurentSpeed = currentspeed;
            this.MaxSpeed = maxspeed;
        }
        //定义委托用来与car的时间协作
        public delegate void CarEngineNewHandles(string msg);
        //汽车可以发送的事件
        public event CarEngineNewHandles Exploded;
        public event CarEngineNewHandles AbouttoBlow;

        public void NewAccelerate(int delta)
        {
            if (carIsdead)
            {
                if (Exploded != null)
                {
                    Exploded("sorry,this car is dead");
                }
            }
            else
            {
                CurentSpeed += delta;
                //不能超过最大速度
                if (5 == (MaxSpeed - CurentSpeed) && AbouttoBlow != null)
                {
                    AbouttoBlow("this speed is nearly to the maxspeed");
                }
                if (CurentSpeed > MaxSpeed)
                {
                    carIsdead = true;
                }
                else
                    Console.WriteLine("current speed:{0}", CurentSpeed);
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //////////////////////////////////////////////////////////////////////////使用委托回调
            //首先创建一个car对象
            Car mycar = new Car("xiaowang", 10);
            //现在告诉汽车他想要向我们发送信息是应该调用哪个方法
            mycar.RegisterWithCarEngine(new Car.CarEngineHandler(OnCarEngineEvent));
            //方法组转换的---传递与委托类型一致的函数
            //mycar.RegisterWithCarEngine(CallMeHere);
            //加速，触发事件
            Console.WriteLine("*******speed up********");
            for (int i = 0; i < 6; i++)
            {
                mycar.Accelerate(20);
                Console.ReadKey();
            }

            ////////////////////////////////////////////////////////////////////////// 使用事件回调

            //调用者监听传入的事件
            ///先要使用+=h和-=注册和删除事件
            newCar c1 = new newCar("wangming", 30);
            //注册事件处理程序
            c1.AbouttoBlow += new newCar.CarEngineNewHandles(CarIsAboutToBlow);
            c1.AbouttoBlow += new newCar.CarEngineNewHandles(CarIsAmostAboutToBlow);


            newCar.CarEngineNewHandles d = new newCar.CarEngineNewHandles(OnCarEngineEvent);
            c1.Exploded += d;

            for (int i = 0; i < 6; i++)
            {
                c1.NewAccelerate(30);
                Console.ReadLine();
            }

            ///使用方法组转换简化
            newCar c2 = new newCar("wangming", 30);
            //注册事件处理程序
            c2.AbouttoBlow += CarIsAboutToBlow;
            c2.AbouttoBlow += CarIsAmostAboutToBlow;
            newCar.CarEngineNewHandles d2 = new newCar.CarEngineNewHandles(OnCarEngineEvent);
            c2.Exploded += d2;

        }

        
        public static void OnCarEngineEvent(string msg)
        {
            Console.WriteLine("feedback information:{0}", msg);
        }
        public static void CarIsAboutToBlow(string msg)
        {
            Console.WriteLine("car is about to blow");
        }
        public static void CarIsAmostAboutToBlow(string msg)
        {
            Console.WriteLine("car is about to blow");
        }
    }

}

 从上面的例子也可以看出，手工定义一个委托对象调用的方法显的有点繁琐，不会很受欢迎，可以在实践注册时之间将一个委托与一段代码相关联-----------匿名方法。

示例代码入下：

            //注册事件处理程序作为匿名方法
            c3.AbouttoBlow += delegate (string msg)
            {
                Console.WriteLine("匿名委托返回消息{0}", msg);
                Console.ReadKey();
            };
            c3.Exploded += delegate (string msg)
            {
                Console.WriteLine("feedback information:{0}", msg);
                Console.ReadLine();
            };
            for (int i = 0; i < 6; i++)
            {
                c3.NewAccelerate(5);   
            }

8、Lambda表达式

lambda表达式本质上是用更简单的方法写匿名方法，首先定义一个参数列表，"=>"标记紧随其后，然后就是处理这些参数的语句。

ArgumentsToProcess=>StatementsToProcessThem;参数类型可以是显式的也可以是隐式的。

namespace Lambda表达式
{
    class Program
    {
        static void Main(string[] args)
        {
            TraditionalDelegateSyntax();
        }

        static void TraditionalDelegateSyntax()
        {
            //创建整数列表
            List<int> list = new List<int>();
            list.AddRange(new int[] { 20, 1, 4, 8, 444, 8 });

            ////使用传统委托方法调用FindAll()
            //Predicate<int> callback = new Predicate<int>(IsEvenNumber);
            //List<int> evennumbers = list.FindAll(callback);
            //foreach (int evennum in evennumbers)
            //{
            //    Console.WriteLine("{0}	", evennum);
            //}
            //Console.ReadKey();
            //////////////////////////////////////////////////////////////////////////
            //采用匿名方法
            //List<int> evennumbers = list.FindAll(delegate (int num)
            //{
            //    return (num % 2 == 0);
            //});
            //foreach (int evennum in evennumbers)
            //{
            //    Console.WriteLine("{0}	", evennum);
            //}

            //////////////////////////////////////////////////////////////////////////
            //采用Lamada表达式
            List<int> evennumbers = list.FindAll(num=>(num%2)==0);
            //运行时被编译成了上述匿名方法
            foreach (int evennum in evennumbers)
            {
                Console.WriteLine("{0}	", evennum);
            }
            Console.ReadKey();

        }
        static bool IsEvenNumber(int num)
        {
            //这是个偶数
            return (num % 2 == 0);
        }
    }
}

9、接口

 接口是一组抽象成员的命名集合，由接口定义的某个特定成员依赖于它所模拟的确切行为。.NET基础库中提供了几百个预定义的接口类型，由各种类和结构实现。 与抽象类不同，接口只能包含抽象成员，由于C#中类不支持多重继承，一个父类定义的抽象成员只能被其派生类继承，但是大型系统中开发除了Object之外没有公共父类的多个层次结构很普遍，这样就不能配置多层次结构支持相同的多态接口，接口类型解决了这一问题，它可以被任何层次结构。任何命名空间或任何程序集中的任何类或结构来实现，这样接口就有了较高的多态性。

1）不能向类和结构一样分配类型：

Ipointy p=new Ipointy()

2)实现接口是个要"要么全要要么全部不要”的命题，即支持类型无法选择实现哪些成员。

    interface IPoint
    {
        //接口定义
        //1)不指定访问修饰符（默认隐式共有、抽象）
        //2)不能实现
       // byte GetNumofPoint();

        //只读属性
        byte Points{ get; }

    }
    //实现接口时要么全要，要么全不要
    class Triangle:Object,IPoint
    {   //...
        public byte Points
        {
            get { return 3; }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //在对象级别调用接口成员
            Triangle triangle = new Triangle();
            Console.WriteLine(triangle.Points);
            Console.ReadKey();
        }
    }

9.1怎样判定一个类型是否支持一个指定接口

1）使用显式强制转换。

 static void Main(string[] args)
        {
            //在对象级别调用接口成员
            Triangle triangle = new Triangle();
            try
            {
                IPoint point = null;
                point = (IPoint)triangle;
                Console.WriteLine(triangle.Points);
                Console.ReadKey();
            }
            catch (InvalidCastException e)
            {
                Console.WriteLine(e.Message);
            }
        }

2）as关键字

 IPoint point = null;
            point = triangle as IPoint;

3)is关键字

            //在对象级别调用接口成员
            Triangle triangle = new Triangle();
            try
            {

                if (triangle is IPoint)
                {
                    Console.WriteLine(triangle.Points);
                    Console.ReadKey();
                }
            }
            catch (InvalidCastException e)
            {
                Console.WriteLine(e.Message);
            }

9.2接口作为参数

 interface IPoint
    {
        //接口定义
        //1)不指定访问修饰符（默认隐式共有、抽象）
        //2)不能实现
        string GetNumofName();

        //只读属性
        //byte Points{ get; }

    }
    //实现接口时要么全要，要么全不要
    class Triangle : Object, IPoint
    {   //...
        public string GetNumofName()
        {
            return "i am Triangle ";
        }
    }
    class Rect : Object, IPoint
    {   //...
        public string GetNumofName()
        {
            return "i am Rect";
        }
    }
    class Program
    {
        static public string sayname(IPoint p)
        {
            return p.GetNumofName();
        }
        static void Main(string[] args)
        {
            //在对象级别调用接口成员
            //Triangle triangle = new Triangle();
            //try
            //{

            //    if (triangle is IPoint)
            //    {
            //        Console.WriteLine(triangle.Points);
            //        Console.ReadKey();
            //    }
            //}
            //catch (InvalidCastException e)
            //{
            //    Console.WriteLine(e.Message);
            //}

            object[] obj = { new Triangle(), new Rect() };
            for (int i = 0; i < obj.Length; i++)
            {
                if (obj[i] is IPoint)
                {
                    IPoint p = (IPoint)obj[i];
                    Console.WriteLine(sayname(p));
                }
            }
            Console.ReadKey();

        }
    }

类似的通过as/is关键字的使用，接口也可以作为返回值。

9.3接口数组

接口数组可以包含实现了该接口的任何类或者结构,不论相关不相关。

IPoint[]={new triangle(),new Tree(),new Rect()}

 9.4接口的层次结构

1）接口可以继承，继承后如果一个类实现了该接口，则该接口继承的接口成员也需要被实现，同时接口也支持多种继承，若不同接口存在命名冲突，可以通过显式接口解决冲突。