Question

I have a web service which receive a string.

This string contains multiple keys => values which are concatenated with the character ‘+’.

I must validate each value (“required”, “not empty”), and assign each to a variable with the same name.

Here is how I build the Dictionary from the string :

string firstname;
string lastname;
string amount;

string request = "firstname=foo+lastname=bar+amout=100.58";

Dictionary<string, string> arguments = new Dictionary<string, string>();

request.Split('+').ToList<string>().ForEach(p =>
{
    string[] tmp = p.Split('=');

    if (tmp.Length == 2)
        arguments.Add(tmp[0], tmp[1]);
});

// Validate and assign : How I do with one value : (I must find a better way)
bool isValid = true;

// check "firstname"
if(arguments.ContainsKey("firstname") && string.IsNullOrWhiteSpace(arguments["firstname"]) == false)
{
    firstname = arguments["firstname"];
}
else
{
    isValid = false;
    Logger.Write("Invalid argument : firstname");
}

// Do this for about 20 arguments, it becomes huge...

if(isValid)
{
    Console.WriteLine(firstname); // Displays foo
    Console.WriteLine(lastname); // Displays bar
    Console.WriteLine(amout); // Displays 100.58
}

Thanks, and sorry for spelling mistakes, I’m French.

Answer 1

I think you want something like this, but since you didn’t acutally ask a question I’m just guessing:

request.Split('+').ToList<string>().ForEach(p =>
{
    string[] tmp = p.Split('=');

    if (tmp.Length == 2 && !string.IsNullOrWhiteSpace(tmp[1]))
    {
        // edit - if your string can have duplicates, use
        // Dictionary<U,K>.ContainsKey(U) to check before adding
        var key = tmp[0];
        var value = tmp[1];

        if(!arguments.ContainsKey(key))
        {
            arguments.Add(key, value);
        }
        else
        {
            //overwrite with new value
            //could also maybe throw on duplicate or some other behavior.
            arguents[key]=value; 
        }
    }
    else
        throw InvalidOperationException("Bad dictionary string value");
});

Also, I would question the use of ToList->ForEach if this was in front of me in a code review. You want to avoid side effects in Linq, I would write it with a traditional foreach like:

var itemValues = request.Split('+');
foreach(var item in itemValues)
{
    string[] tmp = item.Split('=');

    if (tmp.Length == 2 && !string.IsNullOrWhiteSpace(tmp[1]))
        arguments.Add(tmp[0], tmp[1]);
    else
        throw InvalidOperationException("Bad dictionary string value");
});



// Validate and assign
//read values from the dictionary
//use ContainsKey to check for exist first if needed

Console.WriteLine(arguments["firstname"]); // Displays foo
Console.WriteLine(arguments["lastname"]); // Displays foo
Console.WriteLine(arguments["amout"]); // Displays 100.58

Edit 2 – You should encapsulate the logic in a method:

private string TryGetValue(IDictionary<string,string> dict,string key)
{
    string value = null;
    if(dict.ContainsKey(key) && !string.IsNullOrWhiteSpace(dict[key]))
    {
        value = dict[key];
    }
    else
    {
        Logger.Write("Invalid argument : " + key);
    }
    return value;
}

Now you can say:

string firstName = TryGetValue(arguments,"firstname");
string lastName= TryGetValue(arguments,"lastName");
string amount = TryGetValue(arguments,"amount");

bool isValid = firstName!=null && lastName != null && amount != null;

if(isValid)
{
    Console.WriteLine(firstName ); // Displays foo
    Console.WriteLine(lastName); // Displays bar
    Console.WriteLine(amout); // Displays 100.58
}

TryGetValue would make an excellent extension method:

public static class Extensions
{
    public static string TryGetValue(this IDictionary<string,string> dict, string key)
    {
        string value = null;
        if(dict.ContainsKey(key) && !string.IsNullOrWhiteSpace(dict[key]))
        {
            value = dict[key];
        }
        else
        {
            Logger.Write("Invalid argument : " + key);
        }
        return value;
    }

}

Now the calling code would look like:

string firstName = arguments.TryGetValue("firstname");
string lastName= arguments.TryGetValue("lastname");
string amount = arguments.TryGetValue("amount");

Last edit –
A note on extention methods – Yes they are neat, but it’s also easy to accidently get in a bad situation overusing them. Read up on msdn and blogs about them, follow the guidelines. Avoid extensions on generic types like object, string ect.

In my projects I always lay out extension methods in distinct namespaces depending on the type they interact with, which forces classes that wish to use them to be very explicate about it like:

namespace Extensions.IDictionary { ... }
namespace Extensions.string { ... }
namespace Extensions.SomeType { ... }
namespace Extensions.IList { ... }

and consuming code would have using clauses to match:

using Extensions.IDictionary;

to pull in just the extensions your interested in, no more.