委托delegate,继承

public void test(Func<string,int,string> returnMethod, Action<string> voidMethod){    voidMethod("para1");    string returnValue = returnMethod("para1", 5);}PRotected void Page_Load(object sender, EventArgs e){    //第一种写法    test(delegate(string para1, int para2)    {        return "";    }, delegate(string para1)    {        string x = "do somthing";    });    //第2中写法,有点表达式的味道了。 js的话要ECMA6才支持箭头写法    test((para1, para2) => "5", (para1) => { string x = "do somthing"; });    test((para1, para2) =>    {        string a = "5" + para1;        return a + "5";    }, (para1) =>    {        string x = "do somthing" + para1;    });}

     public void method(tuoguan voidMethod, tuoguan2 returnMethod) //这里不可以在写 Action or Func了    {        Int32 i = returnMethod("b");        voidMethod("b");    }    public delegate void tuoguan(string name);    public delegate Int32 tuoguan2(string name);    public Int32 returnMethod(string name)    {        return 5;    }            tuoguan xx = delegate(string name)             {                //do somthing             };            tuoguan2 yy = returnMethod; //这里可以指向某个方法，不是一定要写 delegate            method(xx, yy);

//简单介绍public class basic_class_logic{    public abstract class chouxiang //抽象类只是一个虚拟的类，是不可以实例化的(其它特性和普通类一样),目的是给派生类(子类)使用    {         //与接口不同        //里面可以写属性方法    }              //public：它具有最高的访问级别，对访问公共成员没有限制。    //private：它的访问级别最低，仅限于它的包含类。    //protected：能在它的包含类或包含类的派生类中访问。    //internal：只能在同一程序集的文件中。    //protected internal：仅限于从包含类派生的当前程序集或类型。    //public abstract：可以在任何地方访问，但不能实例化，只能继承。    //public sealed：可以在任何地方访问，只能实例化，不能派生。    public static void move() { } //static void 是静态方法 (无需实例化类也可以调用)    public const int months = 12; //const 是常量 ，一旦赋值就不能改变，通常用于一些死的变量    // public const DateTime months = new DateTime(2013, 10, 07, 00, 05, 00, 00); 这里会报错 ！ const 不能使用 new ，所以用readonly就不会    public readonly int MAX_VALUE = 10;  // readonly 也是常量 。动态常量 ， 有人建议用这个不要用 const                          //公有name "引用" 私有name （和js 一样逻辑）    //调用:    //Car first = new Car();    //first.name = "keatkeat";    //first.changeName("xinyao");    //string a = first.name;  //result : xinyao    //*    public class Person    {        private string _name; //私有name         public Person()        {            this.name = "ttc";        }        public string name //公有name        {            get { return _name; } //返回私有name            set { _name = value; } // set 私有name        }        public void changeName(string name)//公有方法         {            _name = name; //替换私有name         }    }    //无需私有name 的方式 效果和上面一个差不多    public class Car    {        public string name { get; set; } //公有name        public void changeName(string name)        {            this.name = name; //change obj.name         }    }    }//继承public class xuncheng {    public class Person //基类，父类    {        public Person(string name, int age = 0) //实例化是调用的函数        {            this.name = name;            this.age = age;        }        public string name { get; set; }        public int age { get; set; }        public string getName() //普通方法        {            return this.name;        }        public abstract string getAbstractName(); //abstract 抽象方法(只有在抽象类才能有抽象方法) ，在本类是无法调用的,也无内容,只是一个声明，子类通过覆盖方法来调用(一定要有覆盖的方法，不然会error)        public virtual void sayVirtualName() //virtual 虚方法，本类可以调用,子类可以覆盖，如果没有覆盖将调用此方法 (和普通方法几乎一样)        {            string a = "bb";        }               }    //讲解:    //子类可以调用所有父类的属性和方法(除了私有的不可以)               public class Student : Person    {        //base.属性 ，base.方法 通过base关键字，调用父类的函数 (孩子的孩子，通过base方法就会一直向上调用，不管几代都能一直往上)        public string school_name { get; set; }        public Student(string school_name) //调用基类的构造函数（实例化时的函数）  可以写default也可以是传入参数             : base(school_name, 5)                         {            this.school_name = school_name;        }                              public new string getName() //可以用 new 来隐藏父类的普通方法,在父类依然是调用父类，在子类就会调用new 的方法子类。        {            string a = this.name; //如果子类没有name 属性会调用父类的，有的话会调用子类的            string b = base.name; //100%调用父类的name            return "覆盖name";        }        public override string getAbstractName()//通过 override 来覆盖抽象方法或虚方法，一但覆盖了即便是在父类也将调用覆盖了的新方法了！        {            return "抽象方法必须实现-用override";        }        public override void sayVirtualName()//通过 override 来覆盖虚方法 (如果子类没有覆盖将调用回复类方法)        {            string start = "xx"; //这样就可以达到扩展方法的效果了            base.sayVirtualName();//调用回原本的方法            string end = "xx";         }    }    }//泛型//调用时才把类型传进去,有点动态的感觉//调用 : Parent<string> xx = new Parent<string>();  这个时候才指定是string public class Parent<T> //T 是一个类型 比如 string,int {    public T name { get; set; }    public T getName()    {        return this.name;    }}//struct 是 值类型 //好处调用的是如果参数是值类型可以不用著名 test(100) 而不需要 test<int>(100);public void test<T>(T number) where T : struct{    int z = Convert.ToInt32(number);    //调用 test(100);}//不知道好处在哪public void test2<T>(T lei) where T : class{}//我知道哪个class还需要用泛型吗？！ 不解public void test3<T>() where T : stooges{}//进来实例化就走？也是不知道哪里用得上！实例了又不能调用它的方法啦！靠public T test4<T>() where T : new(){    T abc = new T();    return abc;}public class stooges{     }protected void Page_Load(object sender, EventArgs e){}