Identifying strings and manipulating the correctly

Question

To preface this I am pulling records from a database. The CaseNumber column will have a unique identifier. However, multiple cases related to ONE Event will have very similar case numbers in which the last two digits will be the next following number. Example:

TR42X2330789
TR42X2330790
TR42X2330791
TR51C0613938
TR51C0613939
TR51C0613940
TR51C0613941
TR51C0613942
TR52X4224749

As you can see we would have to group these records into three groups. Currently my function is really messy and I it does not account for the scenario in which a group of case numbers is followed by another group of case numbers. I was wondering if anybody had any suggestions as to how to tackle this. I was thinking about putting all the case numbers in an array.

int i = 1;
string firstCaseNumber = string.Empty;
string previousCaseNumber = string.Empty;

if (i == 1)
{
    firstCaseNumber = texasHarrisPublicRecordInfo.CaseNumber;

    i++;
}
else if (i == 2)
{
    string previousCaseNumberCode = firstCaseNumber.Remove(firstCaseNumber.Length - 3);
    int previousCaseNumberTwoCharacters = Int32.Parse(firstCaseNumber.Substring(Math.Max(0, firstCaseNumber.Length - 2)));

    string currentCaseNumberCode = texasHarrisPublicRecordInfo.CaseNumber.Remove(texasHarrisPublicRecordInfo.CaseNumber.Length - 3);
    int currentCaselastTwoCharacters = Int32.Parse(texasHarrisPublicRecordInfo.CaseNumber.Substring(Math.Max(0, texasHarrisPublicRecordInfo.CaseNumber.Length - 2)));

    int numberPlusOne = previousCaseNumberTwoCharacters + 1;

    if (previousCaseNumberCode == currentCaseNumberCode && numberPlusOne == currentCaselastTwoCharacters)
    {
        //Group offense here

        i++;

        needNewCriminalRecord = false;
    }
    else
    {
        //NewGRoup here
    }
    previousCaseNumber = texasHarrisPublicRecordInfo.CaseNumber;
    i++;
}
else
{
    string beforeCaseNumberCode = previousCaseNumber.Remove(previousCaseNumber.Length - 3);
    int beforeCaselastTwoCharacters = Int32.Parse(previousCaseNumber.Substring(Math.Max(0, previousCaseNumber.Length - 2)));

    string currentCaseNumberCode = texasHarrisPublicRecordInfo.CaseNumber.Remove(texasHarrisPublicRecordInfo.CaseNumber.Length - 3);
    int currentCaselastTwoCharacters = Int32.Parse(texasHarrisPublicRecordInfo.CaseNumber.Substring(Math.Max(0, texasHarrisPublicRecordInfo.CaseNumber.Length - 2)));

    int numberPlusOne = beforeCaselastTwoCharacters + 1;

    if (beforeCaseNumberCode == currentCaseNumberCode && numberPlusOne == currentCaselastTwoCharacters)
    {
        i++;

        needNewCriminalRecord = false;
    }
    else
    {
        needNewCriminalRecord = true;
    }
}

Answer 1

If you do not really care about performance you can use LINQ .GroupBy() and .ToDictionary() methods and create dictionary with lists. Something among the lines of :

string[] values = 
{
    "TR42X2330789",
    "TR42X2330790",
    "TR42X2330791",
    "TR51C0613938",
    "TR51C0613939",
    "TR51C0613940",
    "TR51C0613941",
    "TR51C0613942",
    "TR52X4224749"
};

Dictionary<string, List<string>> grouppedValues = values.GroupBy(v => 
            new string(v.Take(9).ToArray()),   // key - first 9 chars
                 v => v)                       // value
                    .ToDictionary(g => g.Key, g => g.ToList());

foreach (var item in grouppedValues)
{
    Console.WriteLine(item.Key + "   " + item.Value.Count);
}

Output :

TR42X2330   3
TR51C0613   5
TR52X4224   1

Answer 2

I would create a general puropose extension method:

static IEnumerable<IEnumerable<T>> GroupByConsecutiveKey<T, TKey>(this IEnumerable<T> list, Func<T, TKey> keySelector, Func<TKey, TKey, bool> areConsecutive)
{
    using (var enumerator = list.GetEnumerator())
    {
        TKey previousKey = default(TKey);
        var currentGroup = new List<T>();

        while (enumerator.MoveNext())
        {
            if (!areConsecutive(previousKey, keySelector(enumerator.Current)))
            {
                if (currentGroup.Count > 0)
                {
                    yield return currentGroup;
                    currentGroup = new List<T>();
                }
            }

            currentGroup.Add(enumerator.Current);
            previousKey = keySelector(enumerator.Current);
        }

        if (currentGroup.Count != 0)
        {
            yield return currentGroup;
        }
    }
}

And now you would use it like:

var grouped = data.GroupByConsecutiveKey(item => item, (k1, k2) => areConsecutive(k1, k2));

A quick hack for areConsecutive could be:

public static bool Consecutive(string s1, string s2)
{
    if (s1 == null || s2 == null)
        return false;

    if (s1.Substring(0, s1.Length - 2) != s2.Substring(0, s2.Length - 2))
        return false;

    var end1 = s1.Substring(s1.Length - 2, 2);
    var end2 = s2.Substring(s2.Length - 2, 2);

    if (end1[1]!='0' && end2[1]!='0')
        return Math.Abs((int)end1[1] - (int)end2[1]) == 1;

    return Math.Abs(int.Parse(end1) - int.Parse(end2)) == 1;
}

Note that I am considering that Key can take any shape. If the alphanumeric code has the same pattern always then you can probably make this method a whole lot prettier or just use regular expressions.