• Switches with a low number of cases can become if statements.
• Switches with reasonably contigious ranges can be turned into the switch instruction. Holes can be patched with a jump target to the default case.
• Switches with a non-zero case can get rebased using an add or sub instruction in order to use the switch instruction again.
• Switches with sparse case values can be turned into nested/hierarchical switch instructions, using any of the above techniques applied.
• Switches on string cases can become if statements, but if there are more than a treshold number (currently 6 IIRC), a Dictionary<string, int> is lazily constructed, using the int values for switch instruction use.

Just a little example:

[MethodImpl(MethodImplOptions.NoInlining)]
static void Bar(int i, out int j)
{
    switch (i)
    {
        case 17:
            j = 1;
            break;
        case 19:
            j = 2;
            break;
        case 20:
            j = 3;
            break;
        case 25:
            j = 4;
            break;
        default:
            j = 0;
            break;
    }
}

Code above got compiled without /o+, so you'll see redundant nop instruction and excessive st/ld pairs in the IL. Using SOS, we dump the IL and the generated assembler:

0:004> !name2ee switch.exe Program.Bar
Module:      000007ff000330d8
Assembly:    switch.exe
Token:       0000000006000002
MethodDesc:  000007ff000340e0
Name:        Program.Bar(Int32, Int32 ByRef)
JITTED Code Address: 000007ff001501d0
0:004> !dumpil 000007ff000340e0
ilAddr = 000000000137207c
IL_0000: nop 
IL_0001: ldarg.0 
IL_0002: stloc.0 
IL_0003: ldloc.0 
IL_0004: ldc.i4.s 17
IL_0006: sub 
IL_0007: switch (IL_0023, IL_0037, IL_0028, IL_002d)
IL_001c: ldloc.0 
IL_001d: ldc.i4.s 25
IL_001f: beq.s IL_0032
IL_0021: br.s IL_0037
IL_0023: ldarg.1 
IL_0024: ldc.i4.1 
IL_0025: stind.i4 
IL_0026: br.s IL_003c
IL_0028: ldarg.1 
IL_0029: ldc.i4.2 
IL_002a: stind.i4 
IL_002b: br.s IL_003c
IL_002d: ldarg.1 
IL_002e: ldc.i4.3 
IL_002f: stind.i4 
IL_0030: br.s IL_003c
IL_0032: ldarg.1 
IL_0033: ldc.i4.4 
IL_0034: stind.i4 
IL_0035: br.s IL_003c
IL_0037: ldarg.1 
IL_0038: ldc.i4.0 
IL_0039: stind.i4 
IL_003a: br.s IL_003c
IL_003c: ret 

Notice the sub instruction to rebase the switch statement and the insertion of case 18 equals default case by a jump to IL_0037 in the switch instruction's table. Case 25 which is further away from the switch range encountered here is handled by fall-through after the switch instruction and a jump to IL_0032. If you'd have a cluster of cases close to 25 again, you'd see another switch instruction being born.

I'll leave it as a good SOS exercise to the reader to perform a !U on the JITTED code address for different platform architectures and unravvle the assember generated...

0:004> !u 000007ff001501d0
Normal JIT generated code
Program.Bar(Int32, Int32 ByRef)
Begin 000007ff001501d0, size 62
...

Also don't forget order of cases in a switch statement doesn't matter, so the techniques described above can be applied even if cases don't appear in a sorted lexical order.

Ion Todirel wrote:



littleguru wrote: does somebody know how to detect if a type is an anonymous type?

why would you want that for?

A few answers that might be useful. In C# 3.0 anonymous types are immutable indeed; there are only getters while the properties can only be set through the constructor (which is created by the compiler). In VB 9.0 anonymous types are mutable except for fields marked with the Key keyword. This is the addition Paul Vick was referring to.

Concerning detection of anonymous types, you're right there's no metadata available that ensures a type is a dynamically cooked up type, neither is there an API to help you out (which wouldn't give any guarantuees anyhow if there's no dedicated piece of metadata). A good heuristic to determine anonymous types is:

- Check for the CompilerGeneratedAttribute using reflection
- Type name contains "AnonymousType"
- Type name starts with either "<>" or "VB$" (these prefixes cannot be used by code written by a developer)
- Type is generic
- Type definition is private (and sealed in C# 3.0)

The code below illustrates this:

static TypeAttributes s_ta = TypeAttributes.NotPublic;

static bool IsAnonymousType(Type t)
{
    return    t.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Length == 1
           && t.IsGenericType
           && t.Name.Contains("AnonymousType") 
           && (t.Name.StartsWith("<>") || t.Name.StartsWith("VB$"))
           && (t.Attributes & s_ta) == s_ta;
}

An alternative is to construct a regex to check the name to be valid against C# 3.0 or VB 9.0 anonymous type naming conventions - which unfortunately aren't official by any means.

Enjoy!

using System;

class Program
{
   static void Main()
   {
      Bar bar = new Bar();

      /*
      bar.Foo = new Foo();
      bar.Foo.Bar = new Bar();
      bar.Foo.Bar.Foo = new Foo();
      */

      Foo foo = bar.IsNull(b => b.Foo).IsNull(f => f.Bar).IsNull(b => b.Foo);
      Console.WriteLine(foo == null);
   }
}

class Bar
{
   public Foo Foo {get;set;}
}

class Foo
{
   public Bar Bar {get;set;}
}

public static class ObjectExtension
{
   public static R IsNull<T,R>(this T value, Func<T,R> func)
      where T : class
   {
      return value == null ? default(R) : func(value);
   }
}

It's not as easy as some kind of proposed ?. operator but it could serve as a workaround, especially when writing query expressions. All it's doing is shortcutting a clumsy nesting of ? : operator uses:

Foo foo = bar != null ? (bar.Foo != null ? (bar.Foo.Bar != null ? (bar.Foo.Bar.Foo != null ? bar.Foo.Bar.Foo : null) : null) : null) : null;

Concerning the ?. operator I do recognize the value as well but I feel it's a bit too late in the Orcas release cycle to design and implement this properly, especially to make it consistent when used in combination with properties and fields, indexers, method invocations, etc, as well as tools functionality such as IntelliSense.

Cheers,
-Bart

Maybe it's useful to show a more complete sample containing an event definition as well.

Let's start with the concept of a delegate, which is an object that can point to a method with a given signature:

delegate int BinOp(int a, int b);

BinOp can point to any method that takes two ints and returns an int. For example:

int Add(int a, int b) { return a + b; }

can be pointed at by a BinOp delegate, like this:

BinOp add = new BinOp(Add);

or even (starting from C# 2.0):

BinOp add = Add; //the same as the code above, just more convenient

One can call the target method a delegate is pointing at by using regular method call syntax on the delegate instance, like this:

add(1,2); //notice the casing of add - we're not calling Add directly but through the delegate created above

For the following, consider a delegate defined like this:

delegate void ChangedEventHandler(object o, ChangedEventArgs e);

Note: there's a generic EventHandler class that provides a shortcut to create typical *EventHandler delegates.


Now we can cook up an event using this delegate. This allows users of a class to "subscribe" to an event by pointing at a method with the appropriate signature:

class Controller
{
   public event ChangedEventHandler StateChanged; //events have a delegate type, in this case ChangedEventHandler

   public void DoWork()
   {
      //do work
      if (StateChanged != null) //make sure someone has subscribed
         StateChanged(this, new ChangedEventArgs(...)); //delegate calling syntax
      //do more work
   }
}

This allows the user of the class to subscribe to the event like this:

Controller ctrl = new Controller();
ctrl.StateChanged += new ChangedEventHandler(ctrl_Changed);

where ctrl_Changed is defined like this:

void ctrl_Changed(object o, ChangedEventArgs e)
{
   //do something to handle the event; o points at the object that raised the event - you can cast it back to Controller
}

Or, using anonymous method syntax in C# 2.0 and higher:

Controller ctrl = new Controller();
ctrl.StateChanged += delegate (object o, ChangedEventArgs e)
{
   //do something to handle the event; o points at the object that raised the event - you can cast it back to Controller
};

Hope this helps.