Please in a normal and human way explain to me the difference OK, let’s make some toast. That’s the most normal human thing I do. Pull based: // I want some toast. I will pull it out of the toaster when it is done. // I will do nothing until the toast is available. Toast … Read more
.Any(predicate) sounds like what you want; returns bool, returning true as soon as a match is found, else false. There is also: .All(predicate) which behaves in a similar way, returning false as soon as a non-match is found, else true.
Found it: Assert.IsTrue(expected.SequenceEqual(actual));
It is worth noting that the list method is a lot older than the extension method. The naming was likely kept the same as Reverse seems more succinct than BackwardsIterator. If you want to bypass the list version and go to the extension method, you need to treat the list like an IEnumerable<T>: var numbers … Read more
All you need to do for the default case is: queryRes = values.OrderBy(a => 1); This will effectively be a noop sort. Because the OrderBy performs a stable sort the original order will be maintained in the event that the selected objects are equal. Note that since this is an IQueryable and not an IEnumerable … Read more
yield return works for exactly 4 cases: IEnumerable IEnumerable<T> IEnumerator IEnumerator<T> This is because it has to build a state machine internally; a dictionary (etc) wouldn’t be possible with this. You can of course just return a suitable type instead.
var sums = Orders.GroupBy(x => new { x.CustomerID, x.ProductID }) .Select(group => group.Sum(x => x.ProductCount));
I don’t know exactly what your properties really is here – but if it’s essentially representing an unmaterialized database query, then your if statement will perform three queries. I suspect it would be better to do: string[] propertiesToFind = { “Property1”, “Property2”, “Property3” }; if (properties.Any(x => propertiesToFind.Contains(x)) { … } That will logically only … Read more
I don’t believe there’s anything built into LINQ to do this. There’s a problem with doing it recursively like this – you end up creating a large number of iterators. This can be quite inefficient if the tree is deep. Wes Dyer and Eric Lippert have both blogged about this. You can remove this inefficiency … Read more
First off “Better” includes a combination of performance (memory and speed) In general you can’t have both, the rule of thumb is, if you optimise for speed, it’ll cost memory, if you optimise for memory, it’ll cost you speed. There is a better option, that performs well on both memory and speed fronts, and can … Read more