C# 每N个字符/数字拆分一个字符串/数字？

我需要将数字分成偶数部分，例如：
32427237需要变成32427237
103092501需要变成103092501

我相信我可以只为下一个数字，但我相信有一个更有效的方法，因为我不想错过这些数字中的字符-数字本身可以是任何长度，所以如果数字是1234567890，我希望它分成这些部分1234567890

我在其他语言（如Python等）中看到过一些示例，但我对它们的理解还不够透彻，无法将它们转换为C#-循环遍历字符，然后在第三次循环时获取上一个，然后获取索引以获取字符串的部分，但我愿意接受关于如何更好地完成这项工作的建议。

一种非常简单的方法（不是最有效的，但也不会比最有效的慢几个数量级）

publicstaticlist-GetChunks（字符串值，int-chunkSize）
{
列表三元组=新列表（）；
while（value.Length>chunkSize）
{
三元组.Add（value.Substring（0，chunkSize））；
value=value.Substring（chunkSize）；
}
如果（值！=“”）
三胞胎。增加（值）；
返回三胞胎；
}

这是候补的

    public static List<string> GetChunkss(string value, int chunkSize)
    {
        List<string> triplets = new List<string>();
        for(int i = 0; i < value.Length; i += chunkSize)
            if(i + chunkSize > value.Length)
                triplets.Add(value.Substring(i));
            else
                triplets.Add(value.Substring(i, chunkSize));

        return triplets;
    }

publicstaticlist GetChunkss（字符串值，intchunksize）
{
列表三元组=新列表（）；
for（int i=0；ivalue.Length）
三元组.Add（value.Substring（i））；
其他的
三元组.Add（value.Substring（i，chunkSize））；
返回三胞胎；
}

您可以使用简单的for循环在每个第n个位置插入空格：

string input = "12345678";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.Length; i++)
{
    if (i % 3 == 0)
        sb.Append(' ');
    sb.Append(input[i]);
}
string formatted = sb.ToString();

string input=“12345678”；
StringBuilder sb=新的StringBuilder（）；
for（int i=0；i

如果必须在代码中的许多地方执行此操作，则可以创建一种奇特的扩展方法：

static class StringExtensions {

  public static IEnumerable<String> SplitInParts(this String s, Int32 partLength) {
    if (s == null)
      throw new ArgumentNullException(nameof(s));
    if (partLength <= 0)
      throw new ArgumentException("Part length has to be positive.", nameof(partLength));

    for (var i = 0; i < s.Length; i += partLength)
      yield return s.Substring(i, Math.Min(partLength, s.Length - i));
  }

}

输出为所需的

324 272 37

将字符串拆分为多个部分时，将分配新字符串，即使原始字符串中已存在这些子字符串。通常，您不应该太担心这些分配，但使用现代C#可以通过稍微更改扩展方法以使用“跨度”来避免这种情况：

public静态IEnumerable SplitInParts（此字符串为s，Int32 partLength）
{
如果（s==null）
抛出新ArgumentNullException（nameof（s））；
如果（partLength这可能与主题无关，因为我不知道你为什么希望以这种方式格式化数字，所以如果与此无关，请忽略此帖子

整数的显示方式在不同的区域性中有所不同。您应该以独立于本地的方式执行此操作，以便以后更容易将更改本地化

int.ToString采用不同的参数，您可以使用这些参数为不同的区域性设置格式。
该参数为特定于区域性的分组提供标准格式

也是一个很好的资源。
拆分方法：

public static IEnumerable<string> SplitInGroups(this string original, int size) {
  var p = 0;
  var l = original.Length;
  while (l - p > size) {
    yield return original.Substring(p, size);
    p += size;
  }
  yield return original.Substring(p);
}

编辑：我更喜欢Martin Liversage解决方案：）

编辑2：修复了一个bug

编辑3：添加代码将字符串连接回来。
我会这样做，尽管我确信还有其他方法。应该会执行得很好

public static string Format(string number, int batchSize, string separator)
{      
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i <= number.Length / batchSize; i++)
  {
    if (i > 0) sb.Append(separator);
    int currentIndex = i * batchSize;
    sb.Append(number.Substring(currentIndex, 
              Math.Min(batchSize, number.Length - currentIndex)));
  }
  return sb.ToString();
}

公共静态字符串格式（字符串编号、int batchSize、字符串分隔符）
{      
StringBuilder sb=新的StringBuilder（）；
for（inti=0；i0）sb.追加（分隔符）；
int currentIndex=i*batchSize；
sb.Append（number.Substring）（当前索引，
Math.Min（batchSize，number.Length-currentIndex））；
}
使某人返回字符串（）；
}
我喜欢这个，因为它很酷，但效率不高：

var n = 3;
var split = "12345678900"
            .Select((c, i) => new { letter = c, group = i / n })
            .GroupBy(l => l.group, l => l.letter)
            .Select(g => string.Join("", g))
            .ToList();

LINQ规则：

var input = "1234567890";
var partSize = 3;

var output = input.ToCharArray()
    .BufferWithCount(partSize)
    .Select(c => new String(c.ToArray()));

更新：

string input = "1234567890";
double partSize = 3;
int k = 0;
var output = input
    .ToLookup(c => Math.Floor(k++ / partSize))
    .Select(e => new String(e.ToArray()));

试试这个：

Regex.Split(num.toString(), "(?<=^(.{8})+)");

Regex.Split（num.toString（），”（？如果您知道整个字符串的长度完全可以被部分大小整除，请使用：

var whole = "32427237!";
var partSize = 3;
var parts = Enumerable.Range(0, whole.Length / partSize)
    .Select(i => whole.Substring(i * partSize, partSize));

但是，如果整个字符串的结尾可能有一个小数块，则需要更加复杂：

var whole = "32427237";
var partSize = 3;
var parts = Enumerable.Range(0, (whole.Length + partSize - 1) / partSize)
    .Select(i => whole.Substring(i * partSize, Math.Min(whole.Length - i * partSize, partSize)));

在这些示例中，parts将是IEnumerable，但如果需要字符串[]或列表值，可以在末尾添加.ToArray（）或.ToList（）。
这已经晚了五年，但：

int n = 3;
string originalString = "32427237";
string splitString = string.Join(string.Empty,originalString.Select((x, i) => i > 0 && i % n == 0 ? string.Format(" {0}", x) : x.ToString()));

使用其他StackOverflow问题的答案，这是一个不错的实现：

"32427237"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" ");  // "324 272 37"

"103092501"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" "); // "103 092 501"

AsChunks（）：

ToCsv（）：
对于分割字符串并返回每个位置具有特定字符号的字符串列表，以下是我的函数：

public List<string> SplitStringEveryNth(string input, int chunkSize)
    {
        var output = new List<string>();
        var flag = chunkSize;
        var tempString = string.Empty;
        var lenght = input.Length;
        for (var i = 0; i < lenght; i++)
        {
            if (Int32.Equals(flag, 0))
            {
                output.Add(tempString);
                tempString = string.Empty;
                flag = chunkSize;
            }
            else
            {
                tempString += input[i];
                flag--;
            }

            if ((input.Length - 1) == i && flag != 0)
            {
                tempString += input[i];
                output.Add(tempString);
            }
        }
        return output;
    }

public List SplitStringEveryNth（字符串输入，int-chunkSize）
{
var输出=新列表（）；
var标志=块大小；
var tempString=string.Empty；
var lenght=输入长度；
对于（变量i=0；i
您可以使用Linq尝试类似的方法

var str = "11223344";
var bucket = 2;    
var count = (int)Math.Ceiling((double)str.Length / bucket);
        
Enumerable.Range(0, count)
    .Select(_ => (_ * bucket))
    .Select(_ => str.Substring(_,  Math.Min(bucket, str.Length - _)))
    .ToList()

您想将字符串拆分为三个单独的字符串，还是要插入空格？。所有答案都是java语言，但您可以轻松地将其移植到c#。它们应该是三个单独的字符串一个通用的
n
版本更好。这两种方法都会生成错误的输出，例如
string.Join（，”，GetChunks（“20000”，3）。ToArray（）
将生成对货币不正确的
200,00
（应为
20000
），拆分应从末尾开始。还请注意，问题本身要求以这种方式拆分数字w
int n = 3;
string originalString = "32427237";
string splitString = string.Join(string.Empty,originalString.Select((x, i) => i > 0 && i % n == 0 ? string.Format(" {0}", x) : x.ToString()));

"32427237"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" ");  // "324 272 37"

"103092501"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" "); // "103 092 501"

public List<string> SplitStringEveryNth(string input, int chunkSize)
    {
        var output = new List<string>();
        var flag = chunkSize;
        var tempString = string.Empty;
        var lenght = input.Length;
        for (var i = 0; i < lenght; i++)
        {
            if (Int32.Equals(flag, 0))
            {
                output.Add(tempString);
                tempString = string.Empty;
                flag = chunkSize;
            }
            else
            {
                tempString += input[i];
                flag--;
            }

            if ((input.Length - 1) == i && flag != 0)
            {
                tempString += input[i];
                output.Add(tempString);
            }
        }
        return output;
    }

var str = "11223344";
var bucket = 2;    
var count = (int)Math.Ceiling((double)str.Length / bucket);
        
Enumerable.Range(0, count)
    .Select(_ => (_ * bucket))
    .Select(_ => str.Substring(_,  Math.Min(bucket, str.Length - _)))
    .ToList()