How to create a class from a comma separated strings in C#

Question

I have a comma separated string that I would like to convert into a class. My class definition is like so:

public class Data 
{
    public string Event {get;set;}
    public string TagId {get;set;}
    public string Type {get;set;}
    public string Frequency {get;set;}
    public string Rssi {get;set;}
    public string TxPower {get;set;}
    public string Tid {get;set;}
}

and the string that I get is like so:

event.tag.report tag_id=0x534D43010005600803251100, type=ISOC, antenna=1, frequency=919000, rssi=-451, tx_power=280, tid=0xE2003412012DF30009DA43851F0E0074300541FBFFFFDC50

I can make an array of the string by splitting it on the comma and split it more on the equal sign then get the last value and assign it to the class variable but maybe you have an idea that is faster and better than what I have in mind.

ATTEMPT

private void ParseIntoDataClass (string eventInfo)
{
    var firstArray = eventInfo.Split(',');
    var secondArray = new List<string>();
    var data = new Data();
    foreach (var item in firstArray)
    {
       secondArray.Add(item.Split('=').Last());
    }

    for (int i = 0; i < secondArray.Count - 1; i++)
    {
        switch(i)
        {
            case 0:
                data.Event = secondArray[i];
                break;
            case 1:
                data.TagId = secondArray[i];
                break;
            case 2:
                data.Type = secondArray[i];
                break;
            case 3:
                data.Frequency = secondArray[i];
                break;
            case 4:
                data.Rssi = secondArray[i];
                break;
            case 5:
                data.TxPower = secondArray[i];
                break;
            case 6:
                data.Tid = secondArray[i];
                break;
        }
    }
}

Answer 1

You can try Regex(@"(\w+)\s*=\s*([^,]*)") to split like this

tag_id: 0x534D43010005600803251100
type: ISOC
antenna: 1
frequency: 919000
rssi: -451
tx_power: 280
tid: 0xE2003412012DF30009DA43851F0E0074300541FBFFFFDC50

Full sample:

public static void Main()
{
    string input = "event.tag.report tag_id=0x534D43010005600803251100, type=ISOC, antenna=1, frequency=919000, rssi=-451, tx_power=280, tid=0xE2003412012DF30009DA43851F0E0074300541FBFFFFDC50";

    Dictionary<string, string> parameters = new Dictionary<string, string>();
    Regex regex = new Regex(@"(\w+)\s*=\s*([^,]*)");
    MatchCollection matches = regex.Matches(input);
    foreach (Match match in matches)
    {
        parameters[match.Groups[1].Value] = match.Groups[2].Value;
    }

    // Data
    var data = new Data();
    // data.Event = ?
    data.TagId = parameters["tag_id"];
    data.Type = parameters["type"];
    data.Frequency = parameters["frequency"];
    data.Rssi = parameters["rssi"];
    data.TxPower = parameters["tx_power"];
    data.Tid = parameters["tid"];
}

Updated:

Sorry, I noticed that your Event is not included in the string? Hmmm, the ParseIntoDataClass() will get the tag_id value to Event.

Updated

I think @VadimMartynov's answer is the best, and I tested both the benchmark without using property reflection and the one with property reflection.

Method	Mean	Error	StdDev
ParseIntoDataClass	196.5 ns	3.45 ns	3.23 ns
ParseIntoDataClassByProperty	11,739.1 ns	224.12 ns	209.64 ns

As @VadimMartynov said, this reflection indeed has a more negative impact on performance.

Answer 2

You can write a method to extract the name/value pairs from the input by returning ranges for the name and value strings, like so:

public static IEnumerable<(Range name, Range value)> ExtractNameValuePairs(string input)
{
    int nameStart = 0;
    int nameEnd   = 0;

    for (int i = 0; i < input.Length; i++)
    {
        switch (input[i])
        {
            case ' ':
                nameStart = i + 1;
                break;

            case '=':
                nameEnd = i;
                break;

            case ',':
                yield return (new Range(nameStart, nameEnd), new Range(nameEnd + 1, i));
                break;
        }
    }

    yield return (new Range(nameStart, nameEnd), new Range(nameEnd + 1, input.Length));
}

You can then use that to parse the data into the correct parameters like so:

static void ParseUsingRangesAndCheckingNames(string input)
{
    var data = new Data(); // data.Event is what?
    
    foreach (var nvp in ExtractNameValuePairs(input))
    {
        switch (input[nvp.name])
        {
            case "tag_id"   : data.TagId     = input[nvp.value]; break;
            case "type"     : data.Type      = input[nvp.value]; break;
            case "frequency": data.Frequency = input[nvp.value]; break;
            case "rssi"     : data.Rssi      = input[nvp.value]; break;
            case "tx_power" : data.TxPower   = input[nvp.value]; break;
            case "tid"      : data.Tid       = input[nvp.value]; break;
        }
    }
}

If you know that the data will always be in the order that you specified and have all the name/value pairs from your example you can optimise that a bit to:

static void ParseUsingRanges(string input)
{
    var data = new Data(); // data.Event is what?

    using var iter = ExtractNameValuePairs(input).GetEnumerator();

    iter.MoveNext();
    data.TagId = input[iter.Current.value];
    
    iter.MoveNext();
    data.Type = input[iter.Current.value];
    
    iter.MoveNext(); // Skip antenna
    iter.MoveNext();
    data.Frequency = input[iter.Current.value];

    iter.MoveNext();
    data.Rssi = input[iter.Current.value];

    iter.MoveNext();
    data.TxPower = input[iter.Current.value];

    iter.MoveNext();
    data.Tid = input[iter.Current.value];
}

but obviously that's a lot more brittle because it assumes the order and the presence of the various name/value pairs.

In order to benchmark this I used the following code:

using System.Text.RegularExpressions;
using BenchmarkDotNet.Attributes;

namespace Console1;

[MemoryDiagnoser]
public class Benchmarks
{
    [Benchmark]
    public void ParseUsingStringSplit()
    {
        ParseIntoDataClass(data);
    }

    [Benchmark]
    public void ParseUsingRegExp()
    {
        ParseUsingRegExp(data);
    }

    [Benchmark]
    public void ParseUsingRanges()
    {
        ParseUsingRanges(data);
    }

    [Benchmark]
    public void ParseUsingRangesAndCheckingNames()
    {
        ParseUsingRangesAndCheckingNames(data);
    }

    static void ParseIntoDataClass(string eventInfo)
    {
        var firstArray  = eventInfo.Split(',');
        var secondArray = new List<string>();
        var data        = new Data();

        foreach (var item in firstArray)
        {
            secondArray.Add(item.Split('=').Last());
        }

        for (int i = 0; i < secondArray.Count - 1; i++)
        {
            switch (i)
            {
                case 0:
                    data.Event = secondArray[i];
                    break;
                case 1:
                    data.TagId = secondArray[i];
                    break;
                case 2:
                    data.Type = secondArray[i];
                    break;
                case 3:
                    data.Frequency = secondArray[i];
                    break;
                case 4:
                    data.Rssi = secondArray[i];
                    break;
                case 5:
                    data.TxPower = secondArray[i];
                    break;
                case 6:
                    data.Tid = secondArray[i];
                    break;
            }
        }
    }

    static void ParseUsingRegExp(string input)
    {
        Dictionary<string, string> parameters = new Dictionary<string, string>();
        Regex                      regex      = new Regex(@"(\w+)\s*=\s*([^,]*)");
        MatchCollection            matches    = regex.Matches(input);

        foreach (Match match in matches)
        {
            parameters[match.Groups[1].Value] = match.Groups[2].Value;
        }

        // Data
        var data = new Data();
        // data.Event = ?
        data.TagId     = parameters["tag_id"];
        data.Type      = parameters["type"];
        data.Frequency = parameters["frequency"];
        data.Rssi      = parameters["rssi"];
        data.TxPower   = parameters["tx_power"];
        data.Tid       = parameters["tid"];
    }

    static void ParseUsingRanges(string input)
    {
        var data = new Data(); // data.Event is what?

        using var iter = ExtractNameValuePairs(input).GetEnumerator();

        iter.MoveNext();
        data.TagId = input[iter.Current.value];
    
        iter.MoveNext();
        data.Type = input[iter.Current.value];
    
        iter.MoveNext(); // Skip antenna
        iter.MoveNext();
        data.Frequency = input[iter.Current.value];

        iter.MoveNext();
        data.Rssi = input[iter.Current.value];

        iter.MoveNext();
        data.TxPower = input[iter.Current.value];

        iter.MoveNext();
        data.Tid = input[iter.Current.value];
    }

    static void ParseUsingRangesAndCheckingNames(string input)
    {
        var data = new Data(); // data.Event is what?
    
        foreach (var nvp in ExtractNameValuePairs(input))
        {
            switch (input[nvp.name])
            {
                case "tag_id"   : data.TagId     = input[nvp.value]; break;
                case "type"     : data.Type      = input[nvp.value]; break;
                case "frequency": data.Frequency = input[nvp.value]; break;
                case "rssi"     : data.Rssi      = input[nvp.value]; break;
                case "tx_power" : data.TxPower   = input[nvp.value]; break;
                case "tid"      : data.Tid       = input[nvp.value]; break;
            }
        }
    }

    public static IEnumerable<(Range name, Range value)> ExtractNameValuePairs(string input)
    {
        int nameStart = 0;
        int nameEnd   = 0;

        for (int i = 0; i < input.Length; i++)
        {
            switch (input[i])
            {
                case ' ':
                    nameStart = i + 1;
                    break;

                case '=':
                    nameEnd = i;
                    break;

                case ',':
                    yield return (new Range(nameStart, nameEnd), new Range(nameEnd + 1, i));
                    break;
            }
        }

        yield return (new Range(nameStart, nameEnd), new Range(nameEnd + 1, input.Length));
    }

    readonly string data = "event.tag.report tag_id=0x534D43010005600803251100, type=ISOC, antenna=1, frequency=919000, rssi=-451, tx_power=280, tid=0xE2003412012DF30009DA43851F0E0074300541FBFFFFDC50";
}

public class Data
{
    public string? Event     { get; set; }
    public string? TagId     { get; set; }
    public string? Type      { get; set; }
    public string? Frequency { get; set; }
    public string? Rssi      { get; set; }
    public string? TxPower   { get; set; }
    public string? Tid       { get; set; }
}

With the following results:

|                           Method |       Mean |     Error |    StdDev |     Median |   Gen0 | Allocated |
|--------------------------------- |-----------:|----------:|----------:|-----------:|-------:|----------:|
|            ParseUsingStringSplit |   969.9 ns |  36.98 ns | 106.71 ns |   942.9 ns | 0.4253 |    1784 B |
|                 ParseUsingRegExp | 8,965.3 ns | 179.23 ns | 349.57 ns | 8,867.3 ns | 2.1362 |    8960 B |
|                 ParseUsingRanges |   450.8 ns |   8.92 ns |  13.62 ns |   447.3 ns | 0.1163 |     488 B |
| ParseUsingRangesAndCheckingNames |   575.3 ns |  13.24 ns |  38.19 ns |   564.2 ns | 0.1774 |     744 B |

Answer 3

i would do something like

private Data ParseIntoDataClass(string eventInfo)
{
    var pair = eventInfo.Split(',');
    var keyandValueDic = new Dictionary<string, string>();
    foreaach(var item in pair)
    {
        var keyandValue = eventInfo.Split('=');
        var key = keyandValue[0];
        var value = keyandValue[1];
        keyandValueDic.Add(key, value);
    }
 
    Data data = new Data();
    //may dic of same with values to class
    Foreach(var item in keyandValueDic)
    {
        ParseDicIntoDataClass(item, data);
    }   
    return data;
}

//match on name and do any parsing of types if required
private Data ParseDicIntoDataClass(Dictionary<string, string> dic, Data data)
{
    foreaach(var item in keyandValueDic)
    {
        if(item.key == "event"{
            data.Event = Item.Value;
        }
        else if(
        ect....
    }   
}

Answer 4

The delay is caused by the way the string is parsed, not by assigning the properties. Strings are immutable so each string operation creates a new temporary strings that needs to be allocated and eventually garbage-collected.

Improve parsing performance

One way to improve this is to use a regular expression to capture they key/value pairs without splitting the string. The expression (?<key>\w+?)\s*=\s*(?<value>\w+?) will capture key/value pairs in named groups. \w+? matches any word character in a non-greedy way.

var regex=new Regex(@"(?<key>\w+?)\s*=\s*(?<value>\w+?)");

IEnumerable<string> lines=File.ReadLines(path);

foreach(var line in lines)
{
    foreach(var match in regex.Matches(line))
    {
        var key=match.Groups["key"].Value;
        var value=match.Groups["value"].Value;
        ...
    }
}

or

foreach(var line in lines)
{
    Dictionary<string,string> dict=regex.Matches(line)
                                        .ToDictionary(m=>m.Groups["key"].Value,
                                                      m=>m.Groups["value"].Value);
    ...
}

Regex doesn't split the string. Essentially, it finds the indexes in the source string where each match and group starts and ends. No strings are created until Value is called.

You could even turn this code into a LINQ query:

var recordList=lines.Select(l=>regex.Matches(l))
                    .Select(m=>.ToDictionary(m=>m.Groups["key"].Value,                                                      
                              m=>m.Groups["value"].Value)
                     )
                    .ToList();

You can even filter using Where before calling ToList

Create the final objects

If all tags are required, creating the data object is easy once a dictionary is available :

var records=lines.Select(l=>regex.Matches(l))
                 .Select(m=>.ToDictionary(m=>m.Groups["key"].Value,                                                      
                              m=>m.Groups["value"].Value)
                  )
                  .Select(dict=>new Data{
                      TagId     = dict["tag_id"],
                      Type      = dict["type"],
                      Frequency = dict["frequency"],
                      ...
                  })
                  .ToList();