委托 delegate, 继承

c# 的委托就是说把函数当参数来传递。

这个在js完全就用不着搞什么委托东西，直接转就是了嘛。对不对！怎么录嘛！

一个函数，如果它的参数是函数，那么是这样子写的

public void method(Action<string, Int32> voidMethod, Func<string, Int32> returnMethod)

Action<string, Int32> voidMethod

的意思是说这个将被传进来的函数是一个没有return的函数，就是public void啦, 它需要一个str参数

(这里提一下，js中每个函数都是return的即使你没有写，它也会return undefiend)

Func<string, Int32> returnMethod

的意思是说这个函数是一个有return的函数，最后一个参数Int32代表了它的return是一个Int32 , 就是 public Int32啦, 那么除了最后一个参数其余的都是这个函数所需要的参数了

具体代码 :

public void test(Func<string,int,string> returnMethod, Action<string> voidMethod)
{
    voidMethod("para1");
    string returnValue = returnMethod("para1", );
}
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) => "", (para1) => { string x = "do somthing"; });
    test((para1, para2) =>
    {
        string a = "" + para1;
        return a + "";
    }, (para1) =>
    {
        string x = "do somthing" + para1;
    });
}

这里使用的是匿名函数delegate(){}，这个比较习惯，因为js大多数会用匿名函数的。

当然，如果你硬硬要old school风 ， 可以写比较传统的

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

            tuoguan xx = delegate(string name)
            {
                //do somthing
            };
            tuoguan2 yy = returnMethod; //这里可以指向某个方法，不是一定要写 delegate
            method(xx, yy);

委托是很好用的，比如我对进去的匿名函数也可以引用到作用域上的变量，这个和js是一样的！

把它当js来写，我觉得这样非常好！

继承

//简单介绍
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 = ; //const 是常量 ，一旦赋值就不能改变，通常用于一些死的变量
    // public const DateTime months = new DateTime(2013, 10, 07, 00, 05, 00, 00); 这里会报错 ！ const 不能使用 new ，所以用readonly就不会
    public readonly int MAX_VALUE = ;  // 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 = ) //实例化是调用的函数
        {
            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, )
        {
            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)
{

}

更新 2016-07-12

async 一个方法

Func<Task<string>> xx = async () =>
{
    await Task.Delay();
    return "";
};
string www =  await xx();