Static Extension Method using Func and Lambda

Guest User

Given the following:-

public static string CommaSeparate(this IEnumerable source, Func func) {     return string.Join(",", source.Select(s => func(s).ToString()).ToArray()); }

I appreciate that a Lambda expression matches a Func delegate in terms of Input maps to Output.

So why does the Lambda in the Select method show s => func(s).ToString(); rather than s => s.ToString();

Thanks

12 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
That's right, there is no difference.

The Select method is not bothered whether you pass it an actual delegate or a lambda expression because the latter is always convertible to a compatible delegate.
Guest User13y ago
I tested it and it works the same, so case and thread closed : )
Guest User13y ago
Thanks Vulpes.

One last question on this topic please if I may...

I found an example of:-

public static List GetValuesAttribute(this IEnumerable source, Func selector)
{
var videos = QueryVideos(HttpContext.Current);

return videos.Where(v => v.Type == "ExampleType")
.Select(selector);
.Distint();
.OrderBy(v => v)
.ToList();
}

Paying attention in particular to the .Select method which is taking the GetValuesAttribute methods' "selector" as the input parameter, instead of using a Lambda...

I wondered what the difference would be compared to my previous example of passing a Lambda into the .Select method like so:-

.Select((s) => func(s).ToString());

Technically speaking I should be able to implement .Select(func); and then in the client code invoke the CommaSeperate Extension method like so:-

CommaSeperate(u => u.UserId.ToString());

Regards
Vulpes13y ago
Yes, it's inferred by the compiler from the code to the right of the => symbol in the lambda expression.

So, if you have:

s => func(s).ToString()

the compiler infers TResult to be string.
Guest User13y ago
Thanks Vulpes I understand.

What threw me was the usage of the Func func as a parameter in the custom CommaSeperate Extension method.

And the fact that the method then uses the Select Extension method which again takes Func as a parameter.

There are a lot of Func delegates flying about in this one method which confused me...

I now appreciate that (s) => func(s).ToString(); is the Lambda expression used in the Select Extension method's parameter to correspond\map to the func parameter of the CommaSeperate Extension method.

PS I assume the Type of TResult that is inferred to be of Type int, is hidden from view? as id expect to see it before the call to the ToString() method!?

(s) => func(s).ToString();

Regards...
Vulpes13y ago
Well, if the method has a parameter of type Func then you either need to pass it a delegate of that type or a lambda expression.

However, the point I was trying to make is that if the input and output types are the same, this doesn't necessarily mean that the input parameter has to be transformed in some way; it can simply be passed out again unmodified. The position would then be similar to having a parameter of type T rather than Func.

The use of Func in this scenario is unlikely to create any overhead when compiled to native code as the JIT should be clever enough to 'optimize away' the function call.
Guest User13y ago
How do you mean map the input parameter to itself with s => s;

I thought that syntax was, input goes to result? which corresponds\maps
with Func if Generic

Or is it a case of finishing the statement like s => s * s; in order to produce the result?
Vulpes13y ago
Quite a lot of the LINQ extension methods make use of a Func delegate if you look down the list for the Enumerable class:

http://msdn.microsoft.com/en-us/library/system.linq.enumerable_methods(v=vs.100).aspx

As you'll see from this list Select is one of them.

Of course, the Func delegate is completely general and if you use Func you can just map the input parameter to itself with s => s.
Guest User13y ago
Thanks Vulpes

Do you know of any other examples in or out of the .NET Framework that use the Lambda mapping syntax:-

(Input) => someMethod(Input) i.e s => func(s);

Is the above only possible due to the Lambda being used within the Select method in which itself has a Func delegate?

As opposed to the more common form when invoking a Func delegate with a Lambda?

(Input) => (Output\Result) i.e s => s;

Regards
Vulpes13y ago
Well, you're starting with a collection of User objects and these are then being transformed by the Func delegate into ints i.e. Func takes a User object as a parameter and returns an int.

ToString() is then applied to each int which enables an array of strings to be generated and hence a single comma separated string to be produced using the String.Join method.
Guest User13y ago
Thanks Vulpes.

The Type parameters for Func when the code is executed are T = User and U = Int

So given s => func(s).ToString();

Why does s hold and pass User to Func when it is already User?
Vulpes13y ago
The method is doing more than just producing a comma separated string of the collection members which is what the lambda expression: s=> s.ToString() would do.

It's transforming the members first using Func and then comma separating the results.

Here's a simple example which takes an array of ints, doubles them and then comma separates them:

using System;
using System.Collections.Generic;
using System.Linq;

static class Test
{
static void Main()
{
int[] numbers = {1, 2, 3};
string result = numbers.CommaSeparate(n => 2 * n);
Console.WriteLine(result);
Console.ReadKey();
}

public static string CommaSeparate(this IEnumerable source, Func func)
{
return string.Join(",", source.Select(s => func(s).ToString()).ToArray());
}
}

The output is:

2,4,6