(1 item) |
|
(1 item) |
|
(5 items) |
|
(1 item) |
|
(1 item) |
|
(2 items) |
|
(2 items) |
|
(4 items) |
|
(1 item) |
|
(6 items) |
|
(2 items) |
|
(4 items) |
|
(1 item) |
|
(4 items) |
|
(2 items) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(2 items) |
|
(2 items) |
|
(5 items) |
|
(3 items) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(3 items) |
|
(1 item) |
|
(1 item) |
|
(2 items) |
|
(8 items) |
|
(2 items) |
|
(7 items) |
|
(2 items) |
|
(2 items) |
|
(1 item) |
|
(2 items) |
|
(1 item) |
|
(2 items) |
|
(4 items) |
|
(1 item) |
|
(5 items) |
|
(1 item) |
|
(3 items) |
|
(2 items) |
|
(2 items) |
|
(8 items) |
|
(7 items) |
|
(3 items) |
|
(7 items) |
|
(6 items) |
|
(1 item) |
|
(2 items) |
|
(5 items) |
|
(5 items) |
|
(7 items) |
|
(3 items) |
|
(7 items) |
|
(16 items) |
|
(10 items) |
|
(27 items) |
|
(15 items) |
|
(15 items) |
|
(13 items) |
|
(16 items) |
|
(15 items) |
In my recent blog on anonymous delegates, I mentioned I was sure I remembered reading an article saying that while inline delegates have access to variables in their enclosing scope, it would only be able to read those variables, not update them.
At the time, I was frustrated that I hadn't been able to locate the article. It has been nagging at me ever since. I craved, if you'll forgive the pun, closure.
Well I finally tracked it down. It was in Erik Meijer's blog. The reason I was unable to find it before is that it wasn't talking directly about C# after all. However, it was talking about closures and mutability, which is on-topic.
Moreover, although it doesn't mention C#, I think I can be excused for having concluded that it was talking in coded terms about a future version of C#. It talks about a 'hypothetical imperative language' which allocates its local variables on the stack. C# v1.x is an imperative language which allocates its local variables on the stack. Moreover, the blog was discussing the problems inherent in supporting closures in such a language. And back when I first read that blog, I knew that C# v2.0 was going to be getting closures (or rather, something very like them: anonymous delegates), so I assumed that this is what he was really talking about. (This was two and a half months before the PDC, so I didn't have access to Whidbey at that point.)
Not a completely unreasonable conclusion, but I was wrong nonetheless... Apparently Erik's 'hypothetical imperative language' was just that - hypothetical - and not in fact a coded reference to the forthcoming C# v2.0. As I mentioned in my earlier blog, C# v2.0 doesn't suffer from the problem Erik described. It allows closures to update variables too. It is able to do this because unlike in C# v1.x, local variables are no longer necessarily stored on the stack.