Browse by Tags

• Arrays
• Breaking Changes
• C# 4.0
• cast operator
• Channel 9
• Code Generation
• Conversions
• Immutability
• Language Design
• Memory Management
• Performance
• Rarefied Heights
• reference
• Scripting
• type safety
• Video
• werewolves
• What's The Difference?

• Exact rules for variance validity

  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, Read More... Posted Thursday, December 03, 2009 6:32 AM by Eric Lippert | 17 Comments Filed under: C#, Covariance and Contravariance, C# 4.0, Language Design

• What's the difference between covariance and assignment compatibility?

  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 Read More... Posted Monday, November 30, 2009 6:51 AM by Eric Lippert | 18 Comments Filed under: Rarefied Heights, C#, Covariance and Contravariance, C# 4.0, What's The Difference?, werewolves

• Some new videos

  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 Read More... Posted Monday, October 26, 2009 6:17 AM by Eric Lippert | 5 Comments Filed under: C#, Video, Covariance and Contravariance, C# 4.0

• Why is covariance of value-typed arrays inconsistent?

  Another interesting question from StackOverflow : uint[] foo = new uint[10]; object bar = foo; Console.WriteLine("{0} {1} {2} {3}", foo is uint[], // True foo is int[], // False bar is uint[], // True bar is int[]); // True What the heck is going on here? Read More... Posted Thursday, September 24, 2009 6:53 AM by Eric Lippert | 21 Comments Filed under: C#, Covariance and Contravariance, Arrays

• Why do ref and out parameters not allow type variation?

  Here's a good question from StackOverflow : If you have a method that takes an "X" then you have to pass an expression of type X or something convertible to X . Say, an expression of a type derived from X. But if you have a method that takes a "ref X", Read More... Posted Monday, September 21, 2009 6:36 AM by Eric Lippert | 16 Comments Filed under: C#, Conversions, Covariance and Contravariance, type safety, reference

• The void is invariant

  [UPDATES below] A while back I described a kind of variance that we’ve supported since C# 2.0. When assigning a method group to a delegate type, such that both the selected method and the delegate target agree that their return type is a reference type, Read More... Posted Monday, June 29, 2009 7:30 AM by Eric Lippert | 19 Comments Filed under: Scripting, C#, Breaking Changes, Code Generation, Conversions, Covariance and Contravariance, Memory Management

• Representation and Identity

  I get a fair number of questions about the C# cast operator. The most frequent question I get is: short sss = 123; object ooo = sss; // Box the short. int iii = (int) sss; // Perfectly legal. int jjj = (int) (short) ooo; // Perfectly legal int kkk = (int) Read More... Posted Thursday, March 19, 2009 6:46 AM by Eric Lippert | 20 Comments Filed under: Performance, C#, Code Generation, Conversions, Covariance and Contravariance, Language Design, cast operator

• The Future of C#, Part Four: Yet More Video

  Mads, Chris, Sam and me on Channel Nine. Enjoy. Read More... Posted Sunday, November 02, 2008 7:07 AM by Eric Lippert | 8 Comments Filed under: C#, Video, Covariance and Contravariance, C# 4.0, Channel 9

• Covariance and Contravariance, Part Eleven: To infinity, but not beyond

  UPDATE: Andrew Kennedy, author of the paper I reference below, was good enough to point out some corrections and omissions, which I have addressed. Thanks Andrew! As I've discussed at length in this space, we are considering adding covariance and contravariance Read More... Posted Wednesday, May 07, 2008 6:56 AM by Eric Lippert | 20 Comments Filed under: C#, Covariance and Contravariance, C# 4.0

• Immutability in C# Part Three: A Covariant Immutable Stack

  Now suppose we had a hypothetical future version of C# in which interface covariance worked, and we wanted a covariant immutable stack. That is, we want to be able to implicitly convert an IStack<Giraffe> to IStack<Mammal> . As we've already Read More... Posted Thursday, December 06, 2007 7:55 AM by Eric Lippert | 24 Comments Filed under: C#, Covariance and Contravariance, Immutability

• Covariance and Contravariance in C#, Part Ten: Dealing With Ambiguity

  OK, I wasn’t quite done. One more variance post! Smart people: suppose we made IEnumerable<T> covariant in T . What should this program fragment do? class C : IEnumerable<Giraffe>, IEnumerable<Turtle> { IEnumerator<Giraffe> IEnumerable<Giraffe>.GetEnumerator() Read More... Posted Friday, November 09, 2007 11:37 AM by Eric Lippert | 43 Comments Filed under: C#, Covariance and Contravariance, C# 4.0

• Covariance and Contravariance in C#, Part Nine: Breaking Changes

  Today in the last entry in my ongoing saga of covariance and contravariance I’ll discuss what breaking changes adding this feature might cause. Simply adding variance awareness to the conversion rules should never cause any breaking change. However, the Read More... Posted Friday, November 02, 2007 7:33 AM by Eric Lippert | 34 Comments Filed under: C#, Breaking Changes, Covariance and Contravariance, C# 4.0

• Covariance and Contravariance in C#, Part Eight: Syntax Options

  As I discussed last time, were we to introduce interface and delegate variance in a hypothetical future version of C# we would need a syntax for it. Here are some possibilities that immediately come to mind. Option 1: interface IFoo<+T, -U> { T Read More... Posted Wednesday, October 31, 2007 7:48 AM by Eric Lippert | 66 Comments Filed under: C#, Covariance and Contravariance, C# 4.0

• Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

  Suppose we were to implement generic interface and delegate variance in a hypothetical future version of C#. What, hypothetically, would the syntax look like? There are a bunch of options that we could hypothetically consider. Before I get into options Read More... Posted Monday, October 29, 2007 7:32 AM by Eric Lippert | 20 Comments Filed under: C#, Covariance and Contravariance, C# 4.0

• Covariance and Contravariance in C#, Part Six: Interface Variance

  Over the last few posts I’ve discussed how it is possible to treat a delegate as contravariant in its arguments and covariant in its return type. A delegate is basically just an object which represents a single function call; we can do this same kind Read More... Posted Friday, October 26, 2007 7:30 AM by Eric Lippert | 12 Comments Filed under: C#, Covariance and Contravariance, C# 4.0