相关疑难解决方法(0)

我理解String和StringBuilder(StringBuilder可变)之间的区别,但两者之间是否有很大的性能差异？

我正在研究的程序有很多案例驱动的字符串附加(500+).使用StringBuilder更好的选择？

我正在浏览开源SignalR项目的源代码,我看到这个名为"不要在这个热代码路径中使用StringBuilder或foreach"的差异代码:

-           public static string MakeCursor(IEnumerable<Cursor> cursors)
+           public static string MakeCursor(IList<Cursor> cursors)
            { 
-               var sb = new StringBuilder();
-               bool first = true;
-               foreach (var c in cursors)
+               var result = "";
+               for (int i = 0; i < cursors.Count; i++)
                {
-                   if (!first)
+                   if (i > 0)
                    {
-                       sb.Append('|');
+                       result += '|';
                    }
-                   sb.Append(Escape(c.Key));
-                   sb.Append(',');
-                   sb.Append(c.Id);
-                   first = false; …

我通常通过连接来包装长字符串:

Log.Debug("I am a long string. So long that I must " +
    "be on multiple lines to be feasible.");

这非常有效,因为编译器处理字符串文字的连接.我也认为这是处理这个问题最简洁的方法(选项在这里称重).

这种方法适用于String.Format:

Log.Debug(String.Format("Must resize {0} x {1} image " +
    "to {2} x {3} for reasons.", image.Width, image.Height,
    resizedImage.Width, resizedImage.Height));

但是,我现在希望String.Format在这些情况下不再使用,因为C#6的字符串插值更具可读性.我担心的是,我不再有一种高效而又干净的方式来格式化长字符串.

我的问题是编译器是否能以某种方式优化类似的东西

Log.Debug($"Must resize {image.Width} x {image.Height} image " +
    $"to {resizedImage.Width} x {resizedImage.Height} for reasons.");

进入上面的String.Format等价物,或者如果我可以使用的替代方法效率不高(由于不必要的连接),同时保持我的代码结构清晰(根据上面链接中提出的点).

可能重复:
字符串连接与字符串生成器.性能

以下两个选项之间的任何差异(性能和内存使用情况)？

选项1:

StringBuilder msgEntry = new StringBuilder();
msgEntry.AppendLine("<" + timeTag + ">" + timeStamp + "</" + timeTag + ">");

选项2:

StringBuilder msgEntry = new StringBuilder();
msgEntry.Append("<");
msgEntry.Append(timeTag);
msgEntry.Append(">");
msgEntry.Append(timeStamp);
msgEntry.Append("</");
msgEntry.Append(timeTag );
msgEntry.Append(">\n");

所以......我有这个场景,我有一个Foreach循环,循环通过一个复选框列表来检查选中哪个.对于每个选中的复选框,我必须进行相当长的字符串连接,涉及30个平均长度为20个字符的不同字符串,然后将其作为HTTP请求发送出去.其中2个字符串取决于所选复选框的索引/值.

复选框列表的长度也可根据用户的数据而变化.我会说List的平均长度是20,但它可以达到50-60.因此,最糟糕的情况是执行整个字符串连接60次左右.

现在我通过'+'运算符使用简单的字符串连接来完成它,但我想知道使用Stringbuilder执行它是否会更快.当然,这意味着我必须在循环中创建一个Stringbuilder对象,或者在循环之前创建它,并在发出HTTP请求后调用Stringbuilder.Remove.

我感谢任何人可以就此问题分享任何见解.

编辑
感谢所有人的回复,所以从我收集的内容来看,这样做的最佳方式是:

 StringBuilder sb = new StringBuilder();
 foreach (CheckBox item in FriendCheckboxList)
 {
     if (item.Checked)
     {
         sb.Append(string1);
         sb.Append(string2);
         sb.Append(string3);
         .
         .
         .
         sb.Append(stringLast);

         SendRequest(sb.ToString());
         sb.Length = 0;
      }
  }

我在下面的结构中有一个List:

Tuple<string, string>

像这样:

我想加入列表,形成如下字符串:

['A', '1'],['B', '2'], ['C', '3']...

我现在使用下面的代码来做:

string result = "";
for (int i = 0; i < list.Count; i++)
{
      result += "[ '" + list[i].Item1 + "', '" + list[i].Item2 + "'],";
}

代码工作正常,但想问是否有更好的方法可以做到这一点？

我希望下面的代码(来自.Net框架中的Exception类)使用StringBuilder来构建一个字符串,然后返回一个builder.ToString()而不是在现有字符串上使用"+"运算符,最终创建每次都有一个新的字符串.

我希望大家写.Net源代码可以尽可能地遵循最佳实践,因此我想仔细检查这是否仍然是某种最佳方式

private String ToString(bool needFileLineInfo, bool needMessage) {
    String message = (needMessage ? Message : null);
    String s;
    if (message == null || message.Length <= 0) {
        s = GetClassName();
    }
    else {
        s = GetClassName() + ": " + message;
    }

    if (_innerException!=null) {
        s = s + " ---> " + _innerException.ToString(needFileLineInfo, needMessage) 
              + Environment.NewLine 
              + "   "
              + Environment.GetResourceString("Exception_EndOfInnerExceptionStack");

    }

    string stackTrace = GetStackTrace(needFileLineInfo);
    if (stackTrace != null)
    {
        s += Environment.NewLine + stackTrace;
    }

    return …

使用string.concat或字符串构建器更好吗？谁能解释我在什么情况下我应该使用这两个？

有一个问题在这里,解释的表现,我想知道在哪里使用string.concat何避免呢？

提前致谢.

正如标题所示,是否有任何理由我不应该执行以下操作来将某些内容添加到字符串的末尾:

string someString = "test";
someString += "Test";

我正在审查一些代码,我看到大量的字符串连接,但它们都是非常小的字符串.像这样的东西:

public string BuildList()
{
    return "A" + GetCount() + "B" + TotalCount() + "C" + AMountLeft()
         + "D" + DaysLeft + "R" +  Initials() + "E";
}

我正在简化它,但总的来说,最长的字符串大约是300个字符,数量+大约是20个.我试图弄清楚它是否值得将它转换为StringBuilder并做类似这样的事情:

public string BuildList()
{
    var sb = new StringBuilder();
    sb.Append("A");
    sb.Append(GetCount());
    sb.Append("B");
    sb.Append(TotalCount());
    sb.Append("C");
    sb.Append(AmountLeft());
    sb.Append("D");

    // etc . . 
}

我看不出与测试有很大的不同,但想看看是否有一个关于使用StringBuilder的良好的盈亏平衡规则(字符串长度或不同连接数)？