字符串操作c＃

Question

我有一个字符串， A:<<Default>>;B:<<Default>>;C:<<Default>>;D:<<Default>>;E:<<Default>> [template string]

字符串的表示形式类似于字典键：用分号分隔符分组为字符串的值。

现在应用逻辑后，我得到一个下面的字符串列表，

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

现在我需要将上面的列表作为下面的列表（其中具有新值的键应该以正确的顺序放置并且其余键具有默认值），

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

尝试使用拆分功能，替换并转换为列表来实现此目的。 我们有任何有效的方法来实现同样的目标吗？

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解决方案：

  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拆分元素的ParseAndApply ，我们只对其中的第一个冒号执行拆分一次，因此值后面出现的其他冒号不是问题。

Answer 3

这是通过单元测试，

[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);
    }
}

为生活欢呼..