C#C#中的特殊数据类型

6、委托项目delegate

委托项目用来定义和响应应用程序中的回调,使用回调程序员可以使用一个函数重临报告给程序中的另一个函数,使用这种方法,windows开发者能够可以拍卖按钮单击、鼠标移动、菜单接纳以及内存中六个实体的双向通信。本质上嘱托是个项目安全的目的,它指向一个从此会被调用的法子(或者四个措施),可以毫不手工创制一个thread对象去条用别样thread上的点子,委托项目有七个至关首要的信息:

1)它所调用的措施和称号

2)该情势的参数(可选)

3)该方法的回来值类型(可选)

2、结构类型

协会类型能够看作是轻量级的类类型,可是不可能像类一样持续

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

    //创建结构变量
    point p1;
    p1.x = 5;//需要为每一个共有字段成员赋值
            point p2 = new point();
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();
        }
    }
3、数组类型

一组一致档次的数据点:int[] myInt=new int[3]

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

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}\t", evennum);
            //}
            //Console.ReadKey();
            //////////////////////////////////////////////////////////////////////////
            //采用匿名方法
            //List<int> evennumbers = list.FindAll(delegate (int num)
            //{
            //    return (num % 2 == 0);
            //});
            //foreach (int evennum in evennumbers)
            //{
            //    Console.WriteLine("{0}\t", evennum);
            //}

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

        }
        static bool IsEvenNumber(int num)
        {
            //这是个偶数
            return (num % 2 == 0);
        }
    }
}
 9.4接口的层次结构

1)接口可以连续,继承后一旦一个类实现了该接口,则该接口继承的接口成员也需要被实现,同时接口也支撑多种继承,若不同接口存在命名争辩,可以由此显式接口解决争论。

 

  

 

 6.2贯彻多路广播—见6.1
1、class类型
 5.3泛型集合

唯有类、结构、接口和信托可以拔取泛型,枚举类型不得以。

1)System.Collection.Generic命名空间

C# 1

 

 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,第二个参数为NotifyCollectionChanged伊芙ntArgs)。

  

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;
        }
    }
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);
            }
1.2走访修饰符

花色成员隐式私有的,而类是隐式内部的。

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

public 可以从对象、派生类、外部其它程序集访问
private 定义类访问
protected 定义类及子类可以访问,外部类无法通过点操作符访问
internal 只能在当前程序集中访问
protected internal 在定义该项的程序集、类及派生类中可用
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类,在一定的情事下存在项目安全题材。

9.3接口数组

接口数组能够分包实现了该接口的此外类依然社团,不论相关不相干。

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

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 { }

 

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>最终一个参数是再次来到值。

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

C#中分外数据类型有class类型、结构类型、数组类型、枚举类型、集合类型、委托项目、事件、兰姆(Lamb)da表明式、接口类型。

例2

C# 2C# 3

//声明委托
    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;
        }

    }

View Code

 

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("你好"+"\r\n");
            }
        }


    }
//其他类的用法类似,有相应的文档
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)
        { 
            //操作
        }
    }
9.2接口作为参数

C# 4C# 5

 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();

        }
    }

View Code

仿佛的经过as/is关键字的行使,接口也足以用作重临值。

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));
HashTable示例:

C# 6C# 7

  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();


        }

View Code

6.1、委托项目标概念

public delegate int BinaryOp(int x,int y)

行使delegate关键字,就直接创立了一个类,这一个类是“MulticastDelegate”,下表显示了独具寄托对象都有些要旨成员。

C# 8

例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);
        }
    }
}
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]
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);
        }
    }
}
7、事件

event关键字在变已处理的时候,它会自动的提供注册和撤除方法以及此外必要的信托项目成员变量,这个分子变量是私有的,不可能从出发事件的对象访问。

概念事件:

1)定义委托项目—-事件触发时要调用的方法;

2)用相关委托表明这一个事件—-使用event关键字。

C# 9C# 10

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");
        }
    }

}

View Code

 从地点的例子也得以见见,手工定义一个寄托对象调用的措施显的多少麻烦,不会很受欢迎,可以在进行注册时之间将一个信托与一段代码相关联———–匿名方法。

示范代码入下:

            //注册事件处理程序作为匿名方法
            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);   
            }
 5、集合类型-数据容器

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

  简单数组日常是永恒大小的,而集合类本身的尺码是动态的,类似于python中的list类型,很多会聚提供了更强的项目安全,举办了莫大优化,能够以内存高效的格局处理所含有的数目。

  集合可分割为两大门类:非泛型集合和泛型集合

相关文章