C#: create a do-nothing Action on class instantiation [duplicate]
I have a class that the user can pass an A开发者_运维技巧ction into (or not).
public class FooClass<T> : BaseClass<T>
{
public FooClass()
: this((o) => ()) //This doesn't work...
{
}
public FooClass(Action<T> myAction)
: base(myAction)
{
}
}
Basically, I can't pass null into my base class for the
Action
. But, at the same time I don't want to force my user to pass in an Action
. Instead, I want to be able to create a "do-nothing" action on the fly.You want to say
this(t => { })
Think of it like this. You need t => anonymous-expression-body
. In this case, anonymous-expression-body
is an expression
or a block
. You can't have an empty expression so you can't indicate an empty method body with an expression
. Therefore, you have to use a block
in which case you can say { }
to indicate the a block
has an empty statement-list
and is therefore the empty body.
For details, see the grammar specification, appendix B.
And here's another way to think of it, which is a way that you could use to discover this for yourself. An Action<T>
is a method that takes in a T
and returns void
. You can define an Action<T>
via an non-anonymous method or via an anonymous method. You are trying to figure out how to do it using an anonymous method (or rather, a very special anonymous method, namely a lambda expression). If you wanted to do this via a non-anonymous method you would say
private void MyAction<T>(T t) { }
and then you could say
this(MyAction)
which uses the concept of a method group. But now you want to translate this to a lambda expression. So, let's just take that method body and make it a lambda expression. Therefore, we throw away the private void MyAction<T>(T t)
and replace it with t =>
and copy verbatim the method body { }
.
this(t => { })
Boom.
Shouldn't it be curly brackets?
public FooClass()
: this(o => {})
{
}
Lambda form is (/*paramaters*/) => {/*body*}
Parenthesis around the parameters can be omitted, but Curly braces around the body can be omitted only if it's a single (not empty) statement.
精彩评论