C # string manipulations

Question

I got a string like A:<<Default>>;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:<<Default>>[pattern string]

The string representation is similar to a dictionary key: A value that is grouped as a comma delimited string.

Now, after applying the logic, I get a list of lines below,

A:aaa;E:eee
D:ddd
B:bbb;E:eee

Now I need to do the above list below (where the key with the new value should be placed in the correct order and have the rest of the keys with default values),

A:aaa;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:eee
A:<<Default>>;B:<<Default>>;C:<<Default>>;D:ddd;E:<<Default>>
A:<<Default>>;B:bbb;C:<<Default>>;D:<<Default>>;E:eee

Tried with split function, Replace and convert to list to achieve this. Do we have an effective way to achieve the same?

string constants = "A:<<Default>>;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:<<Default>>";
            string placeHolder = string.Empty;


            List<string> filteredkeys = new List<string>();
            List<string> formattedKeys = new List<string>();
            filteredkeys.Add("A:aaa;E:eee;");
            filteredkeys.Add("D:ddd;");
            filteredkeys.Add("B:bbb;E:eee;");

            foreach (var item in filteredkeys)
            {
                placeHolder = constants;
                List<string> keyCombination = item.TrimEnd(';').Split(';').ToList();
                foreach (string keys in keyCombination)
                {
                    List<string> abc = keys.Split(':').ToList();
                    switch (abc[0])
                    {
                        case "A":
                            placeHolder = placeHolder.Replace("A:<<Default>>", keys);
                            break;
                        case "B":
                            placeHolder = placeHolder.Replace("B:<<Default>>", keys);
                            break;
                        case "C":
                            placeHolder = placeHolder.Replace("C:<<Default>>", keys);
                            break;
                        case "D":
                            placeHolder = placeHolder.Replace("D:<<Default>>", keys);
                            break;
                        case "E":
                            placeHolder = placeHolder.Replace("D:<<Default>>", keys);
                            break;
                    }                    
                }
                formattedKeys.Add(placeHolder);
            }

Answer 1

Linq Solution:

  String source = @"A:<<Default>>;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:<<Default>>";

  // Note, that "E" value (eee:fff:ggg:hhh) contains semicolons
  String values = "A:aaa;E:eee:fff:ggg:hhh";  

  var dict = values
    .Split(';')
    .Select(item => item.Split(new Char[] {':'}, 2)) // "2": if value contains ':'
    .ToDictionary(chunk => chunk[0], chunk => chunk[1]);

  String result = String.Join(";", source
    .Split(';')
    .Select(item => item.Split(':'))
    .Select(item => String.Join(":", 
       item[0],
       dict.ContainsKey(item[0]) ? dict[item[0]] : item[1])));

  // Test
  // A:aaa;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:eee:fff:ggg:hhh
  Console.Write(result);

Answer 2

, , , . , , , , , :

public void ParseAndApply(Dictionary<string, string> dictionary, string text)
{
    foreach (string element in text.Split(';'))
    {
        string[] parts = element.Split(new char[]{ ':' }, 2);
        dictionary[parts[0]] = parts[1];
    }
}

public string ConvertToString(Dictionary<string, string> dictionary)
{
    return string.Join(";", dictionary.Select(kv => kv.Key + ":" + kv.Value));
}

:

string[] strings = { "A:aaa;E:eee", "D:ddd", "B:bbb;E:eee" };

foreach (string exampleString in strings)
{
    // create dictionary
    Dictionary<string, string> dict = new Dictionary<string, string>();

    // apply from template string
    string templateString = "A:<<Default>>;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:<<Default>>";
    ParseAndApply(dict, templateString);

    // apply example string
    ParseAndApply(dict, exampleString);

    // write output
    Console.WriteLine(ConvertToString(dict));
}

A:aaa;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:eee
A:<<Default>>;B:<<Default>>;C:<<Default>>;D:ddd;E:<<Default>>
A:<<Default>>;B:bbb;C:<<Default>>;D:<<Default>>;E:eee

---

, ":", DataTime,

, . , ParseAndApply, , , , .

Answer 3

unit test,

[TestMethod]
public void Test()
{
    var template = "A:<<Default>>;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:<<Default>>";

    Assert.AreEqual(Pair.Process("A:aaa;E:eee", template),
        "A:aaa;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:eee");

    Assert.AreEqual(Pair.Process("D:ddd", template),
        "A:<<Default>>;B:<<Default>>;C:<<Default>>;D:ddd;E:<<Default>>");

    Assert.AreEqual(Pair.Process("B:bbb;E:eee", template),
        "A:<<Default>>;B:bbb;C:<<Default>>;D:<<Default>>;E:eee");

}

public class Pair
{
    public static char InnerSeperator = ':';
    public static char OuterSeperator = ';';
    public static string DefaultValue = "<<Default>>";

    public Pair(string asString)
    {
        var strings = asString.Split(InnerSeperator).ToList();
        Key = strings[0];
        Value = strings.Count > 1 ? strings[1] : DefaultValue;
    }

    public string Key { get; set; }
    public string Value { get; set; }
    public override string ToString()
    {
        return string.Format("{0}{1}{2}", Key, InnerSeperator, Value);
    }

    public static string ToStringJoined(IEnumerable<Pair> pairs)
    {
        return string.Join(OuterSeperator.ToString(), pairs.Select(i => i.ToString()));
    }

    public static IEnumerable<Pair> FromJoinedString(string joined)
    {
        return joined.Split(OuterSeperator)
            .Select(x => x.Trim())
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .Select(x => new Pair(x));
    }

    public static string Process(string values, string template)
    {
        var templateItems = FromJoinedString(template);
        var valueItems = FromJoinedString(values);
        var resultItems = templateItems.Select(t => valueItems.FirstOrDefault(x => x.Key == t.Key) ?? t);
        return ToStringJoined(resultItems);
    }
}

.