C# lambda expressions as function arguments

Question

I've been busy diving into lambda expressions recently, and there's some specific functionality that I've been meaning to learn but just couldn't seem to make heads or tails of.

Suppose that I have the following logic in my code:

List<A> foo; // assuming this is populated
string[] bar = foo.Select<A,string>(x => x.StringProperty).ToArray<string>();

Now, I want to perhaps abstract that whole operation into a handler method so that I can do this instead:

string[] bar = MakeArray<A,string>(foo, x => x.StringProperty);
int[] foobar = MakeArray<A,int>(foo, x => x.IntegerProperty);

How would I go about with writing that method's body? I foresee declaring the signature as something like:

U[] MakeArray<T,U>( /* some lambda magic? */ ) where T : IEntity {}

but I don't know how to specify that I'm expecting a lambda expression as the method argument, and how that translates exactly into the body of the method.

Can anybody show me how to create the MakeArray() function above? I'm pretty sure that once I see how it's done, that I can pick it up from there.

EDIT

As pointed out in the comments, MakeArray() needed a reference to the IEnumerable<>. Updated to reflect that.

FWIW the implicit nature of the generics can add a readable value to your code by not having to explicitly state the type with each statement, this could be subjective though. The following statement is equal to your first select.. `string[] bar = foo.Select(x => x.StringProperty).ToArray();` — Quintin Robinson, Mar 22 '11 at 19:36
If you find yourself using arrays all over your code, you may want to consider refactoring them into `IEnumerable` or `IList`. Then none of this will be necessary. Also, doesn't `MakeArray` need a reference to foo? — BlueRaja - Danny Pflughoeft, Mar 22 '11 at 19:44
@Quintin ~ Yeah, I kind of just like the generics explicitly stated (when applicable) just so it's clear what I'm pulling out. You're correct though. — Richard Neil Ilagan, Mar 22 '11 at 19:45
@BlueRaja ~ nah, the array thing is just to illustrate. But, I see your point though! — Richard Neil Ilagan, Mar 22 '11 at 19:47

score 16 · Accepted Answer · answered Mar 22 '11 at 19:34

16

public static U[] MakeArray<T, U>(this IEnumerable<T> @enum, Func<T, U> rule)
{
    return @enum.Select(rule).ToArray();
}

answered Mar 22 '11 at 19:34

Yuriy Faktorovich

67,283
14
105
142

+1 thanks! I'm going with this answer for showing how exactly the Func<> parameter that comes into the method is used. real helpful. – Richard Neil Ilagan Mar 22 '11 at 19:44

JaredPar · Answer 2 · 2011-03-22T19:44:46.967

13

Try the following

U[] MakeArray<T,U>(Func<T, U> projection) where T : IEntity {
  ...
}

When passing lambdas as arguments you generally want the matching parameter to be a delegate. In most cases you should just use the appropriate Action<> or Func<> value. The former for void returning lambdas and the latter for ones that return values.

edited Mar 22 '11 at 19:44

answered Mar 22 '11 at 19:32

JaredPar

733,204
149
1,241
1,454

score 2 · Answer 3 · answered Mar 22 '11 at 19:32

2

You're looking for Action<> and Func<>.

answered Mar 22 '11 at 19:32

devoured elysium

101,373
131
340
557

score 2 · Answer 4 · answered Mar 22 '11 at 19:33

2

You can use the Func and Action classes. Check out the LINQ Where function's signature for an example: http://msdn.microsoft.com/en-us/library/bb534803.aspx

answered Mar 22 '11 at 19:33

David V

11,531
5
42
66

Thanks for the link! I always wondered how they implemented all that magic. – Colin Oct 02 '15 at 17:01

score 1 · Answer 5 · answered Mar 22 '11 at 19:40

You can create extension

public static class MakeArrayExtension
{
    public static U[] MakeArray<T, U>(this IEnumerable<T> collection, Func<T,U> func)
    {
        return collection.Select(func).ToArray();
    }
}

And then use it like this

List<A> foo; // assuming this is populated
string[] bar = foo.MakeArray<A,string>(x => x.StringProperty);

C# lambda expressions as function arguments

5 Answers5

Linked