anonymous-methods

Why the C# 7 Compiler turns Local Functions into methods within the same class where their parent function is. While for Anonymous Methods (and Lambda Expressions) the compiler generates a nested class for each parent function, that will contain all of its Anonymous Methods as instance methods ? For example, C# code (Anonymous Method) : internal class AnonymousMethod_Example { public void MyFunc(string[] args) { var x = 5; Action act = delegate () { Console.WriteLine(x); }; act(); } } Will produce IL Code (Anonymous Method) similar to: .class private auto ansi beforefieldinit AnonymousMethod

This question may be very similar to my one, but I cannot see the answer I need in it. I have a class, called CASM , that has a List<Action> . I want to serialize this class (using the BinaryFormatter or something similar). This class and all classes referenced in the Action s have got correct [Serializable] and [NonSerializable] attributes. The problem comes when serialization is attempted - it gives this error: Type 'CASM.CASM+<>c__DisplayClass2c' in Assembly 'CASM, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' is not marked as serializable. This <>c__DisplayClass2c is an

This is not a dupe of Calling a method with ref or out parameters from an anonymous method I am wondering why out parameters are not allowed within anonymous methods. Not allowing ref parameters makes a bit more sense to me, but the out parameters, not as much. what are your thoughts on this JaredPar In some ways this is a dupe. Out parameters are ref parameters. There is simply an extra attribute on the value that is used by the C# language. The reason for disallowing them is the exact same as ref parameters. The problem here originates with the effect of using a value declared outside the

is it possible to create an anonymous method in c# from a string? e.g. if I have a string "x + y * z" is it possible to turn this into some sort of method/lambda object that I can call with arbitrary x , y , z parameters? It's possible, yes. You have to parse the string and, for example, compile a delegate using expression trees. Here's an example of creating (x, y, z) => x + y * z using expression trees: ParameterExpression parameterX = Expression.Parameter(typeof(int), "x"); ParameterExpression parameterY = Expression.Parameter(typeof(int), "y"); ParameterExpression parameterZ = Expression

Several C# questions on StackOverflow ask how to make anonymous delegates/lambdas with out or ref parameters. See, for example: Calling a method with ref or out parameters from an anonymous method Write a lambda or anonymous function that accepts an out parameter To do so, you just need to specify the type of the parameter, as in: public void delegate D(out T p); // ... D a = (out T t) => { ... }; // Lambda syntax. D b = delegate(out T t) { ... }; // Anonymous delegate syntax. What I'm curious about is why the type is explicitly required. Is there a particular reason that this is the case?

With the advent of new features like lambda expressions (inline code), does it mean we dont have to use delegates or anonymous methods anymore? In almost all the samples I have seen, it is for rewriting using the new syntax. Any place where we still have to use delegates and lambda expressions won't work? Yes there are places where directly using anonymous delegates and lambda expressions won't work. If a method takes an untyped Delegate then the compiler doesn't know what to resolve the anonymous delegate/lambda expression to and you will get a compiler error. public static void Invoke