我有一个长度为 5000 + 个字符的字符串值，我想将其拆分为 76 个字符长，并在每 76 个字符的末尾添加一个新行。我将如何在 C# 中做到这一点？
【问题讨论】：
如果你在写 Base64 数据，试试写
Convert.ToBase64String(bytes, Base64FormattingOptions.InsertLineBreaks);
这将每 76 个字符插入一个换行符
【讨论】：
另一方面，如果您希望 StringBuilder 与字符串性能对比，最好的文章是找到的代码项目 here。
（但这不显示字符串大小）
简而言之，在字符串长度（或重复的接触）达到阈值之前，StringBuilder 不会更快，因此您完全低于此阈值，因此请坚持常规的字符串连接和 String 方法。
【讨论】：
试试这个：
s = Regex.Replace(s, @"(?<=\G.{76})", "\r\n");
编辑：显然，这是迄今为止发布的所有方法中最慢的方法。我想知道如果您预编译正则表达式会如何：
Regex rx0 = new Regex(@"(?<=\G.{76})");
s = rx0.Replace(s, "\r\n"); // only time this portion
另外，它与直接匹配方法相比如何？
Regex rx1 = new Regex(".{76}");
s = rx1.Replace(s, "$0\r\n"); // only time this portion
我一直想知道那些无限制的后视有多昂贵。
【讨论】：
有点丑……但要快得多；）（这个版本需要 161 个滴答声……Aric 需要 413 个滴答声）
我在我的博客上发布了我的测试代码。 http://hackersbasement.com/?p=134 （我还发现 StringBuilder 比 string.Join 慢得多）
http://hackersbasement.com/?p=139
string chopMe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
Stopwatch sw = new Stopwatch();
sw.Start();
char[] chopMeArray = chopMe.ToCharArray();
int totalLength = chopMe.Length;
int partLength = 12;
int partCount = (totalLength / partLength) + ((totalLength % partLength == 0) ? 0 : 1);
int posIndex = 0;
char[] part = new char[partLength];
string[] parts = new string[partCount];
int get = partLength;
for (int i = 0; i < partCount; i++)
{
get = Math.Min(partLength, totalLength - posIndex);
Array.Copy(chopMeArray, posIndex, part, 0, get);
parts[i] = new string(part, 0, get);
posIndex += partLength;
}
var output = string.Join("\r\n", parts) + "\r\n";
sw.Stop();
Console.WriteLine(sw.ElapsedTicks);
【讨论】：
public static string InsertNewLine(string s, int len)
{
StringBuilder sb = new StringBuilder(s.Length + (int)(s.Length/len) + 1);
int start = 0;
for (start=0; start<s.Length-len; start+=len)
{
sb.Append(s.Substring(start, len));
sb.Append(Environment.NewLine);
}
sb.Append(s.Substring(start));
return sb.ToString();
}
s 是您的输入字符串，len 是所需的行长 (76)。
【讨论】：
string[] FixedSplit(string s, int len)
{
List<string> output;
while (s.Length > len)
{
output.Add(s.Substring(0, len) + "\n");
s.Remove(0, len);
}
output.Add(s + "\n");
return output.ToArray();
}
【讨论】：
public static IEnumerable<string> SplitString(string s, int length)
{
var buf = new char[length];
using (var rdr = new StringReader(s))
{
int l;
l = rdr.ReadBlock(buf, 0, length);
while (l > 0)
{
yield return (new string(buf, 0, l)) + Environment.NewLine;
l = rdr.ReadBlock(buf, 0, length);
}
}
}
然后将它们重新组合在一起：
string theString = GetLongString();
StringBuilder buf = new StringBuilder(theString.Length + theString.Length/76);
foreach (string s in SplitString(theString, 76) { buf.Append(s); }
string result = buf.ToString();
或者你可以这样做：
string InsertNewLines(string s, int interval)
{
char[] buf = new char[s.Length + (int)Math.Ceiling(s.Length / (double)interval)];
using (var rdr = new StringReader(s))
{
for (int i=0; i<buf.Length-interval; i++)
{
rdr.ReadBlock(buf, i, interval);
i+=interval;
buf[i] = '\n';
}
if (i < s.Length)
{
rdr.ReadBlock(buf, i, s.Length - i);
buf[buf.Length - 1] = '\n';
}
}
return new string(buf);
}
【讨论】：
还有一个......（第一次通过缓慢的后续运行，类似于上面发布的更快的时间）
private void button1_Click(object sender, EventArgs e)
{
string chopMe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
Stopwatch sw = new Stopwatch();
sw.Start();
string result = string.Join("\r\n", ChopString(chopMe).ToArray());
sw.Stop();
MessageBox.Show(result + " " + sw.ToString());
}
public IEnumerable<string> ChopString(string s)
{
int i = 0;
while (i < s.Length)
{
yield return i + PARTLENGTH <= s.Length ? s.Substring(i,PARTLENGTH) :s.Substring(i) ;
i += PARTLENGTH;
}
}
编辑：我很想知道子字符串有多快......
【讨论】：
字符串是 5000 个字符...我不认为速度真的很重要，除非你这样做数千甚至数百万次，尤其是当 OP 甚至没有提到速度很重要时。过早优化？
我可能会使用递归，因为在我看来，它会导致最简单的代码。
这可能在语法上不正确，因为我知道 .NET 但不是 C#。
String ChunkString(String s, Integer chunkLength) {
if (s.Length <= chunkLength) return s;
return String.Concat(s.Substring(0, chunkLength),
ChunkString(s.Substring(chunkLength)));
}
【讨论】：
主要是为了好玩，这里有一个不同的解决方案，作为字符串的扩展方法实现： （\r\n 明确使用，因此仅支持换行符的格式）；
public static string Split(this string str, int len)
{
char org = str.ToCharArray();
int parts = str.Length / len + (str.Length % len == 0 ? 0 : 1);
int stepSize = len + newline.Length;
char[] result = new char[parts * stepSize];
int resLen = result.Length;
for (int i =0;i<resLen ;i+stepSize)
{
Array.Copy(org,i*len,result,i*stepSize);
resLen[i++] = '\r';
resLen[i++] = '\n';
}
return new string(result);
}
【讨论】：
最后，我想这将是我会使用的
static string fredou()
{
string s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
int partLength = 12;
int stringLength = s.Length;
StringBuilder n = new StringBuilder(stringLength + (int)(stringLength / partLength) + 1);
int chopSize = 0;
int pos = 0;
while (pos < stringLength)
{
chopSize = (pos + partLength) < stringLength ? partLength : stringLength - pos;
n.Append(s , pos, chopSize);
n.Append("\r\n");
pos += chopSize;
}
return n.ToString();
}
通过查看反射器下的 AppendLine：
<ComVisible(False)> _
Public Function AppendLine(ByVal value As String) As StringBuilder
Me.Append(value)
Return Me.Append(Environment.NewLine)
End Function
Public Shared ReadOnly Property NewLine As String
Get
Return ChrW(13) & ChrW(10)
End Get
End Property
对我来说，速度明智，手动执行 > AppendLine
【讨论】：
我将字符串分割为 35
var tempstore ="12345678901234567890123456789012345";
for (int k = 0; k < tempstore.Length; k += 35)
{
PMSIMTRequest.Append(tempstore.Substring(k, tempstore.Length - k > 35 ? 35 : tempstore.Length - k));
PMSIMTRequest.Append(System.Environment.NewLine);
}
messagebox.Show(PMSIMTRequest.tostring());
【讨论】：
@M4N 的回答很好，但我觉得while statement 比for statement 更容易理解。
public static string InsertNewLine(string source, int len = 76)
{
var sb = new StringBuilder(source.Length + (int)(source.Length / len) + 1);
var start = 0;
while ((start + len) < source.Length)
{
sb.Append(source.Substring(start, len));
sb.Append(Environment.NewLine);
start += len;
}
sb.Append(source.Substring(start));
return sb.ToString();
}
【讨论】：