LINQ "let"

[BillWoodruff]

Hi Marc, I first became aware of the 'Let and 'Into Linq operators through this 2011 CP article (which I down-voted for "lack of original content"): [^]. I have never used them :) because I have never invested the energy to learn to use the "fuller" query syntax (my bad). Your comment makes me wonder what I am missing (other than motivation). cheers, Bill p.s. the Microsoft example of 'Let you cite imho goes to a lot trouble do this:

string[] strings =
{
"A penny saved is a penny earned.",
"The early bird catches the worm.",
"The pen is mightier than the sword."
};

string vowels = "aeiou";

List<string> vowelstartwords = String.Join(" ", strings)
.Split(' ')
.Distinct()
.Where(word => vowels.Contains(Char.ToLower(word[0])))
.ToList();

That example, taken as a programming challenge, interests me: it leaves me wondering if it could be significantly improved in terms of memory use and execution time, and if the Linq code using 'Let would, in fact, improve those usage parameters.

«There is a spectrum, from "clearly desirable behaviour," to "possibly dodgy behavior that still makes some sense," to "clearly undesirable behavior." We try to make the latter into warnings or, better, errors. But stuff that is in the middle category you don’t want to restrict unless there is a clear way to work around it.» Eric Lippert, May 14, 2008

[Richard Deeming]

The Cast<T> part isn't a problem for query syntax - you just declare the type on the variable in the from clause:

from T mappedRecord in mappedRecord[typeof(T)]
...

But there's no query syntax keyword for Single, so you still have to call that as a method:

T record = (from T mappedRecord in mappedRecords[typeof(T)]
where mappedRecord.Row == row
select mappedRecord).Single();

I think the method chaining syntax is much cleaner - especially if you use the overload of Single to eliminate the Where call:

T record = mappedRecords[typeof(T)].Cast<T>().Single(r => r.Row == row);

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Richard Deeming]

I'd be inclined to avoid joining the strings just to split them again. I'd also be inclined to use an array of char, rather than searching a string - although I doubt it would make much difference. You've also added a Distinct and a ToList which weren't in the original example. :)

char[] vowels = { 'a', 'e', 'i', 'o', 'u' };

IEnumerable<string> vowelStartWords = strings
.SelectMany(sentence => sentence.Split(' '))
.Where(word => Array.IndexOf(vowels, char.ToLower(word[0])) != -1)
;

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Nish Nishant]

Marc, you probably know this by now, but let is just syntactic sugar for the Select method.

Regards, Nish

---

Website: www.voidnish.com Blog: voidnish.wordpress.com

[Nish Nishant]

Same here, I never got the hang of it - never liked it to be honest, and always use C# method syntax.

Regards, Nish

---

Website: www.voidnish.com Blog: voidnish.wordpress.com

[BillWoodruff]

I'm always delighted to have a chance to learn from your code ! I did add the call to 'Distinct with my first (and only) edit of the original post because I got to thinking that if you had a lot of 'if and 'else and 'and and 'is and 'or, etc., that would eliminate some duplicate calls. edit ... my head spins as I consider the ways you can use Linq to "coalesce collections:" ''SelectMany, 'Aggregate, 'Join, etc. thanks, Bill

«There is a spectrum, from "clearly desirable behaviour," to "possibly dodgy behavior that still makes some sense," to "clearly undesirable behavior." We try to make the latter into warnings or, better, errors. But stuff that is in the middle category you don’t want to restrict unless there is a clear way to work around it.» Eric Lippert, May 14, 2008

[Super Lloyd]

Haha, I have to say I dunno "how to replace let with extension method" so when I want to introduce a variable it's one case where I definitely use linq query syntax over chaining LINQ extension methods....

All in one Menu-Ribbon Bar DirectX for WinRT/C# since 2013! Taking over the world since 1371!

[Mark Whybird]

Console.WriteLine(
string.Join(
"\n",
strings.SelectMany(sentence => sentence.Split(' '))
.Where(word => Array.IndexOf(vowels, char.ToLower(word[0])) != -1)
.Select(vowelWord => $"\"{vowelWord}\" starts with a vowel")))
;

;)

[Richard Deeming]

Shame there's no foreach extension method:

public static class EnumerableExtensions
{
public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
if (source == null) throw new ArgumentNullException(nameof(source));
if (action == null) throw new ArgumentNullException(nameof(action));

    foreach (T item in source)
    {
        action(item);
    }
}

}

Then you could do:

strings.SelectMany(sentence => sentence.Split(' '))
.Where(word => Array.IndexOf(vowels, char.ToLower(word[0])) != -1)
.Select(vowelWord => $"\"{vowelWord}\" starts with a vowel")
.ForEach(Console.WriteLine)
;

:)

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Nicholas Marty]

I think you're mistaking Linq with Linq to SQL. ;-) Depending on the use case you might even gain performance, as an Enumerable is only evaluated when it's needed. As long as you're not accessing the items (or converting it into something other than an IEnumberable with "ToList" or "ToArray") the query isn't evaluated.

[Nicholas Marty]

Well, you could convert the IEnumerable to a List with ToList and call the ForEach method of the List<T> class. Should pretty much equal the foreach loop (as you need to evaluate the query anyways when looping)

[Sander Rossel]

Nicholas Marty wrote:

I think you're mistaking Linq with Linq to SQL. ;-)

I know the difference very well. I was just assuming we were talking about LINQ to SQL/Entities/whatever data source, because if we're talking LINQ to Objects there really isn't any performance issue to talk about :)

Read my (free) ebook Object-Oriented Programming in C# Succinctly. Visit my blog at Sander's bits - Writing the code you need. Or read my articles here on CodeProject.

Simplicity is prerequisite for reliability. — Edsger W. Dijkstra

Regards, Sander

[James Curran]

Now, if your table have appropriately assigned foreign keys, then your Profile object would have a "geekSkills" collection of Skills object, which in turn would have a Category property which would have a Name property. Reducing that to :

var categoryRanks = from s in profile.geekSkills
group s by new {Level = s.Level, Name = s.Category.Name} into g
select new SkillLevelBySkillByCategory() { 
SkillLevel = g.Key.Level, 
SkillLevelCount = g.Count(x => x.Level == g.Key.Level), 
Name = g.Key.Name };

Not having the tables (or schema) makes designing that a bit tricky, so that might be off a bit. (like, i"m pretty sure that SkillLevelCount can be just "g.Count()" but I don't know your data) Now, using LET, we can bring that down to :

var categoryRanks = from s in profile.geekSkills
let sl = new {Level = s.Level, Name = s.Category.Name}
group sl by sl into g
select new SkillLevelBySkillByCategory() {
SkillLevel = g.Key.Level,
SkillLevelCount = g.Count(x => x.Level == g.Key.Level),
Name = g.Key.Name };

Truth, James

[James Curran]

Which "traditional" methods? ADO with DataSets? From my experience, LINQ is trivially slower (but with added type-safety benefits to offset it). BUT, linq makes it very easy to write bad queries. Things like, reading an entire table into an array, and then linearly search through it. SO, it you compare a carefully tuned, DBA written stored procedure against a simple query written by a developer with little experience with databases, well, then, LINQ is going to lose. But, it you compare two well-crafted queries, one in LINQ and one in SQL, then you should be nearly the same (since the LINQ will generate the exact same SQL).

Truth, James

[Nicholas Marty]

Depending on what you're doing with Linq, it can be even faster than a loop – but it can also be slower by more than 100%. If the difference matters is really up to the specific case. I'd guess it doesn't really have a noticeable impact in most cases, as a few milliseconds are negligible.

[louthy]

For a bit of background. LINQ facilitates functors and monads (concepts from functional programming). Simplified: functors are types that 'map' (Select), monads are types that 'bind' (SelectMany). When you do 'from x in y' you're lifting the value out of the monad (get the value wrapped up *in* the monad), doing an operation on it, and then wrapping it back up in the monad. The monad in this case being IEnumerable/IQueryable. There are other types, like Option, Either, Try - see this library: [language-ext] 'let' is essentially the non-monadic assign, it's essentially exactly the same as declaring a local variable. It doesn't do the lifting, and therefore if you did 'let x = list', then it wouldn't extract the value from the list, it will just assign the list. It's most useful in query expressions to pre-calculate a value that will be used many times in subsequent parts of the query; but it can very much allow full functional programming within LINQ expressions.

[Mark Whybird]

I actually thought about a nasty Linq-with-side-effect version with something like

.Select(vowelWord => Console.WriteLine($"\"{vowelWord}\" starts with a vowel"))

but of course you can't, because Console.WriteLine() returns Void. No doubt it would be possible to force something like this, but that'd be silly; it's actually quite neat that C# protects us from such folly. For one thing, it won't evaluate until the IEnumerable is enumerated, so you don't really know when that is just from that line of code.

[Mark Whybird]

Nice.

[Marc Clifton]

James Curran wrote:

Now, if your table have appropriately assigned foreign keys,

They do, but I haven't set up my models yet with EntityRef and EntitySet. I'll have to do that and then play around with what you're suggesting. I'll be really curious to log what the DataContext does! And thank you for the reductions, that was way beyond the call of duty! Marc

Imperative to Functional Programming Succinctly Contributors Wanted for Higher Order Programming Project! Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny

[James Curran]

Marc Clifton wrote:

They do, but I haven't set up my models yet with EntityRef and EntitySet.

That shouldn't be necessary. As long as the tables have the foreign keys defined, both Linq2sql & Entity Framework should create the properties automatically.

Truth, James