Sign In
Fabulous Adventures In Coding
Eric Lippert's Blog
Tags
Aargh! (8)
accuracy (6)
Arrays (8)
ASP (11)
AStar (5)
Async (15)
bad jokes (14)
Begging the question (4)
Benford's Law (3)
Best Of FAIC (12)
Big Words (5)
Books (23)
Breaking Changes (24)
Brittle Base Classes (6)
C# (327)
C# 4.0 (39)
C# 5.0 (10)
Cargo Cult Programming (4)
cast operator (3)
Channel 9 (6)
Charts (6)
closures (3)
Code Generation (10)
Code Quality (29)
COM Programming (57)
Conditional Operator (3)
Continuation Passing Style (11)
Conversions (16)
Covariance and Contravariance (22)
customer service (4)
declaration spaces (5)
definite assignment (3)
Dialogue (14)
English Usage (11)
exception handling (9)
Floating Point Arithmetic (15)
grammars (9)
graph colouring (5)
GUIDs (4)
Hashing (9)
High Dimensional Spaces (5)
Immutability (27)
integer arithmetic (5)
Interviewing (8)
Introduction (6)
It Hurts When I Do This (5)
Iterators (10)
JScript (93)
JScript .NET (29)
keywords (4)
Lambda Expressions (20)
Language Design (62)
local variables (3)
localization (3)
Mathematics (18)
Memory Management (13)
Metablogging (9)
Mistakes (6)
Music (6)
myths (7)
namespaces (5)
Non-computer (37)
Optional arguments (5)
Overload Resolution (9)
Pages (25)
Performance (48)
precedence (4)
precision (7)
protected (7)
Puzzles (49)
quotable quotations (4)
Rants (51)
Rarefied Heights (52)
reachability (4)
Recursion (26)
reference (4)
Regular Expressions (13)
Relationships (4)
Salt (4)
Science (12)
scope (5)
Scripting (189)
Security (47)
shadowcasting (6)
SimpleScript (30)
Software development methodology (13)
Static Methods (6)
Threading (18)
Topological Sort (4)
Type Inference (18)
type safety (4)
unsafe code (4)
Value Types (11)
VBScript (80)
Video (12)
virtual dispatch (9)
VSTO (10)
warnings (5)
What's The Difference? (11)
Zombies (4)
Browse by Tags
MSDN Blogs
>
Fabulous Adventures In Coding
>
All Tags
>
c# 4.0
Tagged Content List
Blog Post:
Breaking changes and named arguments
Eric Lippert
Before I get into the subject of today's post, thanks so much to all of you who have given us great feedback on the Roslyn CTP. Please keep it coming . I'm definitely going to do some articles on Roslyn in the future; the past few weeks I have been too busy actually implementing it to write much about...
on
7 Nov 2011
Blog Post:
Optional argument corner cases, part four
Eric Lippert
(This is the fourth and final part of a series on the corner cases of optional arguments in C# 4; part three is here .) Last time we discussed how some people think that an optional argument generates a bunch of overloads that call each other. People also sometimes incorrectly think that void M(string...
on
19 May 2011
Blog Post:
Optional argument corner cases, part three
Eric Lippert
(This is part three of a series on the corner cases of optional arguments in C# 4; part two is here . Part four is here .) A lot of people seem to think that this: void M(string x, bool y = false) { ... whatever ... } is actually a syntactic sugar for the way you used to have to write this in C#, which...
on
16 May 2011
Blog Post:
Optional argument corner cases, part two
Eric Lippert
(This is part two of a series on the corner cases of optional arguments in C# 4. Part one is here . Part three is here . This portion of the series was inspired by this StackOverflow question .) Last time we saw that the declared optional arguments of an interface method need not be optional arguments...
on
12 May 2011
Blog Post:
Optional argument corner cases, part one
Eric Lippert
(This is part one of a series on the corner cases of optional arguments in C# 4. Part two is here .) In C# 4.0 we added "optional arguments"; that is, you can state in the declaration of a method's parameter that if certain arguments are omitted, then constants can be substituted for them: void M(int...
on
9 May 2011
Blog Post:
So many interfaces!
Eric Lippert
Today, another question from StackOverflow , and again, presented as a dialogue as is my wont. The MSDN documentation for List<T> says that the class is declared as public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable Does List<T>...
on
4 Apr 2011
Blog Post:
Optional arguments on both ends
Eric Lippert
Before we get into today's topic, a quick update on my posting from last year about Roslyn jobs. We have gotten a lot of good leads and made some hires but we still have positions open, both on the Roslyn team and on the larger Visual Studio team. For details, see this post on the Visual Studio blog...
on
10 Feb 2011
Blog Post:
The Annotated Fourth Edition is available
Eric Lippert
A brief digression from C# 5 to talk about C# 4: the annotated C# 4 specification is now available in book form from Addison-Wesley . It is of course handy to have a specification in book form, particularly if you're going to while away the hours with the book sitting by a warm fire. (It's hundreds of...
on
15 Nov 2010
Blog Post:
Teach Yourself C# In... how long?
Eric Lippert
Earlier this year I was the technical editor of " Teach Yourself Visual C# 2010 in 24 Hours " by Scott Dorman, and I am pleased to announce that it is available in stores now. Scott has pretty much completely rewritten this from the previous edition to ensure that it is totally up-to-date for C# 4. If...
on
13 Sep 2010
Blog Post:
Better late than never
Eric Lippert
Good heavens, I just realized I completely forgot to post a link to this interview . I'm a year late, but better late than never. A year ago Ken stopped by my office and we had a very freewheeling, entertaining and rather random conversation about many diverse aspects of programming language design...
on
7 Jun 2010
Blog Post:
It's Essential!
Eric Lippert
My copy of Essential C# 4.0 just arrived, and it looks great. I was one of the technical reviewers of this book. Some books are a pain to edit, but the Essential C# series is one of my favourites. It totally lives up to its name; it really does give you lots of essential information for developing high...
on
15 Apr 2010
Blog Post:
Some Last-Minute New C# 4.0 Features
Eric Lippert
As I’m sure you know by now, we are done implementing C# 4. We’ve added support for interoperability with dynamic languages and legacy object models, named and optional parameters, the ability to “link” against interfaces from a Primary Interop Assembly, and my favourite feature, covariance and contravariance...
on
1 Apr 2010
Blog Post:
How Many Passes?
Eric Lippert
Large bodies of code written in the C/C++ languages typically divide up the code into “header” files, which are just declarations of methods and types (and definitions of macros). The actual bodies of those methods and types are in completely different files. People sometimes ask me why doesn’t C#...
on
4 Feb 2010
Blog Post:
Exact rules for variance validity
Eric Lippert
I thought it might be interesting for you all to get a precise description of how exactly it is that we determine when it is legal to put "in" and "out" on a type parameter declaration in C# 4. I'm doing this here because (1) it's of general interest, and (2) our attempt to make a more human-readable...
on
3 Dec 2009
Blog Post:
What's the difference between covariance and assignment compatibility?
Eric Lippert
I've written a lot about this already, but I think one particular point bears repeating. As we're getting closer to shipping C# 4.0, I'm seeing a lot of documents, blogs, and so on, attempting to explain what "covariant" means. This is a tricky word to define in a way that is actually meaningful to...
on
30 Nov 2009
Blog Post:
The Purpose, Revealed
Eric Lippert
Interestingly enough, no one correctly guessed why I needed code in the compiler to transform a method argument list into a form that batched up the side effecting expressions, stuck their values in variables, and then called the method with the side-effect-free variable references. There certainly were...
on
25 Nov 2009
Blog Post:
Some new videos
Eric Lippert
Somehow it has happened again; people just keep on recording videos of me and putting them on the internet. In these videos you find out what I look like when lit from above and behind. Kinda spooky. We should have made the room entirely dark and held a flashlight underneath my face. That would be...
on
26 Oct 2009
Blog Post:
Why No Extension Properties?
Eric Lippert
I'm frequently asked "you guys added extension methods to C# 3, so why not add extension properties as well?" Good question. First, let me talk a bit about C# 3. Clearly the big feature in C# 3 was LINQ. In a sense we had only three features in C# 3: everything necessary for LINQ -- implicitly...
on
5 Oct 2009
Blog Post:
What's the difference, part one: Generics are not templates
Eric Lippert
Because I'm a geek, I enjoy learning about the sometimes-subtle differences between easily-confused things. For example: I'm still not super-clear in my head on the differences between a hub , router and switch and how it relates to the gnomes that live inside of each. Hunks of minerals found...
on
30 Jul 2009
Blog Post:
Reserved and Contextual Keywords
Eric Lippert
Many programming languages, C# included, treat certain sequences of letters as “special”. Some sequences are so special that they cannot be used as identifiers. Let’s call those the “reserved keywords” and the remaining special sequences we’ll call the “contextual keywords”. They are “contextual” because...
on
11 May 2009
Blog Post:
Zip Me Up
Eric Lippert
Suppose you’ve got a sequence of Foos and you want to project from that a sequences of Bars. That’s straightforward using LINQ: IEnumerable<Bars> bars = from foo in foos select MakeBar(foo); or, without the query sugar: IEnumerable<Bars> bars = foos.Select(foo=>MakeBar(foo));...
on
7 May 2009
Blog Post:
Locks and exceptions do not mix
Eric Lippert
A couple years ago I wrote a bit about how our codegen for the lock statement could sometimes lead to situations in which an unoptimized build had different potential deadlocks than an optimized build of the same source code. This is unfortunate, so we've fixed that for C# 4.0. However, all is still...
on
6 Mar 2009
Blog Post:
The Future Of C#, Part Five
Eric Lippert
When we're designing a new version of the language, something we think about a lot is whether the proposed new features "hang together". Having a consistent "theme" to a release makes it easier for us to prioritize and organize proposals, it makes it easier for our marketing and user education people...
on
7 Nov 2008
Blog Post:
The Future of C#, Part Four: Yet More Video
Eric Lippert
Mads, Chris, Sam and me on Channel Nine. Enjoy.
on
2 Nov 2008
Blog Post:
The Future of C#, Part Three: On video, plus the dead-trees edition
Eric Lippert
Amazingly enough, it has happened again . Why does this keep happening to me? Anders, Mads and Eric on C# 4.0: C# 4.0 with Anders Hejlsberg, Mads Torgersen, and Eric Lippert - Part 1 of 2 C# 4.0 with Anders Hejlsberg, Mads Torgersen, and Eric Lippert - Part 2 of 2 Anders, Mads and Scott on...
on
29 Oct 2008
Page 1 of 2 (39 items)
1
2