Question

say you have to interpret a sting of command arguments like AABBCDEEFF… and the idea is that each character represents a command for which you have to take some actions on the class, the ugly solution is to write a big switch-case but i dont want to use that , can anybody suggest a more elegant solution ??

Answer 1

For C#, In the more complex case a solution can be to implement and interface, or add attributes and use reflection to call the command or method.

OK, as an example i created some C# code

public class ExecuteSequence
    {
        Dictionary<string, Type> classes = new Dictionary<string, Type>();
        public void LoadClasses()
        {
            classes.Clear();
            //load all classes with attribute
            //this can be done at startup once, or on requested refresh
            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
                foreach (Type type in assembly.GetTypes())
                    foreach (object attribute in type.GetCustomAttributes(typeof(MethodAttribute), true))
                        if (attribute.GetType() == typeof(MethodAttribute))
                            classes.Add(((MethodAttribute)attribute).MethodName, type);
        }

        public string Execute(string sequence)
        {
            string retVal = "";
            foreach (char c in sequence)
                if (classes.ContainsKey(c.ToString()))
                {
                    IMethod method = (IMethod)Activator.CreateInstance(classes[c.ToString()]);
                    retVal += method.Execute();
                }

            return retVal;
        }
    }

    public class MethodAttribute : Attribute
    {
        private readonly string m_MethodName;
        public MethodAttribute(string methodName)
        {
            m_MethodName = methodName;
        }
        public string MethodName
        {
            get { return m_MethodName; }
        }
    }
    public interface IMethod
    {
        string Execute();
    }

    [Method("A")]
    public class MethodA : IMethod
    {
        public string Execute()
        {
            return "FOO";
        }
    }

    [Method("B")]
    public class MethodB : IMethod
    {
        public string Execute()
        {
            return "BAR";
        }
    }

You can limit the list of initial assemblies scanned, but as mentioned, this should only load on startup.

Hope this helps.