字符串操作c#

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

这是一个非常直接的解决方案，只需解析字符串，然后将元素应用到您传递的字典中。为了使用模板字符串，您只需首先应用模板字符串，然后应用您想要处理的实际字符串覆盖所有默认值（如果适用）：

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

这是一个通过单元测试的

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

为生活欢呼。。