C# 是否需要在替换StringBuilder中的字符串之前进行检查（使用诸如“Contains”或“IndexOf”之类的函数）？

C#中是否有索引或包含的方法。代码如下：

var sb = new StringBuilder(mystring);
sb.Replace("abc", "a");
string dateFormatString = sb.ToString();

if (sb.ToString().Contains("def"))
{
    sb.Replace("def", "aa");
}


if (sb.ToString().Contains("ghi"))
{
    sb.Replace("ghi", "assd");
}

---

正如您可能已经注意到的，我在上面一次又一次地使用ToString（），这是我想要避免的，因为它每次都在创建新字符串。您能帮助我如何避免吗？

如果

StringBuilder

不包含“def”，则执行替换不会导致任何问题，因此只需使用：

var sb = new StringBuilder(mystring);
sb.Replace("abc", "a");
sb.Replace("def", "aa");
sb.Replace("ghi", "assd");

---

在

StringBuilder

中没有这样的方法，但是您不需要

包含
测试。你可以这样简单地写：

 sb.Replace("abc", "a");
 sb.Replace("def", "aa");
 sb.Replace("ghi", "assd");

如果在
Replace
的第一个参数中找不到字符串，那么对
Replace
的调用就是一个空操作，这正是您想要的

文件规定：

将此实例中指定字符串的所有匹配项替换为另一个指定字符串

您阅读这篇文章的方式是，当没有发生任何事件时，什么也不做。
在这种情况下，您不必使用StringBuilder。。。StringBuilder在循环中使用时更有用。就像微软说的那样

字符串对象是不可变的。每一个
使用中的方法之一的时间
String类，则创建一个新的
内存中的字符串对象
需要新的空间分配给
那个新物体。在以下情况下：
你需要重复表演
对字符串的修改
与创建
新的字符串对象可能很昂贵。这个
System.Text.StringBuilder类可以是
要修改字符串时使用
不创建新对象。对于
例如，使用StringBuilder类
可以在以下情况下提高性能：
将多个字符串串联在一起
循环

因此，只需使用String并避免使用ToString（）…
就可以编写一个类，将方法扩展到StringBuilder对象。在这里，我向StringBuilder类添加了IndexOf、Substring和其他方法。把这个类放在你的项目中

using System;
using System.Text;

namespace Helpers
{
    /// <summary>
    /// Adds IndexOf, IsStringAt, AreEqual, and Substring to all StringBuilder objects.
    /// </summary>
    public static class StringBuilderExtension
    {
        // Adds IndexOf, Substring, AreEqual to the StringBuilder class.
        public static int IndexOf(this StringBuilder theStringBuilder,string value)
        {
            const int NOT_FOUND = -1;
            if (theStringBuilder == null)
            {
                return NOT_FOUND;
            }
            if (String.IsNullOrEmpty(value))
            {
                return NOT_FOUND;
            }
            int count = theStringBuilder.Length;
            int len = value.Length;            
            if (count < len)
            {
                return NOT_FOUND;
            }
            int loopEnd = count - len + 1;
            for (int loop = 0; loop < loopEnd; loop++)
            {
                bool found = true;
                for (int innerLoop = 0; innerLoop < len; innerLoop++)
                {
                    if (theStringBuilder[loop + innerLoop] != value[innerLoop])
                    {
                        found = false;
                        break;
                    }
                }
                if (found)
                {
                    return loop;
                }
            }
            return NOT_FOUND;
        }
        public static int IndexOf(this StringBuilder theStringBuilder, string value,int startPosition)
        {
            const int NOT_FOUND = -1;
            if (theStringBuilder == null)
            {
                return NOT_FOUND;
            }
            if (String.IsNullOrEmpty(value))
            {
                return NOT_FOUND;
            }
            int count = theStringBuilder.Length;
            int len = value.Length;
            if (count < len)
            {
                return NOT_FOUND;
            }
            int loopEnd = count - len + 1;
            if (startPosition >= loopEnd)
            {
                return NOT_FOUND;
            }
            for (int loop = startPosition; loop < loopEnd; loop++)
            {
                bool found = true;
                for (int innerLoop = 0; innerLoop < len; innerLoop++)
                {
                    if (theStringBuilder[loop + innerLoop] != value[innerLoop])
                    {
                        found = false;
                        break;
                    }
                }
                if (found)
                {
                    return loop;
                }
            }
            return NOT_FOUND;
        }
        public static string Substring(this StringBuilder theStringBuilder, int startIndex, int length)
        {
            return theStringBuilder == null ? null : theStringBuilder.ToString(startIndex, length);
        }
        public static bool AreEqual(this StringBuilder theStringBuilder, string compareString)
        {
            if (theStringBuilder == null)
            {
                return compareString == null;
            }
            if (compareString == null)
            {
                return false;
            }
            int len = theStringBuilder.Length;
            if (len != compareString.Length)
            {
                return false;
            }
            for (int loop = 0; loop < len; loop++)
            {
                if (theStringBuilder[loop] != compareString[loop])
                {
                    return false;
                }
            }
            return true;            
        }
        /// <summary>
        /// Compares one string to part of another string.
        /// </summary>
        /// <param name="haystack"></param>
        /// <param name="needle">Needle to look for</param>
        /// <param name="position">Looks to see if the needle is at position in haystack</param>
        /// <returns>Substring(theStringBuilder,offset,compareString.Length) == compareString</returns>
        public static bool IsStringAt(this StringBuilder haystack, string needle,int position)
        {
            if (haystack == null)
            {
                return needle == null;
            }
            if (needle == null)
            {
                return false;
            }
            int len = haystack.Length;
            int compareLen = needle.Length;
            if (len < compareLen + position)
            {
                return false;
            }
            for (int loop = 0; loop < compareLen; loop++)
            {
                if (haystack[loop+position] != needle[loop])
                {
                    return false;
                }
            }
            return true;
        }

    }
}

使用系统；
使用系统文本；
命名空间帮助程序
{
/// 
///向所有StringBuilder对象添加IndexOf、IsStringAt、AreEqual和Substring。
/// 
公共静态类StringBuilderExtension
{
//向StringBuilder类添加IndexOf、Substring和AreEqual。
公共静态int IndexOf（此StringBuilder-theStringBuilder，字符串值）
{
const int NOT_FOUND=-1；
如果（字符串生成器==null）
{
未找到返回；
}
if（String.IsNullOrEmpty（value））
{
未找到返回；
}
int count=字符串生成器的长度；
int len=值。长度；
如果（计数=循环结束）
{
未找到返回；
}
for（int loop=startPosition；loop