Is there any way to pass the lambda expression as a variable or argument?

Question

I need to pass the lambda query as a parameter, the followings code is sample and I am interesting to find an implement for it, there is samples: some thing like this:

Answer 1

Well, a lambda is nothing but a delegate, so you could have a method like this:

public void DoIt(IEnumerable a, Action<IEnumerable> performThis)
{
  performThis(a);
}

But where's the sense in it? Instead of calling a method that applies your lambda, why not calling it directly as you do in the last lines of your code?

Answer 2

Do you mean something like this:

public void UseLambda<T> (IEnumerable<T> source , Func<T, bool> where, Func<T, bool> order)
{
    if(source != null)
    {
        IOrderedEnumerable<T> orderBy = source.Where(where).OrderBy(order);
        foreach (T value in orderBy)
        {
            Console.WriteLine(value);
        }
    }
}

So that you could call it like so:

UseLambda(numbers, x => x > 6, x => x % 2 == 0);

Answer 3

Check Func(Of T, TResult) Delegate (MSDN)

using System;

public class LambdaExpression
{
   public static void Main()
   {
       Func<string, string> convert = s => s.ToUpper();

       string name = "Dakota";
       Console.WriteLine(convert(name));   
   }
}

From MSDN

The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate. In particular, because many methods of types in the System.Linq namespace have Func(Of T, TResult) parameters, you can pass these methods a lambda expression without explicitly instantiating a Func(Of T, TResult) delegate.

EDIT

Possible solution for your case

static void Main(string[] args) 
{
    List<int> numbers = new List<int> { 10, 24, 9, 87, 193, 12, 7, 2, -45, -2, 9 };
    Func<IEnumerable<int>, IEnumerable<int>> expr = n => n.Where(n1 => n1 > 6).OrderBy(n1 => n1 % 2 == 0).Select(n1 => n1);
    UseLambda<int>(numbers, expr);
}
private static void UseLambda<T>(List<T> numbers, 
                                 Func<IEnumerable<T>, 
                                 IEnumerable<T>> expr) 
{
    var values = expr(numbers);
    foreach (var item in values) {
       Console.WriteLine(item);
    }
}

Answer 4

public void UseLambda<T>(IEnumerable<T> source, Expression<Func<IEnumerable<T>, IEnumerable<T>>> expr)
{
    var items = expr.Compile();

    foreach (var item in items.Invoke(source))
    {
        Console.WriteLine(item.ToString());
    }
}


public void Main()
{
    Expression<Func<IEnumerable<int>, IEnumerable<int>>> expr = s => s.Where(n => n > 6).OrderBy(n => n % 2 == 0).Select(n => n);
    var list = new List<int> { 10, 24, 9, 87, 193, 12, 7, 2, -45, -2, 9 };

    UseLambda(list, expr);
}

Answer 5

If you define your LINQ expressions like this:

Func<IEnumerable<int>, IEnumerable<int>> expr1 =
               l => l.Where(n => n > 6).OrderBy(n => n % 2 == 0).Select(n => n);

Func<IEnumerable<int>, IEnumerable<int>> expr2 = 
               l => l.TakeWhile((n, index) => n >= index);

And your UseLambda method as:

public void UseLambda<T> (IEnumerable<T> source 
                          ,Func<IEnumerable<T>, IEnumerable<T>> lambda)
{
    var items= lambda(source);

    foreach(var item in items)
       Console.Writeline(item.ToString());
    }
}

Then you I think you have what you're looking for.