上一篇 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 {
get
;
protected
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 {
get
;
private
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 {
get
;
protected
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 {
get
;
protected
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(
null
)
as
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(
null
)
as
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);
}
|
本文为转载文章，如有任何问题，请按下面原文链接访问！
383
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
