转载:http://www.cnblogs.com/jesse2013/p/happylambda-part2.html

快乐的Lambda表达式

  上一篇 背后的故事之 - 快乐的Lambda表达式(一)我们由浅入深的分析了一下Lambda表达式。知道了它和委托以及普通方法的区别,并且通过测试对比他们之间的性能,然后我们通过IL代码深入了解了Lambda表达式,以及介绍了如何在.NET中用Lambda表达式来实现JavaScript中流行的一些模式。

  今天,我们接着来看Lambda表达式在.NET中还有哪些新鲜的玩法。

Lambda表达式玩转多态

  Lambda如何实现多态?我们用抽象类和虚方法了,为什么还要用Lambda这个玩意?且看下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class MyBaseClass
{
    public Action
SomeAction { 
getprotected set;
}
 
    public MyBaseClass()
    {
        SomeAction
= () =>
        {
            //Do
something!
        };
    }
}
 
class MyInheritedClass
: MyBaseClass
{
    public MyInheritedClass()
    {
        SomeAction
= () => {
            //Do
something different!
        };
    }
}

  我们的基类不是抽象类,也没有虚方法,但是把属性通过委托的方式暴露出来,然后在子类中重新为我们的SomeAction赋予一个新的表达式。这就是我们实现多态的过程,当然父类中的SomeAction的set有protected的保护级别,不然就会被外部随易修改了。但是这还不完美,父类的SomeAction在子类中被覆盖之后,我们彻底访问不到它了,要知道真实情况是我们可以通过base来访问父类原来的方法的。接下来就是实现这个了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class MyBaseClass
{
    public Action
SomeAction { 
getprivate set;
}
 
    Stack<Action>
previousActions;
 
    protected void AddSomeAction(Action
newMethod)
    {
        previousActions.Push(SomeAction);
        SomeAction
= newMethod;
    }
 
    protected void RemoveSomeAction()
    {
        if(previousActions.Count
== 0)
            return;
 
        SomeAction
= previousActions.Pop();
    }
 
    public MyBaseClass()
    {
        previousActions
new Stack<Action>();
 
        SomeAction
= () => {
            //Do
something!
        };
    }
}

  上面的代码中,我们通过AddSomeAction来实现覆盖的同时,将原来的方法保存在previousActions中。这样我们就可以保持两者同时存在了。

  大家知道子类是不能覆盖父类的静态方法的,但是假设我们想实现静态方法的覆盖呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
void Main()
{
    var mother
= HotDaughter.Activator().Message;
    //mother
= "I am the mother"
    var create
new HotDaughter();
    var daughter
= HotDaughter.Activator().Message;
    //daughter
= "I am the daughter"
}
 
class CoolMother
{
    public static Func<CoolMother>
Activator { 
getprotected set;
}
     
    //We
are only doing this to avoid NULL references!
    static CoolMother()
    {
        Activator
= () => 
new CoolMother();
    }
 
    public CoolMother()
    {
        //Message
of every mother
        Message
"I
am the mother"
;
    }
     
    public string Message
getprotected set;
}
}
 
class HotDaughter
: CoolMother
{
    public HotDaughter()
    {
        //Once
this constructor has been "touched" we set the Activator ...
        Activator
= () => 
new HotDaughter();
        //Message
of every daughter
        Message
"I
am the daughter"
;
    }
}

  这里还是利用了将Lambda表达式作为属性,可以随时重新赋值的特点。当然这只是一个简单的示例,真实项目中并不建议大家这么去做。

方法字典

  实际上这个模式我们在上一篇的返回方法中已经讲到了,只是没有这样一个名字而已,就算是一个总结吧。故事是这样的,你是不是经常会写到switch-case语句的时候觉得不够优雅?但是你又不想去整个什么工厂模式或者策略模式,那怎么样让你的代码看起来高级一点呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public Action
GetFinalizer(
string input)
{
    switch
    {
        case "random":
            return ()
=> { 
/*
... */
 };
        case "dynamic":
            return ()
=> { 
/*
... */
 };
        default:
            return ()
=> { 
/*
... */
 };
    }
}
 
//-------------------变身之后-----------------------
Dictionary<string,
Action> finalizers;
 
public void BuildFinalizers()
{
    finalizers
new Dictionary<string,
Action>();
    finalizers.Add("random",
() => { 
/*
... */
 });
    finalizers.Add("dynamic",
() => { 
/*
... */
 });
}
 
public Action
GetFinalizer(
string input)
{
    if(finalizers.ContainsKey(input))
        return finalizers[input];
 
    return ()
=> { 
/*
... */
 };
}

  好像看起来是不一样了,有那么一点味道。但是一想是所有的方法都要放到那个BuildFinalizers里面,这种组织方法实在是难以接受,我们来学学插件开发的方式,让它自己去找所有我们需要的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
static Dictionary<string,
Action> finalizers;
 
//
在静态的构造函数用调用这个方法
public static void BuildFinalizers()
{
    finalizers
new Dictionary<string,
Action>();
 
    //
获得当前运行程序集下所有的类型
    var types
= Assembly.GetExecutingAssembly().GetTypes();
 
    foreach(var type in types)
    {
        //
检查类型,我们可以提前定义接口或抽象类
        if(type.IsSubclassOf(typeof(MyMotherClass)))
        {
            //
获得默认无参构造函数
            var m
= type.GetConstructor(Type.EmptyTypes);
 
            //
调用这个默认的无参构造函数
            if(m
!= 
null)
            {
                var instance
= m.Invoke(
nullas MyMotherClass;
                var name
= type.Name.Remove(
"Mother");
                var method
= instance.MyMethod;
                finalizers.Add(name,
method);
            }
        }
    }
}
 
public Action
GetFinalizer(
string input)
{
    if(finalizers.ContainsKey(input))
        return finalizers[input];
 
    return ()
=> { 
/*
... */
 };
}

  如果要实现插件化的话,我们不光要能够加载本程序集下的方法,还要能随时甚至运行时去加载外部的方法,请继续往下看:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
internal static void BuildInitialFinalizers()
{
    finalizers
new Dictionary<string,
Action>();
    LoadPlugin(Assembly.GetExecutingAssembly());
}
 
public static void LoadPlugin(Assembly
assembly)
{
    var types
= assembly.GetTypes();
    foreach(var type in types)
    {
        if(type.IsSubclassOf(typeof(MyMotherClass)))
        {
            var m
= type.GetConstructor(Type.EmptyTypes);
 
            if(m
!= 
null)
            {
                var instance
= m.Invoke(
nullas MyMotherClass;
                var name
= type.Name.Remove(
"Mother");
                var method
= instance.MyMethod;
                finalizers.Add(name,
method);
            }
        }
    }
}

  现在,我们就可以用这个方法,给它指定程序集去加载我们需要的东西了。

  最后留给大家一个问题,我们能写递归表达式么?下面的方法如果用表达式如何写呢?

1
2
3
4
5
6
7
int factorial(int n)
{
    if(n
== 0)
        return 1;
    else
        return n
* factorial(n - 1);
}

  

快乐的Lambda表达式(二)的更多相关文章

  1. 背后的故事之 - 快乐的Lambda表达式(一)

    快乐的Lambda表达式(二) 自从Lambda随.NET Framework3.5出现在.NET开发者眼前以来,它已经给我们带来了太多的欣喜.它优雅,对开发者更友好,能提高开发效率,天啊!它还有可能 ...

  2. 【转】背后的故事之 - 快乐的Lambda表达式(一)

    快乐的Lambda表达式(二) 自从Lambda随.NET Framework3.5出现在.NET开发者眼前以来,它已经给我们带来了太多的欣喜.它优雅,对开发者更友好,能提高开发效率,天啊!它还有可能 ...

  3. 背后的故事之 - 快乐的Lambda表达式(二)

    快乐的Lambda表达式 上一篇 背后的故事之 - 快乐的Lambda表达式(一)我们由浅入深的分析了一下Lambda表达式.知道了它和委托以及普通方法的区别,并且通过测试对比他们之间的性能,然后我们 ...

  4. 【转】背后的故事之 - 快乐的Lambda表达式(二)

    快乐的Lambda表达式 上一篇 背后的故事之 - 快乐的Lambda表达式(一)我们由浅入深的分析了一下Lambda表达式.知道了它和委托以及普通方法的区别,并且通过测试对比他们之间的性能,然后我们 ...

  5. 快乐的Lambda表达式(一)

    转载:http://www.cnblogs.com/jesse2013/p/happylambda.html 原文出处: Florian Rappl   译文出处:Jesse Liu 自从Lambda ...

  6. Java 8 Lambda 表达式(二)

    lambdas 实现 Runnable 接口 下面是使用 lambdas 来实现 Runnable 接口的示例: // 1.1使用匿名内部类 new Thread(new Runnable() { @ ...

  7. lambda表达式 <二>

    概念了解: 1.什么是匿名委托(匿名方法的简单介绍.为什么要用匿名方法) 2.匿名方法的[拉姆达表达式]方法定义 3.匿名方法的调用(匿名方法的参数传递.使用过程中需要注意什么) 什么是匿名方法? 匿 ...

  8. C#中的Lambda表达式和表达式树

    在C# 2.0中,通过方法组转换和匿名方法,使委托的实现得到了极大的简化.但是,匿名方法仍然有些臃肿,而且当代码中充满了匿名方法的时候,可读性可能就会受到影响.C# 3.0中出现的Lambda表达式在 ...

  9. .NET进阶篇05-Linq、Lambda表达式

    知识需要不断积累.总结和沉淀,思考和写作是成长的催化剂 内容目录 一.Lambda表达式1.匿名方法2.Lambda表达式二.Linq概述三.查询操作符1.linq初见2.常用查询操作符筛选排序分组连 ...

随机推荐

  1. 浅析单点登录,以及不同二级域名下的SSO实现

    一家公司有多个产品线,就可能要有多个子域名,下头以baidu域名为例,a.baidu.com, b.baidu.com.com 是顶级域名,baidu 就是一个二级域名,a和b就是子域名. 当用户在a ...

  2. android 环境的配置

    经过了长达好几天的她探索,一直出现各种问题,然后,也是一个一个的解决,但最后,解决烦了,就觉得重新开始配置android的环境了. 原来一直都是版本的问题,因为我之前下载的都是2014的版本,而这个版 ...

  3. Luogu3320 SDOI2015 寻宝游戏 链并

    传送门 可以发现从哪里开始的最优答案都是一样的.我们只需要用一种比较好维护的方法维护答案就好了. 我们考虑用$dfs$序加上$set$维护链并.先预处理$dfs$序,将当前有宝藏的点丢入$set$中, ...

  4. Android自动化测试之:获取 参数:comonentName 的值方法

    十年河东十年河西,莫欺少年穷! 不了解Activity的,可参考:http://www.cnblogs.com/tekkaman/archive/2011/06/07/2074211.html 相关代 ...

  5. [Spark][Hive][Python][SQL]Spark 读取Hive表的小例子

    [Spark][Hive][Python][SQL]Spark 读取Hive表的小例子$ cat customers.txt 1 Ali us 2 Bsb ca 3 Carls mx $ hive h ...

  6. browserify运行原理分析

    目前对于前端工程师而言,如果只针对浏览器编写代码,那么很简单,只需要在页面的script脚本中引入所用js就可以了. 但是某些情况下,我们可能需要在服务端也跑一套类似的逻辑代码,考虑如下这些情景(以n ...

  7. 干货分享:vue2.0做移动端开发用到的相关插件和经验总结(2)

    最近一直在做移动端微信公众号项目的开发,也是我首次用vue来开发移动端项目,前期积累的移动端开发经验较少.经过这个项目的锻炼,加深了对vue相关知识点的理解和运用,同时,在项目中所涉及到的微信api( ...

  8. Nginx基于TCP/UDP端口的四层负载均衡(stream模块)配置梳理

    通过我们会用Nginx的upstream做基于http/https端口的7层负载均衡,由于Nginx老版本不支持tcp协议,所以基于tcp/udp端口的四层负载均衡一般用LVS或Haproxy来做.至 ...

  9. Heartbeat基础知识-运维小结

    在日常的集群系统架构中,一般用到Heartbeat的主要就2种:1)高可用(High Availability)HA集群, 使用Heartbeat实现,也称为”双机热备”, “双机互备”, “双机”: ...

  10. B. Heaters Div3

    链接 [http://codeforces.com/contest/1066/problem/B] 分析 具体看代码,贪就完事了 代码 #include<bits/stdc++.h> us ...