C# 如何拆分一个字符串，然后重新连接它？

我用C#表示以下字符串

然后我用

newchar[]{'，'，'，'.'，'|'，'：'}

将其拆分。如何使用相同的字符以与以前相同的顺序重新连接此字符串？因此，这份名单最终将与以前一模一样

范例

string s = "aaa,bbbb.ccc|dddd:eee";
string[] s2 = s.Split(new char[] {',','.','|',':'});
// now s2 = {"aaa", "bbbb", "ccc", "dddd", "eee"}
// lets assume I done some operation, and
// now s2 = {"xxx", "yyy", "zzz", "1111", "222"}

s = s2.MagicJoin(~~~~~~);  // I need this

// now s = "xxx,yyy.zzz|1111:222";

编辑

上面示例中的

char[]

只是示例，不以相同的顺序出现，甚至不会在现实世界中同时出现

编辑

---

只是想一想，使用Regex.split，然后首先通过

char[]

拆分得到一个

string[]

，然后使用

而不是char[]

拆分得到另一个

string[]

，然后将它们放回原处。可能有用，但我不知道如何编码。

给你-这适用于任何顺序的分隔符组合，也允许在字符串中实际找不到分隔符的情况。我花了一段时间才想出这个答案，在发布之后，它看起来比任何其他答案都要复杂

好吧，反正我会把它放在这里

public static string SplitAndReJoin(string str, char[] delimiters, 
  Func<string[], string[]> mutator)
{
  //first thing to know is which of the delimiters are 
  //actually in the string, and in what order
  //Using ToArray() here to get the total count of found delimiters
  var delimitersInOrder = (from ci in
                            (from c in delimiters
                             from i in FindIndexesOfAll(str, c)
                             select new { c, i })
                          orderby ci.i
                          select ci.c).ToArray();
  if (delimitersInOrder.Length == 0)
    return str;

  //now split and mutate the string
  string[] strings = str.Split(delimiters);
  strings = mutator(strings);
  //now build a format string
  //note - this operation is much more complicated if you wish to use 
  //StringSplitOptions.RemoveEmptyEntries
  string formatStr = string.Join("",
    delimitersInOrder.Select((c, i) => string.Format("{{{0}}}", i)
      + c));
  //deals with the 'perfect' split - i.e. there's always two values
  //either side of a delimiter
  if (strings.Length > delimitersInOrder.Length)
    formatStr += string.Format("{{{0}}}", strings.Length - 1);

  return string.Format(formatStr, strings);
}

public static IEnumerable<int> FindIndexesOfAll(string str, char c)
{
  int startIndex = 0;
  int lastIndex = -1;

  while(true)
  {
    lastIndex = str.IndexOf(c, startIndex);
    if (lastIndex != -1)
    {
      yield return lastIndex;
      startIndex = lastIndex + 1;
    }
    else
      yield break;
  }
}

请注意，我假设您需要能够处理数组的元素，在将单个字符串重新连接到一起之前操作它们-否则您可能只会保留原始字符串

---

该方法生成一个动态格式字符串。这里不保证效率：）

这里是

MagicSplit

：

public IEnumerable<Tuple<string,char>> MagicSplit(string input, char[] split)
{    
    var buffer = new StringBuilder();
    foreach (var c in input)
    {
        if (split.Contains(c)) 
        {
            var result = buffer.ToString();
            buffer.Clear();
            yield return Tuple.Create(result,c);
        }
        else
        {
            buffer.Append(c);
        }
    }
    yield return Tuple.Create(buffer.ToString(),' ');
}

用途：

var s = "aaa,bbbb.ccc|dddd:eee";

// simple
var split = MagicSplit(s, new char[] {',','.','|',':'}).ToArray();
var joined = MagicJoin(split);    

// if you want to change the strings
var strings = split.Select(tup => tup.Item1).ToArray();
var chars = split.Select(tup => tup.Item2).ToArray();
strings[0] = "test";
var joined = MagicJoin(strings,chars);

---

使用Regex类可能更容易做到这一点：

input = Regex.Replace(input, @"[^,.|:]+", DoSomething);

其中DoSomething是一种转换相关项目的方法或lambda，例如：

string DoSomething(Match m)
{
    return m.Value.ToUpper();
}

对于本例，“aaa，bbbb.ccc | dddd:eee”的输出字符串将是“aaa，bbbb.ccc | dddd:eee”

如果您使用lambda，您可以非常轻松地保持状态，如下所示：

int i = 0;
Console.WriteLine(Regex.Replace("aaa,bbbb.ccc|dddd:eee", @"[^,.|:]+",
    _ => (++i).ToString()));

产出：

1,2.3|4:5

这只取决于您对项目所做的转换。

这如何

var x = "aaa,bbbb.ccc|dddd:eee";

var matches = Regex.Matches(x, "(?<Value>[^\\.,|\\:]+)(?<Separator>[\\.,|\\:]?)");

var result = new StringBuilder();

foreach (Match match in matches)
{
    result.AppendFormat("{0}{1}", match.Groups["Value"], match.Groups["Separator"]);
}

Console.WriteLine(result.ToString());
Console.ReadLine();

var x=“aaa，bbbb.ccc | dddd:eee”；
var matches=Regex.matches（x，“（？[^\\，\\：]+）（？[\\，\\：]+）”；
var result=新的StringBuilder（）；
foreach（匹配中的匹配）
{
result.AppendFormat（“{0}{1}”、match.Groups[“Value”]、match.Groups[“Separator”]）；
}
Console.WriteLine（result.ToString（））；
Console.ReadLine（）；

或者如果你喜欢林克（我也喜欢）：

var x=“aaa，bbbb.ccc | dddd:eee”；
var matches=Regex.matches（x，“（？[^\\，\\：]+）（？[\\，\\：]+）”；
var resembly=matches.Cast（）.Aggregate（新的StringBuilder（），（a，v）=>a.AppendFormat（“{0}{1}”），v.Groups[“Value”]，v.Groups[“Separator”]）；
控制台写入线（重新组装）；
Console.ReadLine（）；

---

不用说，在重新组装之前，您可以对零件进行一些处理，我认为这是本练习的重点

我认为您可能必须手动操作。轮廓线是否始终以完全相同的顺序排列？检查是否有帮助。字符串是否始终为

$1，$2.$3 |$4:$5

？或者可能有未知数量的逗号、句点、管道等？保留原始字符串不是更简单吗？如果我现在不知道用于拆分的

char[]

的顺序，并且我假设它可能有这些

char[]

。我想为任何字符串创建一个公共函数，请给出建议。谢谢，我认为这种方法是有效的，虽然不是我最初认为的，但我从一个错误的方式开始

int i = 0;
Console.WriteLine(Regex.Replace("aaa,bbbb.ccc|dddd:eee", @"[^,.|:]+",
    _ => (++i).ToString()));

1,2.3|4:5

var x = "aaa,bbbb.ccc|dddd:eee";

var matches = Regex.Matches(x, "(?<Value>[^\\.,|\\:]+)(?<Separator>[\\.,|\\:]?)");

var result = new StringBuilder();

foreach (Match match in matches)
{
    result.AppendFormat("{0}{1}", match.Groups["Value"], match.Groups["Separator"]);
}

Console.WriteLine(result.ToString());
Console.ReadLine();

var x = "aaa,bbbb.ccc|dddd:eee";
var matches = Regex.Matches(x, "(?<Value>[^\\.,|\\:]+)(?<Separator>[\\.,|\\:]?)");
var reassembly = matches.Cast<Match>().Aggregate(new StringBuilder(), (a, v) => a.AppendFormat("{0}{1}", v.Groups["Value"], v.Groups["Separator"])).ToString();
Console.WriteLine(reassembly);
Console.ReadLine();