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

巴特西

委托 delegate, 继承

最新文章

热门文章