Question

I am trying to fill products with values parsed from a website. The process goes fine. What I want is an easy way (with reduced coupling) to fill values in products easily.
At the moment, the way to add a value is like: productX.Attributes[Price].SetValueFromString("95,3€");. Please see the design below and help me improve it.

class Product
{
    Dictionary<KeyValuePair<Type, AAtribute>> _attributes;

    Product()
    {
        // add values to _attributes. for example
        // Name with StrinAttribute
        // Price with NumericAttribute
        // Images with StringListAttribute
    }
}

enum Type
{
    Name,
    Price,
    Images
    ...
}

abtract class AAtribute
{
    abstract void SetValueFromString(string value);
}

and there are several classes that derive from AAtribute:

• StringAtribute,
• StringListAtribute,
• KeyValueStringListAtribute,
• BoolAtribute
• NumericAtribute

I’ve made this design so other classes don’t need to know witch attribute is of what type and how to give values to them.
If for example I want to give value to the Price attribute I would say:

productX.Attributes[Price].SetValueFromString("95,3€");

This has really helped since there are more than 40 attributes. It would be pain to parse value for each one by hand.

My problem is that I wan’t to reduce even more coupling. Any ideas on how to make other classes unaware of AAtributes or product types? Something between decorator and strategy pattern should do but I can’t find a way to it.

The problem that lead me make this question is:
– How can I add values to a ListStringAttribute?

But this rises the problem and know I feel there is a need for refactoring.

Answer 1

The way that we handle this is that all of our business classes inherit from a common base class.

The common base class contains a value setter and a value getter which use reflection to set and get properties within the class. If the requested property isn’t present and the caller indicates it is ok to do so, the setter adds the value to a user-defined field (UDF) collection, which is similar to your attributes.

This approach removes the caller’s need to know anything about how the values are actually stored (i.e. is it a regular property on the class or in the UDF collection) or even what data type it is.

For example, your caller code:

productX.Attributes[Price].SetValueFromString("95,3€");

in our system would be:

productX.SetFieldValue("Price", "95,3€");

We use this extensively for database interaction, form data binding, etc.

Here is an example of the core setter method:

    public static void SetFieldValue(object oRecord, string sName, object oValue)
    {
        PropertyInfo theProperty = null;
        FieldInfo theField = null;
        System.Type oType = null;

        try
        {
            oType = oRecord.GetType();

            // See if the column is a property in the record
            theProperty = oType.GetProperty(sName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public, null, null, new Type[0], null);
            if (theProperty == null)
            {
                theField = oType.GetField(sName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
                if (theField != null)
                {
                    theField.SetValue(oRecord, Global.ValueFromDB(oValue, theField.FieldType.Name));
                }
                else
                {
                    object[] aAttributes = null;

                    // See if the class type is decorated with the NoUDFs attribute. If so, do not add the attribute.
                    aAttributes = oType.GetCustomAttributes(typeof(NoUDFsAttribute), true);
                    if (aAttributes.Length == 0)
                    {
                        // Otherwise, anything that is not found as a property or a field will be stored as a UDF
                        oRecord.SetUDFValue(sName, oValue);
                    }
                }
            }
            else
            {
                if (theProperty.CanWrite)
                {
                    theProperty.SetValue(oRecord, Global.ValueFromDB(oValue, theProperty.PropertyType.Name), null);
                }
            }
        }
        catch (Exception theException)
        {
            // Handle the exception
        }
    }

And one of the getter methods where we get the value as a string:

    public static string GetFieldValueForSQL(object oRecord, string sName)
    {
        PropertyInfo theProperty = null;
        FieldInfo theField = null;
        System.Type oType = null;

        try
        {
            oType = oRecord.GetType();

            // See if the column is a property in the record
            theProperty = oType.GetProperty(sName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public, null, null, new Type[0], null);
            if (theProperty == null)
            {
                theField = oType.GetField(sName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
                if (theField != null)
                {
                    return Global.ValueForSQL(theField.GetValue(oRecord), theField.FieldType.Name);
                }
                else
                {
                    UDF oUDF = null;
                    object[] aAttributes = null;

                    // See if the class type is decorated with the NoUDFs attribute. If so, do not get the value.
                    aAttributes = oType.GetCustomAttributes(typeof(NoUDFsAttribute), true);
                    if (aAttributes.Length == 0)
                    {
                        oUDF = oRecord.GetUDF(sName);
                    }

                    if (oUDF != null)
                    {
                        return Global.ValueForSQL(oUDF.Value);
                    }
                    else
                    {
                        return "Null";
                    }
                }
            }
            else
            {
                return Global.ValueForSQL(theProperty.GetValue(oRecord, null), theProperty.PropertyType.Name);
            }
        }
        catch (Exception theException)
        {
            // Handle the exception
            return null;
        }
    }

I’ve left some of the internal method calls that we use to coerce the values into the appropriate format (ValueFromDB, ValueForSQL) in place so you can see how they are used, but they are pretty straightforward to implement.