Is there a good C# design pattern for parsing strings that when split have different amounts of data?

I am dealing with values delimited by commas sent to me as a string. The strings come in many different structures (meaning different data types in different locations of the string as well as varying amounts of data). So while one string might be represented as:

- common data,identifier,int,string,string,string.

Another might be represented as:

- common data,identifier,int,int,string,string,st开发者_Go百科ring.

Design goals:

• Common parse method
• Common validation (i.e. int.TryParse() returns true)
• Readily able to add different structures

Is there a good design pattern, or combination of design patterns, that allows me to parse the values, check them, and return an object only if the right amount of values were pulled in and those values were the expected data types?

Note: I am dealing with more than 30 different string structures.

If all the lines start with common data, identifier, and then are followed by a variable but expected (i.e. known based on the identifier) set of values, then a table approach could work well. To continue your example, say you have two different types:

• common data,identifier,int,string,string,string.
• common data,identifier,int,int,string,string,string.

You can build a class that defines what you're looking for:

class ItemDesc
{
    public string Ident { get; private set; }
    public string Fields { get; private set; }
    public ItemDesc(string id, string flds)
    {
        Ident = id;
        Fields = flds;
    }
}

The Fields property is just a string that contains one-character type descriptions for the variable data. That is, "isss" would be interpreted as int,string,string,string.

You can then build a Dictionary<string, ItemDesc> that you can use to look these up:

Dictionary<string, ItemDesc> ItemLookup = new Dictionary<string, ItemDesc>
{
    { "ItemType1", new ItemDesc("ItemType1", "isss") },
    { "ItemType2", new ItemDesc("ItemType2", "iisss") },
};

Now when you read a line, use string.Split() to split it into fields. Get the identifier, look it up the dictionary to get the item descriptions, and then parse the rest of the fields. Something like:

string line = GetLine();
var fields = line.Split(',');
// somehow get the identifier
string id = GetIdentifier();
ItemDesc desc;
if (!ItemLookup.TryGetValue(id, out desc))
{
    // unrecognized identifier
}
else
{
    int fieldNo = 3; // or whatever field is after the identifier
    foreach (var c in desc.Fields)
    {
        switch (c)
        {
            case 'i' :
               // try to parse an int and save it.
               break;
            case 's' :
               // save the string
               break;
            default:
               // error, unknown field type
               break;
         }
         ++fieldNo;
    }
}
// at this point if no errors occurred, then you have a collection
// of parsed fields that you saved.  You can now create your object.

would need little more details, based on your problem domain it could entirely change. but following seem to be the first set of patterns, they are ordered on suitability.

• Interpreter
• Strategy
• Builder

Just split them using string.Split(), and then int.Parse() or int.TryParse() each int value in the resulting array as needed.

var myStrings = string.Split(sourceString);
int myint1 = int.Parse(myStrings[0]);

There are several ways of dealing with this. Here's a simple one (outputting just an object array):

class Template
{
    // map identifiers to templates
    static Dictionary<string, string> templates = new Dictionary<string, string>
    {
        { "type1", "isss" },
        { "type2", "iisss" },
    };

    static bool ParseItem(string input, char type, out object output)
    {
        output = null;
        switch (type)
        {
            case 'i':
                int i;
                bool valid = int.TryParse(input, out i);
                output = i;
                return valid;
            case 's':
                output = input;
                return true;
        }
        return false;
    }

    public static object[] ParseString(string input)
    {
        string[] items = input.Split(',');
        // make sure we have enough items
        if (items.Length < 2)
            return null;
        object[] output = new object[items.Length - 2];
        string identifier = items[1];
        string template;
        // make sure a valid identifier was specified
        if (!templates.TryGetValue(identifier, out template))
            return null;
        // make sure we have the right amount of data
        if (template.Length != output.Length)
            return null;
        // parse each item
        for (int i = 0; i < template.Length; i++)
            if (!ParseItem(items[i + 2], template[i], out output[i]))
                return null;
        return output;
    }
}

If you're interested in returning actual objects instead of just object arrays, you can put metadata into the class definitions of the objects you're returning. Then when you get the object type you look for the metadata to figure out where to find its value in the input array. Here's a quick example:

namespace Parser
{
    // create metadata attribute
    class CsvPositionAttribute : Attribute
    {
        public int Position { get; set; }
        public CsvPositionAttribute(int position)
        {
            Position = position;
        }
    }

    // define some classes that use our metadata
    public class type1
    {
        [CsvPosition(0)]
        public int int1;
        [CsvPosition(1)]
        public string str1;
        [CsvPosition(2)]
        public string str2;
        [CsvPosition(3)]
        public string str3;
    }

    public class type2
    {
        [CsvPosition(0)]
        public int int1;
        [CsvPosition(1)]
        public int int2;
        [CsvPosition(2)]
        public string str1;
        [CsvPosition(3)]
        public string str2;
        [CsvPosition(4)]
        public string str3;
    }

    public class CsvParser
    {
        public static object ParseString(string input)
        {
            string[] items = input.Split(',');
            // make sure we have enough items
            if (items.Length < 2)
                return null;
            string identifier = items[1];
            // assume that our identifiers refer to a type in our namespace
            Type type = Type.GetType("Parser." + identifier, false);
            if (type == null)
                return null;
            object output = Activator.CreateInstance(type);
            // iterate over fields in the type -- you may want to use properties
            foreach (var field in type.GetFields())
                // find the members that have our position attribute
                foreach (CsvPositionAttribute attr in
                    field.GetCustomAttributes(typeof(CsvPositionAttribute),
                                              false))
                    // if the item exists, convert it to the type of the field
                    if (attr.Position + 2 >= items.Length)
                        return null;
                    else
                        // ChangeType may throw exceptions on failure;
                        // catch them and return an error
                        try { field.SetValue(output,
                            Convert.ChangeType(items[attr.Position + 2],
                                               field.FieldType));
                        } catch { return null; }
            return output;
        }
    }
}