I'm Loving the .NET Fx ARM

Saturday, April 10, 2004

I enjoyed the annotations in The .NET Framework Standard Library Annotated Reference so much that I read them all in one sitting (in the bathtub, if you must know...). The annotations are where the authors put in their 2 cents about a particular class, method or property and it was very interesting. Here's what I learned just from that part of the book:

• You shouldn't use ApplicationException for custom exceptions. Derive from Exception instead.
   
• Because ICloneable.Clone doesn't define whether it returns a deep or a shallow copy, it's practically worthless.
   
• Prefer UTF-8 because it takes up the same amount of space to represent ASCII characters as ASCII, but can also represent all Unicode characters (I knew that UTF-8 took up the same amount of space but hadn't yet jumped to "prefer").
   
• I was reminded of the System.Convert class, which does all of the same conversions that the various type-specific ToXxx and Parse methods do, but puts them all in one place.
   
• There's another use for the private interface method implementation syntax in C#:
  

  class Enum : IEnumerator {
    object IEnumerator.Current { get { return this.foo; } }
    ...
  }
  

  This syntax hides an interface method from general use unless you cast to the interface base class:
  

  Enum enum = new Enum();
  object obj1 = enum.Current(); // compile-time error
  object obj2 = (IEnumerator)enum.Current(); // this works	
  

  The thing I never thought of that this enables is that it lets you override based on return type, which isn't normally allowed in C#:

  class Enum : IEnumerator {
    object IEnumerator.Current { get { return this.foo; }
    Foo Current { get { return this.foo; } }
    ...
  }
  

  This private method implementation syntax lets you return the generic type as part of the interface implementation so that you can plug into standard idioms, e.g. foreach, but a more specific type for users of the type directly, saving the cast:
  

  Enum enum2 = new Enum();
  Foo foo1 = (Foo)((IEnumerator)enum.Current());
  Foo foo2 = enum.Current(); // no cast required

  This will be less interesting as generics take over, but still, it's a useful trick.
   
• DateTime is always assumed to represent local time, so if you convert to Universal time twice, you'll change the value each time.
   
• Since it's possible to cast any number to an enum value, e.g. TrueFalseEnum tfe = (TrueFalseEnum)42, make sure to always check that an enum is a legal value. Theoretically this is a pain, but in practice, I tend to check enum values with switch statements, making the default case the error case, so it's good to know that my code does the right thing.
   
• The Threading.Interlocked class.
   
• Jim Miller has way more birthdays than we do. : )
   
• Jeff Richter agrees with me that the ThreadStart delegate needs an object parameter.
   
• I should be using CompareInfo instead of ToLower for case-insensitive comparisons (although they don't show how):

  using System.Globalization;
  using System.Threading;
  ...
  CompareInfo compare = Thread.CurrentThread.CurrentCulture.CompareInfo;
  
  if( compare.Compare("foo", "FOO", CompareOptions.IgnoreCase) == 0 ) {
    Console.WriteLine("the same");
  }

If I can get that much out of just the annotations, imagine what I could learn if I read the whole thing. : )

Discuss