Elegant syntax for passing pairs of key -> value mappings to a function?

Question

I'm working on an API which will read string values from a file and allow for type conversion. I also need it to provide a way of "mapping" given string values to a specific value of the desired type. That would look something like this:

int val = myObject.getValue<int>("FieldName", { { "", 0 }, { "INF", int.MaxValue } });

The field name is there so that it can be retrieved later if an error occurs. It's only important to this example because the function needs to take an unrelated first parameter.

However, I am having trouble coming up with an elegant and type-safe syntax to provide this functionality (the above, based on collection initializers, only works if I stick new FieldValueMappingCollection<int> { ... } in there).

---

So, the options I'm aware of are:

myObject.getValue<int>("FieldName", new FieldValueMappingCollection<int> { { "", 0 }, { "INF", int.MaxValue } });

or

myObject.getValue<int>("FieldName", "", 0, "INF", int.MaxValue);

where getValue has params object[] in its signature.

There's got to be a nicer way of doing this, right?

Answer 1

The usual way of doing this is:

myObject.getValue<int>("FieldName",
    Tuple.Create("", 0),
    Tuple.Create("INF", int.MaxValue));

using a function that takes a params array, and either .NET tuples or your own "tuple" class for these field entries.

I'm afraid there isn't really a more concise way in C# while retaining static typing. The collection initializer syntax won't let you get away with not specifying the type.

Answer 2

How about the following class:

public class MyObject<T>
{

    public T GetValue(string fieldName, params MyObjectMap<T>[] mappings)
    {
       // Do whatever you need to do
    }

    public MyObjectMap<T> Map(string from, T to)
    {
        return MyObjectMap<T>.Map(from, to);
    }

}

public class MyObjectMap<T>
{

    private MyObjectMap(string from, T to) { }

    public static MyObjectMap<T> Map(string from, T to)
    {
        return new MyObjectMap<T>(from, to);
    }

}

You could use this like the following:

private void Foo()
{
    MyObject<int> myObject = new MyObject<int>();
    myObject.GetValue("FieldName",
        myObject.Map("", 0),
        myObject.Map("INF", int.MaxValue));
}

And it's entirely type safe.

Answer 3

A nicer way of doing this would be to use a Dictionary<String, Int32> or whatever. Set it up once in your class, and then simply pass the dictionary in. Since you're making an API, this is a much cleaner and expressive way to declare your intent rather than using Tuples. A dictionary is built for these types of operations, and your users should be able to easily understand the intent of the method. Tuples are much less understandable, especially when you're dealing with a simply Key-Value mapping.

In addition, it makes for much nicer initialization if you want to initialize on the fly: http://msdn.microsoft.com/en-us/library/bb531208.aspx

Answer 4

How about passing a delegate:

myObject.GetValue<int>("FieldName", value =>
{
    if (string.IsNullOrEmpty(value))
        return 0;
    if (value == "INF")
        return int.MaxValue;
    throw new InvalidInputException();
});

Advantages:

• This supports a much wider range of possibilities than just a one-to-one mapping of values.
• If it gets complex, you can make it a method of its own instead of needing to inline it here.
• It is completely type-safe.
• The compiler enforces that you need to return a value or throw an exception. You can declare your own InvalidInputException to communicate to GetValue<>() that you couldn’t process the input.

Disadvantages:

• Verbose...
• If GetValue<>() only calls the delegate when it can’t process the input itself, then you can’t use this to override values that GetValue<>() already considers valid, e.g. you can’t make it reject −1.
• If GetValue<>() calls the delegate before it does its own processing, there is a performance penalty in throwing the exception every time.

Answer 5

I would not send the information as parameters. I would use a fluent syntax instead, something like this:

object.With("", 0)
      .With("INF", int.MaxValue)
      .Get<int>("FieldName");

You can change the method names to make it look as you want to. Other option could be:

object.GetValueUsing("", 0)
      .AndUsing("INF", int.MaxValue)
      .Of<int>("FieldName");

Or:

object.WithParameter("", 0)
      .AndParameter("INF", int.MaxValue)
      .GetValue<int>("FieldName");

If you don't know how to create a fluent interface, just google for "c# creating fluent interface" and you will tons of samples.

Answer 6

I would consider doing something like the example below.

Pros:

• simple and compact syntax using anonymous types

Cons:

• Potentially doing a lot of reflection
• keys are restricted to valid identifiers, i.e. special characters are not allowed

The GetValue method takes 4 parameters:

1. the field name, which I assume is used to look up the appropriate value from the file
2. A default value in case the string value is ""
3. An object, assumed to be an anonymous type, used as a value map. The public properties act as the keys of the map, and the values of those properties act as the corresponding values.
4. A parse delegate that is used when the correct value cannot be identified through the value map

(Seems like I need a line here after the list to avoid messing up the code formatting)

    public T GetValue<T>(string fieldName, T @default, object valueMap, Converter<string, T> parse)
    {
        T value;
        string literalString = null; // read string from file

        if (string.IsNullOrEmpty(literalString))
            return @default;
        else
        {
            var map = ToDictionary<T>(valueMap);
            // attempt to look up the corresponding value associated with literalString
            if (map.TryGetValue(literalString, out value))
                return value;
            else
                // literalString does not match any value in the value map,
                // so parse it using the provided delegate
                return parse(literalString);
        }
    }

    public static Dictionary<string, T> ToDictionary<T>(object valueMap)
    {
        // Use reflection to read public properties and add them as keys to a
        // dictionary along with their corresponding value
        // The generic parameter enforces that all properties
        // must be of the specified type,
        // otherwise the code here can throw an exception or ignore the property
        throw new NotImplementedException();
    }


        // usage

        int field1 = myObject.GetValue("Field1", 0, new { one = 1, two = 2, TheAnswer = 42, min = int.MinValue, max = int.MaxValue, INF = int.MaxValue }, int.Parse);

        double field2 = myObject.GetValue("Field2", 0.0, new { PI = Math.PI, min = double.MinValue, max = double.MaxValue }, double.Parse);