斐波那契数列

public int Factorial(int n)
{
    return (n <= 2) ? 1 : Factorial(n - 1) + Factorial(n - 2);
}

public int FactorialFunc(int value)
{
    Func<int, int> factorial = null;
    factorial = n => (n <= 2) ? 1 : factorial(n - 1) + factorial(n - 2);
    return factorial(value);
}

public Expression<Func<T, T>> MakeFactorialExpression<T>()
{
    var nParam = Expression.Parameter(typeof(T), "n");
    var methodVar = Expression.Variable(typeof(Func<T, T>), "factorial");
    var one = Expression.Convert(Expression.Constant(1), typeof(T));
    var two = Expression.Convert(Expression.Constant(2), typeof(T));

    return Expression.Lambda<Func<T, T>>(
        Expression.Block(
            // Func<uint, uint> method;
            new[] { methodVar },
            // method = n => ( n <= 2 ) ? 1 : method( n - 2 ) + method( n - 1 );
            Expression.Assign(
                methodVar,
                Expression.Lambda<Func<T, T>>(
                    Expression.Condition(
                        // ( n <= 2 )
                        Expression.LessThanOrEqual(nParam, two),
                        // 1
                        one,
                        // method( n - 2 ) + method( n - 1 )
                        Expression.Add(
                            // method( n - 2 )
                            Expression.Invoke(
                                methodVar,
                                Expression.Subtract(nParam, two)),
                            // method( n - 1 )
                            Expression.Invoke(
                                methodVar,
                                Expression.Subtract(nParam, one))
                            )
                        ),
                    nParam
                    )
                ),
            // return method( n );
            Expression.Invoke(methodVar, nParam)),
        nParam);
}

Recursive Methods in Expression Trees | Chris Cavanagh’s Blog (wordpress.com)