Оптимизация кода с большим количеством операторов "если"

Question

Я хочу оптимизировать этот код, чтобы уменьшить количество if операторов. Может быть, было бы лучше использовать много классов и позволить классам обрабатывать каждое требуемое действие?

Это может быть рисунок ткани? Или можно использовать более 30 похожих if операторов?

Я пытался создать класс Dictionary с классами string и object. Но я не мог заставить его работать (или мои навыки не достаточно хороши)

if (node[DATA_CONNECTION_ELEMENT] != null)
{               
    return new DataConnectionPropertyDataBinding(form, node[DATA_CONNECTION_ELEMENT], inputableEntity);
}
else if (node[FORM_PARAMETER_ELEMENT] != null)
{
    return new FormParameterDataBinding(form, node[FORM_PARAMETER_ELEMENT], inputableEntity);
}

// + 30 more else ifs

else if (node[COMMAND_ELEMENT] != null)
{
    return new CommandResultDataBinding(form, node[COMMAND_ELEMENT], inputableEntity);
}
else if (node[CONDITION_ELEMENT] != null)
{
    return new ConditionDataBinding(form, node[CONDITION_ELEMENT], inputableEntity);
}
else if (node[CLIPBOARD_ELEMENT] != null)
{
    return new ClipboardDataBinding(form, node[CLIPBOARD_ELEMENT], inputableEntity);
}
else
{
    return new ConstantDataBinding(form, node);
}

Хотите, чтобы это выглядело как

foreach (var item in allThatShareSomeInterface)
{
    if (item.CanHandle(node.Atributes[0]))
    {
        return item.neededObject();
    }
}

Вот ответ. Как это действительно работает.

        Dictionary<string, Type> allObjects = new Dictionary<string, Type>();
        allObjects.Add(CONDITION_ELEMENT, typeof(ConditionDataBinding));
        allObjects.Add(DATA_TYPE_FORMAT_ELEMENT, typeof(DataTypeFormatDataBinding));
        allObjects.Add(DATA_TYPE_CONVERT_ELEMENT, typeof(DataTypeConvertDataBinding));
        allObjects.Add(FORM_PARAMETER_ELEMENT, typeof(FormParameterDataBinding));
        allObjects.Add(FORM_ELEMENT, typeof(FormPropertyDataBinding));
        allObjects.Add(STRING_ELEMENT, typeof(StringFormatDataBinding));
        allObjects.Add(FORMULA_ELEMENT, typeof(FormulaDataBinding));
        allObjects.Add(COMMAND_ELEMENT, typeof(CommandResultDataBinding));
        // + many


        foreach (var pair in allObjects)
        {
            if (node[pair.Key] != null)
            {
                ConstructorInfo ctor = pair.Value.GetConstructor(new[] { typeof(IWorkflowForm), typeof(XmlNode), typeof(IInputable) });
                return ctor.Invoke(new object[] { form, node[pair.Key], inputableEntity });
            }
        }

Answer 1

Вы можете сделать эту работу, используя отражение. Возможно, это сделает ваш код немного медленнее. Это должно выглядеть примерно так (не проверено):

    var pairs = new Dictionary<string, Type>()
    {
        {
            DATA_CONNECTION_ELEMENT, typeof(DataConnectionPropertyDataBinding)
        },
        {
            FORM_PARAMETER_ELEMENT, typeof(FormParameterDataBinding)
        }
    };

    foreach (var pair in pairs)
    {
        if (node[pair.Key] != null)
        {
            ConstructorInfo ctor = pair.Value.GetConstructor(new[] { typeof(object), typeof(object), typeof(object) });
            return ctor.Invoke(new object[] { form, node[pair.Key], inputableEntity });
        }
    }

Answer 2

Если вы знаете, что делаете, и вам действительно нужно столько связывающих классов, один из способов решить это - пользовательские атрибуты + отражение + генерация кода времени выполнения.Вот пример.

// Enum for element type. The order matters, it's the order in which input dictionary is tested.
enum eElement
{
    DataConnection,
    FormParameter,
}
// Custom attribute to mark bindings classes with.
class DataBindingAttribute : Attribute
{
    public eElement element;
    public DataBindingAttribute( eElement e ) { element = e; }
}

// Base class for bindings
abstract class BindingBase { }

// Couple test binding classes
[DataBinding( eElement.DataConnection )]
class DataConnectionPropertyDataBinding: BindingBase
{
    public DataConnectionPropertyDataBinding( object data ) { }
}
[DataBinding( eElement.FormParameter )]
class FormParameterDataBinding: BindingBase
{
    public readonly object data;
    public FormParameterDataBinding( object data ) { this.data = data; }
}

// This static class does the magic.
static class BindingsFactory
{
    // Key = eElement from custom attribute, value = function that constructs the binding. This example uses the constructor with single object argument.
    // It's a good idea to use strong types for arguments instead.
    static readonly SortedDictionary<eElement, Func<object, BindingBase>> dictTypes = new SortedDictionary<eElement, Func<object, BindingBase>>();

    static BindingsFactory()
    {
        // Constructor argument types, just a single `object` in this example.
        Type[] constructorArgumentTypes = new Type[ 1 ]
        {
            typeof( object )
        };

        ParameterExpression[] constructorArgumentExpressions = constructorArgumentTypes
            .Select( tp => Expression.Parameter( tp ) )
            .ToArray();

        // Find all types in current assembly
        var ass = Assembly.GetExecutingAssembly();
        foreach( Type tp in ass.GetTypes() )
        {
            // Try to get the custom attribute
            var dba = tp.GetCustomAttribute<DataBindingAttribute>();
            if( null == dba )
                continue;

            // Ensure you don't have 2 classes with the same element ID value
            Debug.Assert( !dictTypes.ContainsKey( dba.element ) );
            // Ensure the found type inherits from BindingBase
            Debug.Assert( typeof( BindingBase ).IsAssignableFrom( tp ) );

            // Compile the function that constructs the new binding object
            ConstructorInfo ci = tp.GetConstructor( constructorArgumentTypes );
            Debug.Assert( null != ci );

            // new Binding(...)
            var expNew = Expression.New( ci, constructorArgumentExpressions );
            // (BindingBase)( new Binding( ... ) )
            var expCast = Expression.Convert( expNew, typeof( BindingBase ) ); 
            // Compile into lambda
            var lambda = Expression.Lambda<Func<object, BindingBase>>( expCast, constructorArgumentExpressions );
            // Compile the lambda, and save in the sorted dictionary
            var func = lambda.Compile();
            dictTypes.Add( dba.element, func );
        }
    }

    public static BindingBase tryConstruct( Dictionary<eElement, object> dict )
    {
        foreach( var kvp in dictTypes )
        {
            object arg;
            if( !dict.TryGetValue( kvp.Key, out arg ) )
                continue;
            return kvp.Value( arg );
        }
        return null;
    }
}

class Program
{
    static void Main( string[] args )
    {
        var dict = new Dictionary<eElement, object>();
        dict[ eElement.FormParameter ] = 12;
        // This line will construct an instance of FormParameterDataBinding
        var res = BindingsFactory.tryConstruct( dict );
    }
}