So, can somebody please help me understand why leveraging the same overload inside of those other methods is failing with that error? Precisely because you’re using a dynamic value (param) as one of the arguments. That means it will use dynamic dispatch… but dynamic dispatch isn’t supported for extension methods. The solution is simple though: … Read more
Normally left joins in LINQ are modelled with group joins, sometimes in conjunction with DefaultIfEmpty and SelectMany: var leftJoin = p.Person.Where(n => n.FirstName.Contains(“a”)) .GroupJoin(p.PersonInfo, n => n.PersonId, m => m.PersonId, (n, ms) => new { n, ms = ms.DefaultIfEmpty() }) .SelectMany(z => z.ms.Select(m => new { n = z.n, m })); That will give a … Read more
It seems like not supporting Extension methods on Object was a design decision in VB. As a result, the only way we could prevent extension methods from completely breaking existing late bound code was to prevent them from being used on anything typed as object. Link
Use an extension method. Ex: namespace ExtensionMethods { public static class MyExtensionMethods { public static DateTime Tomorrow(this DateTime date) { return date.AddDays(1); } } } Usage: DateTime.Now.Tomorrow(); or AnyObjectOfTypeDateTime.Tomorrow();
Let doesn’t have its own operation; it piggy-backs off of Select. You can see this if you use “reflector” to pull apart an existing dll. it will be something like: var result = names .Select(animalName => new { nameLength = animalName.Length, animalName}) .Where(x=>x.nameLength > 3) .OrderBy(x=>x.nameLength) .Select(x=>x.animalName);
When the compiler searches for extension methods, it starts with those declared in classes in the same namespace as the calling code, then works outwards until it reaches the global namespace. So if your code is in namespace Foo.Bar.Baz, it will first search Foo.Bar.Baz, then Foo.Bar, then Foo, then the global namespace. It will stop … Read more
If by “warm up” you refer to JIT’ing then yes – if a method is never called it won’t have been compiled yet, so the very first time you run it it might be slower. Also refer to Does the .NET CLR JIT compile every method, every time?
It’s by explicit design. The problem is that while String most definitely implements IEnumerable<T>, most people don’t think of it, or more importantly use it, in that way. String has a fairly small number of methods. Initially we did not filter extension methods off of String and the result was a lot of negative feedback. … Read more
This is probably one of those rare cases where it makes sense to use an extern alias. In the properties page for the reference to System.Core (i.e. under References, select System.Core, right-click and select “Properties”), change the “Aliases” value to “global,SystemCore” (or just “SystemCore” if it’s blank to start with). Then in your code, write: … Read more
I just used the Reference Source to look into the code for Last and it checks to see if it is a IList<T> first and performs the appropriate O(1) call: public static TSource Last < TSource > (this IEnumerable < TSource > source) { if (source == null) throw Error.ArgumentNull(“source”); IList < TSource > list … Read more