10月28号委托基数排序，事件

基数排序：将整数按位数切割成不同的数字，然后按每个  位数进行比较。 是一种非比较型整数排序算法，也是多关键字排序。

具体做法：将所有待比较数值统一为同样的位数，较短的数值往前补零，然后从最低位开始进行依次排序。

1.先找到最大值

2.取余放进桶（只是记录个数）

3.更改buttck[i],目的是让更改的后buttck[i]的值，变成该数据在OutPut[]上的位置

4.将数组存储进output

5.排序好的数值赋值给a[];                 

          void Radix_sort(int []arr, int length)
            {
                int max = arr[0] ;
                int[] output = new int[length];
                int _base = 1;
                for (int i = 0; i < length; i++)   //先求最大值
                {
                    if (arr[i] > max)
                    {
                        max = a[i];
                    }
                }
                while(max / _base > 0)
                {
                    int []bucket = new int[10];   //桶
                 
                    for (int i = 0; i < length; i++)   //求余记录进桶
                    {
                        bucket[(arr[i] / _base) % 10]++;
                    }

                    for (int i = 1; i < bucket.Length; i++) //更改Bucket[i],目的是让更改后的bucket[i]的值是该数据在output的位置
                    {
                        bucket[i] += bucket[i - 1];
                    }
                    for (int i = length -1; i >= 0; i--)   //将数据存储进临时数组output中
                    {
                        output[bucket[a[i] / _base % 10] - 1] = a[i];
                        bucket[a[i] / _base % 10]--;
                    }
                    for (int i = 0; i < length; i++)  //把排序好的数据赋值给a[i]
                    {
                        arr[i] = output[i];
                    }
                    for (int i = 0; i < length; i++)  //输出
                    {
                        Console.WriteLine(a[i]);
                    }
                    _base *= 10;    //每次增加一位
                }
            }

委托的一般使用: 把委托类型的参数传入主调方法

回调方法（好菜坞方法）---某个方法，我可以调用它，也可以不调用它。

            WarpFactory warpFactory = new WarpFactory();
            ProductFactroy productFactroy = new ProductFactroy();
            Func<Product> setProduct1 = new Func<Product>(productFactroy.MakePizz);            
            Func<Product> setProduct2 = new Func<Product>(productFactroy.MakeCar);

            Logger logger = new Logger();
            Action<Product> log = new Action<Product>(logger.Log);

           Box box1 = warpFactory._WarpFactory(setProduct1,log);
           Box box2 = warpFactory._WarpFactory(setProduct2,log); 
 class Logger
    {
        public void Log(Product product)
        {
            Console.WriteLine("{0},creat at {1}, price is{2}" , product.name, product.name, product.price);
        }
    }
    class Product  //产品
    {
        public string name { get; set; }
        public int price { get; set; }
    }
    class Box   //盒子
    {
        public Product prouduct { get; set; }
    }
    class WarpFactory   //包装盒子
    {
        public Box _WarpFactory(Func<Product> getProduct,Action<Product> callBack)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            Console.WriteLine(product.price);
            callBack(product);
            box.prouduct = product;
            return box;            
        }
    }
    class ProductFactroy  //生产产品
    {
        public Product MakePizz()
        {
            Product product = new Product();
            product.name = "Pizz";
            product.price = 100;
            return product;
        }
        public Product MakeCar()
        {
            Product product = new Product();
            product.name = "Car";
            product.price = 40;
            return product;
        }
    }

委托的高级使用：

多播委托:（一个委托里封装多个方法） action1 += action2;

隐式异步调用：（beginInvoke）

总结：

            ///直接同步调用
            //stu1.DoHomeWork();
            //stu2.DoHomeWork();
            ///间接同步调用
            //action1.Invoke();
            //action2.Invoke();
            ///多播委托
            // action1 += action2;
            // action1.Invoke();
            ///隐式异步调用 得换成控制台应用Net.Framework
            // action1.BeginInvoke(null, null);
            // action2.BeginInvoke(null, null);
            ///显式异步调用
            //Task task1 = new Task(new Action(stu1.DoHomeWork));
            //Task task2 = new Task(new Action(stu2.DoHomeWork));
            //task1.Start();
            //task2.Start();

 

事件：（就好比对现实世界的模拟）

定位：能使对象或者类具备通知能力的成员

五大组成：事件的拥有者-事件-事件的响应者-事件处理器-事件订阅

            // Form form = new Form();  //事件拥有者
            // Test test = new Test(form);
            // form.ShowDialog();
              
/// <summary>
    /// 一：事件的拥有者跟响应者为不同对象    事情拥有者拥有事件  事件响应者拥有事件处理器 
    /// </summary> 
    class Test   //事件响应者
    {
        public Form form;
        public Test(Form _form)
        {
            if (_form != null)
            {
                form = _form;
                form.Click += this.formClick; //事件订阅   Click事情成员
            }
        }

        private void formClick(object sender, EventArgs e)  //事件处理器
        {
            form.Text = "formClick";
        }
    }

3星

            ///三
            // MyForm1 myform1 = new MyForm1();
            //myform1.ShowDialog();
 
     /// <summary>
    /// 三：事件的拥有者是事件响应者的字段或者属性成员
    /// </summary>
    class MyForm1 : Form    //事件响应者
    {
        private TextBox textBox;
        private Button button;   //事件拥有者

        public MyForm1()
        {
            textBox = new TextBox();
            button = new Button();
            this.Controls.Add(button);
            this.Controls.Add(textBox);
            button.Click += this.ButtonClick;  //订阅

        }
        private void ButtonClick(object sender, EventArgs e) //事情处理器
        {
            textBox.Text = "CLick!CLick!CLick!CLick!";
        }
    }

 2星

            ///二
            // MyForm myform = new MyForm();  //事件拥有者
            //  myform.Click += myform.formClick; //  myform.Click 事件拥有者的事情   myform.formClick事件响应者.事件处理器
            // myform.ShowDialog();
     /// <summary>
    /// 二：事件的拥有者跟响应者为同对象  
    /// </summary>
    class MyForm : Form
    {
        internal void formClick(object sender, EventArgs e)    //事情处理器
        {
            Text = DateTime.UtcNow.ToString();
            Console.WriteLine(Text);
        }
    }

自定义事件：

           // Customer customer = new Customer();
          //  Waitter waitter = new Waitter();
           // customer.orderEvent += waitter.Action;
            //customer.Action();
    public class OrderEventArgs : EventArgs
    {
        public string DishName { get; set; }
    }
    public delegate void OrderEventHandler(Customer customer ,OrderEventArgs e);
    public class Customer
    {
        /// <summary>
        /// 完整声明
        ///      
        /// </summary>
        /*   public OrderEventHandler orderEventHandler;
           public event OrderEventHandler orderEvent
           {
               add
               {
                   this.orderEventHandler += value;
               }
               remove
               {
                   this.orderEventHandler -= value;
               }
           }*/
        /// <summary>
        /// 简略声明   
        /// </summary>
        public event OrderEventHandler orderEvent;
        public void Action()
        {
            if (this.orderEvent != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.DishName = "自定义事件";
                this.orderEvent.Invoke(this, e);
            }
        }
    }
    class Waitter
    {
        public void Action(Customer customer, OrderEventArgs e)
        {

            Console.WriteLine(e.DishName);
        }
    }