Dictionary with delegate or switch?

I am writing a parser which calls some functions dependent on some value.

I can implement this logic with simple switch like this:

switch(some_val)   
{   
    case 0:   
        func0();   
        break;   
    case 1:   
        func1();   
        break;   
}     

or with delegates and a dictionary like this:

delegate void some_delegate();   
Dictionary&开发者_运维技巧lt;int, some_delegate> some_dictionary = new Dictionary<int, some_delegate>();   
some_dictionary[0] = func0;   
some_dictionary[1] = func1;   

some_dictionary[some_value].Invoke();    

Are these two methods equivalent and which is preferred?

I strongly prefer the dictionary choice, because with an initializer, it can be a lot more compact and readable:

var actions = new Dictionary<int, Action>
{
  {1, () => Console.WriteLine("One!")},
  {2, () => Console.WriteLine("Two!")}
}

Also, you have some more flexibility; you can add conditions and actions programatically, which is often handy, depending on what you're doing.

In terms of access, they're identical: both just check if that specific value has a corresponding result. However, a Dictionary will throw an out-of-bounds exception if you try to access a non-existent key.

The choice should primarily be on re-usability. If you only need to make this branching logic at one point, then using a switch-case is probably makes more sense than storing a variable. If you need to access it repeatedly in separate points, then use the Dictionary to save yourself from just re-pasting the switch-statement repeatedly.

If the typical programmer on your team is anything like the ones I often deal with, you should go for the simplest option i.e. the switch. The delegates seem to me like a 'clever' solution that is not needed.

I like the dictionary approach because it gives you the ability to possibly swap out your lambda expressions as the need arises. This is a great trick for a programmer to keep in their tool bag for cases involving programs using complex decision trees. It would be very unwieldy to modify your switch case blocks at run time and the best answer would end up involving lambdas anyway.

I once had a situation where I needed to create a switch statement dynamically. This method provided a lot more readable solution.

Both do the same (well you should check if the key appears in the dictonary).

It is just a matter of readability. What looks the best for your and more important, what do people reading your code would prefer.

(I think the dictionary)

If you need to switch on strings in a resource file, say for globalization purposes, then you'll need to use the dictionary/delegate approach.