October 2007 - Posts

• 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 | 62 Comments Filed under: C#, Covariance and Contravariance

• 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 | 13 Comments Filed under: C#, Covariance and Contravariance

• 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 | 11 Comments Filed under: C#, Covariance and Contravariance

• Covariance and Contravariance In C#, Part Five: Higher Order Functions Hurt My Brain

  Last time I discussed how we could in a hypothetical future version of C# allow delegate types to be covariant in their return type and contravariant in their formal parameter types. For example, we could have a contravariant action delegate: delegate Read More... Posted Wednesday, October 24, 2007 7:06 AM by Eric Lippert | 17 Comments Filed under: C#, Covariance and Contravariance

• Covariance and Contravariance in C#, Part Four: Real Delegate Variance

  In the last two posts I discussed the two kinds of variance that C# already has -- array covariance and member-group-to-delegate conversion covariance (on return types) and contravariance (on formal parameter types). Today I want to generalize the latter Read More... Posted Monday, October 22, 2007 7:39 AM by Eric Lippert | 6 Comments Filed under: C#, Covariance and Contravariance

• Covariance and Contravariance in C#, Part Three: Method Group Conversion Variance

  Last time I discussed how array covariance is broken in C# (and Java, and a number of other languages as well.) Today, a non-broken kind of variance supported by C# 2.0: conversions from method groups to delegates. This is a more complicated kind of variance, Read More... Posted Friday, October 19, 2007 7:13 AM by Eric Lippert | 9 Comments Filed under: C#, Covariance and Contravariance

• Covariance and Contravariance in C#, Part Two: Array Covariance

  C# implements variance in two ways. Today, the broken way. Ever since C# 1.0, arrays where the element type is a reference type are covariant . This is perfectly legal: Animal[] animals = new Giraffe[10]; Since Giraffe is smaller than Animal , and “make Read More... Posted Wednesday, October 17, 2007 8:47 AM by Eric Lippert | 17 Comments Filed under: C#, Covariance and Contravariance

• Covariance and Contravariance in C#, Part One

  I have been wanting for a long time to do a series of articles about covariance and contravariance (which I will shorten to “variance” for the rest of this series.) I’ll start by defining some terms, then describe what variance features C# 2.0 and 3.0 Read More... Posted Tuesday, October 16, 2007 11:04 AM by Eric Lippert | 15 Comments Filed under: C#, Covariance and Contravariance

• Packet Gnomes

  The other morning I got the following question from a reader: I have created a client-server application in C# using asynchronous socket methods [... blah blah blah, a long description of a scenario in which the socket misses packets under certain conditions] Read More... Posted Thursday, October 11, 2007 7:04 AM by Eric Lippert | 16 Comments Filed under: Rants

• Path Finding Using A* in C# 3.0, Part Four

  Finally we are ready to translate our pseudocode into C# 3.0. What do we need to make the algorithm run? We need a start node, a destination node, a function which tells us the exact distance between two neighbours, and a function which tells us the estimated Read More... Posted Wednesday, October 10, 2007 7:17 AM by Eric Lippert | 7 Comments Filed under: Rarefied Heights, C#, AStar

• Path Finding Using A* in C# 3.0, Part Three

  In order to make the A* algorithm work we need to get the lowest-estimated-cost-path-discovered-so-far out of the list of paths under consideration. The standard data structure for doing so is called a “priority queue”. Priority queues are so-called because Read More... Posted Monday, October 08, 2007 7:03 AM by Eric Lippert | 11 Comments Filed under: Rarefied Heights, C#, AStar

• Path Finding Using A* in C# 3.0, Part Two

  In order to implement the A* algorithm in C# 3.0 I am going to need to implement some custom data structures. Today we’ll consider how to implement the “path”. You’ll notice in my description of the algorithm that the only operations we perform on paths Read More... Posted Thursday, October 04, 2007 7:33 AM by Eric Lippert | 24 Comments Filed under: Rarefied Heights, C#, AStar

• Path Finding Using A* in C# 3.0, Part One

  As we get into the home stretch for the Orcas release I’ve been spending a little time lately just playing around implementing some “classic” algorithms and data structures in C#. The one I implemented today is the famous A* algorithm. Surely you’ve played Read More... Posted Tuesday, October 02, 2007 4:31 PM by Eric Lippert | 7 Comments Filed under: Rarefied Heights, C#, AStar