You can do this by using an open generic type definition, and then making the specific type from that: typeof(Func<,>).MakeGenericType(typeof(int), orderType); However, what you’re trying to do (calling Lambda<TDelegate>) is not directly possible. You must call Lambda without a type parameter: var propertyinfo = typeof(T).GetProperty(sortExpressionStr); Type orderType = propertyinfo.PropertyType; var param = Expression.Parameter(typeof(T), “x”); var … Read more
Yes, the MS implementation of anonymous methods effectively creates one hidden class per level of scope that it needs to capture variables from, and captures all the relevant variables from that scope. I believe this is done for the sake of simplicity, but it can indeed increase the lifetime of some objects unnecessarily. It would … Read more
Eric Lippert recently wrote a series of blog posts about why yield is not allowed in some cases. Part 1 Part 2 Part 3 Part 4 Part 5 Part 6 EDIT2: Part 7 (this one was posted later and specifically addresses this question) You will probably find the answer there… EDIT1: this is explained in … Read more
Lambdas in C# do not have types, until they are used in a context that casts them to a delegate or Expression type. That’s why you cannot do the following: var x = () => “some lambda”; You might enjoy Eric Lippert’s Series on Lambda Expressions vs Anonymous Methods Lambda vs Anon – Part One … Read more
Yes there is a very good reason for why you cannot do this. The simple reason is cost. The cost of enabling this feature in C# (or VB) is extremely high. Editing a lambda function is a specific case of a class of ENC issues that are very difficult to solve with the current ENC … Read more
There’s an MSDN page that talks about this: How to Subscribe to and Unsubscribe from Events Note in particular: If you will not have to unsubscribe to [sic] an event later, you can use the addition assignment operator (+=) to attach an anonymous method to the event. And also: It is important to notice that … Read more
Because Invoke/BeginInvoke accepts Delegate (rather than a typed delegate), you need to tell the compiler what type of delegate to create ; MethodInvoker (2.0) or Action (3.5) are common choices (note they have the same signature); like so: control.Invoke((MethodInvoker) delegate {this.Text = “Hi”;}); If you need to pass in parameters, then “captured variables” are the … Read more
Give your instance of the anonymous delegate a name: EventHandler<NewEventArg> handler = delegate(object sender, NewEventArgs e) { //some code }; Subject.NewEvent += handler; Subject.NewEvent -= handler;
Short answer : no. Longer answer that may not be relevant: If you assign the lambda to a delegate type (such as Func or Action) you’ll get an anonymous delegate. If you assign the lambda to an Expression type, you’ll get an expression tree instead of a anonymous delegate. The expression tree can then be … Read more
Action myDelegate = delegate(){Console.WriteLine(“I did it!”);}; MyEvent += myDelegate; // …. later MyEvent -= myDelegate; Just keep a reference to the delegate around.