Parsing formatted string

Question

I am trying to create a generic formatter/parser combination.

Example scenario:

• I have a string for string.Format(), e.g. var format = "{0}-{1}"
• I have an array of object (string) for the input, e.g. var arr = new[] { "asdf", "qwer" }
• I am formatting the array using the format string, e.g. var res = string.Format(format, arr)

What I am trying to do is to revert back the formatted string back into the array of object (string). Something like (pseudo code):

var arr2 = string.Unformat(format, res)

// when: res = "asdf-qwer"    
// arr2 should be equal to arr

Anyone have experience doing something like this? I'm thinking about using regular expressions (modify the original format string, and then pass it to Regex.Matches to get the array) and run it for each placeholder in the format string. Is this feasible or is there any other more efficient solution?

Answer 1

While the comments about lost information are valid, sometimes you just want to get the string values of of a string with known formatting.

One method is this blog post written by a friend of mine. He implemented an extension method called string[] ParseExact(), akin to DateTime.ParseExact(). Data is returned as an array of strings, but if you can live with that, it is terribly handy.

public static class StringExtensions
{
    public static string[] ParseExact(
        this string data, 
        string format)
    {
        return ParseExact(data, format, false);
    }

    public static string[] ParseExact(
        this string data, 
        string format, 
        bool ignoreCase)
    {
        string[] values;

        if (TryParseExact(data, format, out values, ignoreCase))
            return values;
        else
            throw new ArgumentException("Format not compatible with value.");
    }

    public static bool TryExtract(
        this string data, 
        string format, 
        out string[] values)
    {
        return TryParseExact(data, format, out values, false);
    }

    public static bool TryParseExact(
        this string data, 
        string format, 
        out string[] values, 
        bool ignoreCase)
    {
        int tokenCount = 0;
        format = Regex.Escape(format).Replace("\\{", "{");

        for (tokenCount = 0; ; tokenCount++)
        {
            string token = string.Format("{{{0}}}", tokenCount);
            if (!format.Contains(token)) break;
            format = format.Replace(token,
                string.Format("(?'group{0}'.*)", tokenCount));
        }

        RegexOptions options = 
            ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None;

        Match match = new Regex(format, options).Match(data);

        if (tokenCount != (match.Groups.Count - 1))
        {
            values = new string[] { };
            return false;
        }
        else
        {
            values = new string[tokenCount];
            for (int index = 0; index < tokenCount; index++)
                values[index] = 
                    match.Groups[string.Format("group{0}", index)].Value;
            return true;
        }
    }
}

Answer 2

You can't unformat because information is lost. String.Format is a "destructive" algorithm, which means you can't (always) go back.

Create a new class inheriting from string, where you add a member that keeps track of the "{0}-{1}" and the { "asdf", "qwer" }, override ToString(), and modify a little your code.

If it becomes too tricky, just create the same class, but not inheriting from string and modify a little more your code.

IMO, that's the best way to do this.

Answer 3

It's simply not possible in the generic case. Some information will be "lost" (string boundaries) in the Format method. Assume:

String.Format("{0}-{1}", "hello-world", "stack-overflow");

How would you "Unformat" it?