Reducing Code Complexity on Switch-blocks

switch(x){
 case a:
   A();
   break;
 case b:
   B();
   break;
 ...
}

void A(){
 X();
 Y();
};
void B(){
 X();
 ....
}

public delegate void MatcherMethod(MatchState state, ICodeUnit left, ICodeUnit right);

namespace Jsl.RefactoringExplorer
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using Microsoft.StyleCop.CSharp;
    using Expression = System.Linq.Expressions.Expression;  // Use Linq Expression instead of StyleCop's.

    public static class MatchMethodLookup
    {
        #region Public Methods
        public static IDictionary<type,> BuildLookupTable(Type type)
        {
            // Build a list of all the appropriate methods.
            var methods =
                from method in type.GetMethods(BindingFlags.Public | BindingFlags.Static)
                let parameters = method.GetParameters()
                where method.Name.StartsWith("Match", StringComparison.Ordinal)
                    && parameters.Length == 3
                    && parameters[0].ParameterType == typeof(MatchState)
                    && (parameters[1].ParameterType.IsSubclassOf(typeof(CodeUnit))
                        || parameters[1].ParameterType.IsSubclassOf(typeof(CsElement)))
                    && parameters[2].ParameterType == parameters[1].ParameterType
                select new { method, parameters[1].ParameterType };

            return methods.ToDictionary(
                methodInfo => methodInfo.ParameterType,
                methodInfo => MatchMethodLookup.CreateDelegate(methodInfo.method, methodInfo.ParameterType));
        }
        #endregion Public Methods

        #region Private Methods
        private static MatchState.MatcherMethod CreateDelegate(MethodInfo method, Type parameterType)
        {
            var matchStateParameter = Expression.Parameter(typeof(MatchState), "state");
            var leftParameter = Expression.Parameter(typeof(ICodeUnit), "left");
            var rightParameter = Expression.Parameter(typeof(ICodeUnit), "right");

            var leftAsSpecific = Expression.Convert(leftParameter, parameterType);
            var rightAsSpecific = Expression.Convert(rightParameter, parameterType);

            var methodCallExpression = Expression.Call(method, matchStateParameter, leftAsSpecific, rightAsSpecific);

            return Expression.Lambda(
                methodCallExpression,
                matchStateParameter,
                leftParameter,
                rightParameter).Compile();
        }
        #endregion Private Methods
    }
}

using System;
using System.Collections.Generic;

namespace App
{
	public enum Color
	{
		Red,
		Blue,
		Yellow
	}
	
	public class Tester
	{
		private delegate void Method();
		private static Dictionary<Color,Method> _delegates;
		
		public static void UseSwitch(Color color)
		{
			switch (color)
			{
				case Color.Red:
					Console.WriteLine("Eat a raspberry");
					break;
				case Color.Blue:
					Console.WriteLine("Eat a blueberry");
					break;
				case Color.Yellow:
					Console.WriteLine("Eat a banana");
					break;
			}
		}
		
		public static void UseDictionary(Color color)
		{
			_delegates[color]();
		}
		
		public static void UseRed()
		{
			Console.WriteLine("Eat a raspberry");
		}
		
		public static void UseBlue()
		{
			Console.WriteLine("Eat a blueberry");
		}
		
		public static void UseYellow()
		{
			Console.WriteLine("Eat a banana");
		}
		
		public static void Main()
		{
			_delegates = new Dictionary<Color,Method>();
			_delegates.Add(Color.Red, UseRed);
			_delegates.Add(Color.Blue, UseBlue);
			_delegates.Add(Color.Yellow, UseYellow);
			
			UseSwitch(Color.Red);
			UseDictionary(Color.Yellow);
		}
	}
}

.method public hidebysig static void UseSwitch(valuetype App.Color color) cil managed
{
    .maxstack 1
    .locals init (
        [0] valuetype App.Color color2)
    L_0000: ldarg.0 
    L_0001: stloc.0 
    L_0002: ldloc.0 
    L_0003: switch (L_0015, L_0020, L_002b)
    L_0014: ret 
    L_0015: ldstr "Eat a raspberry"
    L_001a: call void [mscorlib]System.Console::WriteLine(string)
    L_001f: ret 
    L_0020: ldstr "Eat a blueberry"
    L_0025: call void [mscorlib]System.Console::WriteLine(string)
    L_002a: ret 
    L_002b: ldstr "Eat a banana"
    L_0030: call void [mscorlib]System.Console::WriteLine(string)
    L_0035: ret 
}

.method public hidebysig static void UseDictionary(valuetype App.Color color) cil managed
{
    .maxstack 8
    L_0000: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 App.Tester::_delegates
    L_0005: ldarg.0 
    L_0006: callvirt instance !1 [mscorlib]System.Collections.Generic.Dictionary`2::get_Item(!0)
    L_000b: callvirt instance void App.Tester/Method::Invoke()
    L_0010: ret 
}

.method public hidebysig static void UseRed() cil managed
{
    .maxstack 8
    L_0000: ldstr "Eat a raspberry"
    L_0005: call void [mscorlib]System.Console::WriteLine(string)
    L_000a: ret 
}