method-group

In a project I'm currently working on, we have many static Expressions that we have to bring in local scope with a variable when we call the Invoke method on them and pass our lambda expressions' arguments to. Today, we declared a static method whose parameter is exactly the type that the query is expecting. So, my coworker and I were messing around to see if we could get this method to do the project in the Select statement of our query, instead of invoking it on the whole object, without bringing it into local scope. And it worked! But we do not understand why. Imagine code like this // old

This question already has an answer here: Can’t assign to delegate an anonymous method with less specific parameter type 3 answers The second test method below does not compile (cannot convert lambda expression to target type D1 ). Does that mean that (non-generic) delegate contravariance does not work with lambda expressions? [TestFixture] public class MyVarianceTests { private abstract class Animal {} private class Tiger : Animal {} private delegate Type D1(Tiger tiger); private static Type M1(Animal animal) { return animal.GetType(); } [Test] public void ContravariantDelegateWithMethod() {

I discovered something very strange that I'm hoping to better understand. var all = new List<int[]>{ new int[]{1,2,3}, new int[]{4,5,6}, new int[]{7,8,9} }; all.ForEach(n => n.ForEach(i => Console.WriteLine(i))); which can be rewritten as: ... all.ForEach(n => n.ForEach(Console.WriteLine)); How is it possible to leave out the lambda expression parameter (i=>) and still have the current item passed to console.WriteLine? Thanks for any insight. -Keith List<T>.ForEach is looking for an Action<T> . When you write n.ForEach(Console.WriteLine); what you have here is one of the members of the method

I'm interesting in some design choices of C# language. There is a rule in C# spec that allows to use method groups as the expressions of is operator: class Foo { static void Main() { if (Main is Foo) Main(); } } Condition above is always false, as the specification says: 7.10.10 The is operator • If E is a method group or the null literal, of if the type of E is a reference type or a nullable type and the value of E is null, the result is false. My questions: what is the purpose/point/reason of allowing to use the C# language element with no runtime representation in CLR like method groups

James Michael Hare recently wrote a blog post about Char static methods. He talks about using a method group to write less-wordy LINQ: if (myString.Any(c => char.IsLower(c))) { xyzzy(); } if (myString.Any(char.IsLower)) { xyzzy(); } // Less wordy FTW! The equivalent in VB.NET would be: If myString.Any(Function(c) Char.IsLower(c)) Then xyzzy() If myString.Any(Char.IsLower) Then xyzzy() 'Compiler error Sadly, I can't do the equivalent of C# here... the compiler tells me that Overload resolution failed because no accessible 'IsLower' accepts this number of arguments ... sadness. I thought it

When dealing with something like a List<string> you can write the following: list.ForEach(x => Console.WriteLine(x)); or you can use a method group to do the same operation: list.ForEach(Console.WriteLine); I prefer the second line of code because it looks cleaner to me, but are there any benefits to this? Well, lets take a look and see what happens. static void MethodGroup() { new List<string>().ForEach(Console.WriteLine); } static void LambdaExpression() { new List<string>().ForEach(x => Console.WriteLine(x)); } This gets compiled into the following IL. .method private hidebysig static void