转载: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. Android 解决启动页白屏或者黑屏的问题

    欢迎页启动的线程由于请求和处理的数据量过大而,导致欢迎页在出现之前界面上会有一个短暂的白色闪屏停留,当然白色闪屏的停留是因为 application 的主题样式android:theme=@style ...

  2. java中使用阻塞队列实现生产这与消费这之间的关系

    需求如下: 有一个生产者和一个消费者,生产者不断的生产产品,消费这不断的消费产品.产品总数为N. 1.生产顺序按队列的方式,先进先出. 2.生产者和消费这可以同时进行. 3.当生产者生产了N个产品后不 ...

  3. Shiro的认证授权

    shiro安全框架入门整理 package com.shiro.test; import org.apache.shiro.SecurityUtils; import org.apache.shiro ...

  4. RabbmitMQ-组成及简单使用

    什么是MQ? MQ全程Message Queue,消息队列(MQ)是一种应用程序对应用程序的通信方法.MQ是消费者-生产者模型的典型代表.一端往消息队列中不断写消息而另一端则可以读取队列中的消息. R ...

  5. 数列分块入门九题(一):LOJ6277~6279

    Preface 分块,一个神奇的暴力算法.可以把很多\(O(n^2)\)的数据结构题的暴力优化到常数极小的\(O(n\sqrt n)\).当一些毒瘤题无法用线段树,主席树,平衡树,树状数组...... ...

  6. POJ1850&&1019&&1942

    这三道题都水的难以想象,所以就放在一起写 1850 题目大意:有一种一种序列排列方式(如同题目中给出的例子),然后给你一个序列,问你这个序列的排名 首先我们先判断无解的情况,这个就很简单了. 由于题目 ...

  7. Zookeeper Ephemeral结点使用心得

    原文地址:https://www.cnblogs.com/linlemo/p/4807178.html 公司里面在拿Zookeeper做命名服务,通过使用ZK,前端只需要根据指定的ZK地址获得相应的资 ...

  8. Shell学习笔记二

    一.调试脚本 调试功能是每一种编程语言都应该实现的重要特性之一,当出现一些始料未及的情况时,用它来生成脚本运行信息.调试信息可以帮你弄清楚是什么原因使得程序发生崩溃或行为异常.每位系统程序员都应该了解 ...

  9. Visual Studio 2013编辑器+SourceTree代码管理工具及扩展工具

    Visual Studio 2013: 美国微软公司的编辑开发工具 扩展工具: Resharper:进行深度代码分析,函数深度查询(ctrl+鼠标左): Grunt:是基于Node.js的项目以自动化 ...

  10. 《Linux内核设计与实现》读书笔记 3

    第三章 进程管理 3.1进程 概念: 进程:处于执行期的程序.但不仅局限于程序,还包含其他资源(打开的文件,挂起的信号,内核内部数据,处理器状态,一个或多个具有内催音社的内存地址空间及一个或多个执行线 ...