Browse by Tags

• AStar
• Books
• Breaking Changes
• Brittle Base Classes
• Code Generation
• Code Quality
• COM Programming
• Conversions
• Covariance and Contravariance
• English Usage
• Immutability
• JScript
• JScript .NET
• Lambda Expressions
• Mathematics
• Mistakes
• Performance
• Psychic Debugging
• Puzzles
• Rarefied Heights
• Recursion
• Scripting
• Security
• Static Methods
• Type Inference
• VBScript
• Video
• VSTO

• Mutating Readonly Structs

  Consider this program which attempts to mutate a readonly mutable struct. What happens? struct Mutable { private int x; public int Mutate() { this.x = this.x + 1; return this.x; } } class Test { public readonly Mutable m = new Mutable(); static void Main(string[] Read More... Posted Wednesday, May 14, 2008 7:10 AM by Eric Lippert | 13 Comments Filed under: C#, Immutability

• Trivial Projections Are (Usually) Optimized Away

  OK, computers aren't entirely dumb when it comes to LINQ. Here's an example of a place where we're a bit smarter. Consider the following query: IEnumerable<int> query = from n in number_array orderby n select n; Does this get transformed by the Read More... Posted Monday, May 12, 2008 6:57 AM by Eric Lippert | 6 Comments Filed under: Performance, C#, Immutability

• Computers are dumb

  A few short takes today, from questions I've received recently about LINQ in C# 3.0. The first question was " in the following code, does it really check every single non-negative integer, or does it use the knowledge that once you're beyond ten, you Read More... Posted Friday, May 09, 2008 8:20 AM by Eric Lippert | 11 Comments Filed under: Performance, C#

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

• Protected Member Access, Part Four

  In Part Two I asked a couple of follow-up questions, the first of which was: Suppose you were a hostile third party and you wanted to mess up the parenting invariant. Clearly, if you are sufficiently trusted, you can always use private reflection or unsafe Read More... Posted Friday, May 02, 2008 9:13 AM by Eric Lippert | 0 Comments Filed under: Security, C#

• Why Can't I Access A Protected Member From A Derived Class, Part Two: Why Can I?

  This is a follow-up to my 2005 post on the same subject which I believe sets a personal record for the longest time between parts of a series. (Of course, I didn't know it was a series when I started it.) Please read the previous article in this series, Read More... Posted Friday, March 28, 2008 4:30 PM by Eric Lippert | 34 Comments Filed under: Security, C#, Breaking Changes

• Translating intentions and mechanisms

  Before I get into today's blogging, a quick note about my recent post on How To Not Get A Question Answered . That was certainly not intended to be fishing for compliments or chiding people for never acknowledging help ten years ago; that said, I appreciate Read More... Posted Tuesday, March 25, 2008 10:26 AM by Eric Lippert | 12 Comments Filed under: C#, Lambda Expressions, Code Quality

• Why Do Initializers Run In The Opposite Order As Constructors? Part Two

  As you might have figured out, the answer to last week's puzzle is "if the constructors and initializers run in their actual order then an initialized readonly field of reference type is guaranteed to be non null in any possible call. That guarantee cannot Read More... Posted Monday, February 18, 2008 7:25 AM by Eric Lippert | 37 Comments Filed under: C#, Puzzles, Immutability

• Why Do Initializers Run In The Opposite Order As Constructors? Part One

  Pop quiz! What do you expect the output of this program to be? using System; class Foo { public Foo(string s) { Console.WriteLine("Foo constructor: {0}", s); } public void Bar() { } } class Base { readonly Foo baseFoo = new Foo("Base initializer"); public Read More... Posted Friday, February 15, 2008 3:01 PM by Eric Lippert | 21 Comments Filed under: C#, Puzzles, Immutability

• Immutability in C# Part Eleven: A working double-ended queue

  At long last, let's get to that double-ended queue. Sorry for leaving you in suspense! Last time we came up with a non-solution -- as commenters immediately discovered, the given algorithm and data structure are deeply inefficient. However, the basic Read More... Posted Tuesday, February 12, 2008 3:40 PM by Eric Lippert | 12 Comments Filed under: C#, Immutability

• deque.cs

  public interface IDeque<T> { T PeekLeft(); T PeekRight(); IDeque<T> EnqueueLeft(T value); IDeque<T> EnqueueRight(T value); IDeque<T> DequeueLeft(); IDeque<T> DequeueRight(); bool IsEmpty { get; } } public sealed class Deque<T> Read More... Posted Tuesday, February 12, 2008 3:14 PM by Eric Lippert | 6 Comments Filed under: C#, Immutability

• Immutability in C# Part 10: A double-ended queue

  Based on the comments, the implementation of a single-ended queue as two stacks was somewhat mind-blowing for a number of readers. People, you ain't seen nothing yet. Before we get into the actual bits and bytes of the solution, think for a bit about Read More... Posted Tuesday, January 22, 2008 7:15 AM by Eric Lippert | 28 Comments Filed under: C#, Immutability

• Immutability in C# Part Nine: Academic? Plus my AVL tree implementation

  Good Monday morning all. I have received a lot of good comments on this series so far that I thought I would speak to a bit. Academic? First and foremost, a number of people have asked questions which could be summed up as "isn't this just an academic Read More... Posted Monday, January 21, 2008 4:13 PM by Eric Lippert | 20 Comments Filed under: C#, Immutability

• Immutability in C# Part Eight: Even More On Binary Trees

  Last year we declared a relatively simple interface to represent an immutable binary tree. We noticed that it was different from every other interface that we've declared so far, in that it really said nothing at all about the immutability of the tree. Read More... Posted Friday, January 18, 2008 11:02 AM by Eric Lippert | 7 Comments Filed under: C#, Immutability

• Recent Book News, Part Two

  Two additional quick notes about books: I am also pleased to announce the availability of the C# 3.0 Cookbook , for which I was again lucky enough to be one of the technical reviewers. Many thanks to the authors for giving the shout-out to this blog in Read More... Posted Wednesday, January 16, 2008 10:32 AM by Eric Lippert | 4 Comments Filed under: VSTO, C#, Books