C＃函数和条件运算符

Question

Duplicate

I can do this:

Func<CategorySummary, decimal> orderByFunc;
if (orderBy == OrderProductsByProperty.Speed)
     orderByFunc = x => x.Speed;
else
    orderByFunc = x => x.Price;

Why can't I do this:

Func<CategorySummary, decimal> orderByFunc = (orderBy == OrderProductsByProperty.Speed) ? x => x.Speed : x => x.Price;

Answer 1

The 'type inference' on the conditional operator is not quite good enough, I get a message like

Type of conditional expression cannot be determined because there is no implicit conversion between 'lambda expression' and 'lambda expression'

you can always just be explicit on the right-hand-side, a la

var o = true ? new Func<int,int>(x => 0) : new Func<int,int>(x => 1);

In any case it's just a minor annoyance regarding how the types of lambdas, type inference, and the conditional operator interact.

Answer 2

只需将lambda转换为Func<CategorySummary, decimal> ，它将起作用

Answer 3

An alternative to the suggestions so far - move the conditional inside the lambda expression:

Func<CategorySummary, decimal> orderByFunc = 
    x => (orderBy == OrderProductsByProperty.Speed) ? x.Speed : x.Price;

It may not be suitable in all situations (and it does mean that the check is performed on every invocation) but sometimes it could be useful.

EDIT: As Eric points out, the two are not equivalent. Here's a quick example of how they differ (using explicit casting to get the conditional to work where the operands are lambdas):

using System;

class Test
{   
    static void Main()
    {
        bool likesCheese = false;

        Action outerConditional = likesCheese 
            ? (Action) (() => Console.WriteLine("Outer: I like cheese"))
            : (Action) (() => Console.WriteLine("Outer: I hate cheese"));

        Action innerConditional = () => 
            Console.WriteLine (likesCheese ? "Inner: I like cheese" 
                                           : "Inner: I hate cheese");


        Console.WriteLine("Before change...");
        outerConditional();
        innerConditional();

        likesCheese = true;
        Console.WriteLine("After change...");
        outerConditional();
        innerConditional();
    }
}

Results:

Before change...
Outer: I hate cheese
Inner: I hate cheese
After change...
Outer: I hate cheese
Inner: I like cheese

As you can see, the change to the value of likesCheese only affects the version which has the conditional operator inside the lambda expression. Sometimes this is desirable, sometimes not... but you definitely need to be aware of it.

Answer 4

It's enough to cast only one resulting operand to a target type:

Action showResult = true 
    ? (Action)(() => Console.Write("Hello!"))
    : () => Console.Write("");

It was a little unexpected, but this is how compiler works. And when I think about it, it makes sense now.