如何在C#中替换字符串中的多个子字符串？

我必须替换一个字符串中的多个子字符串（输入字符串的最大长度为32）。我有一个大字典，它可以有数百万项作为键值对。我需要检查每个单词在字典中是否存在该单词，如果字典中存在，则替换为相应的值。输入字符串可以有多个尾随空格

这个方法被调用了数百万次，因此，它严重影响了性能

代码中是否有任何优化范围或其他更好的方法来实现这一点

public static string RandomValueCompositeField(object objInput, Dictionary<string, string> g_rawValueRandomValueMapping) {

if (objInput == null)
    return null;

string input = objInput.ToString();
if (input == "")
    return input;

//List<string> ls = new List<string>();
int count = WhiteSpaceAtEnd(input);
foreach (string data in input.Substring(0, input.Length - count).Split(' ')) {

    try {
        string value;
        gs_dictRawValueRandomValueMapping.TryGetValue(data, out value);
        if (value != null) {

            //ls.Add(value.TrimEnd());
            input = input.Replace(data, value);
        }
        else {
            //ls.Add(data);
        }
    }
    catch(Exception ex) {

    }

}

//if (count > 0)
//    input = input + new string(' ', count);
    //ls.Add(new string(' ', count));

return input;
}

公共静态字符串RandomValueCompositeField（对象对象对象输入，字典g_rawValueRandomValueMapping）{
if（objInput==null）
返回null；
字符串输入=objInput.ToString（）；
如果（输入==“”）
返回输入；
//列表ls=新列表（）；
int count=空格结束（输入）；
foreach（input.Substring中的字符串数据（0，input.Length-count）.Split（“”））{
试一试{
字符串值；
gs_dictRawValueRandomValueMapping.TryGetValue（数据，输出值）；
if（值！=null）{
//ls.Add（value.TrimEnd（））；
输入=输入。替换（数据、值）；
}
否则{
//ls.添加（数据）；
}
}
捕获（例外情况除外）{
}
}
//如果（计数>0）
//输入=输入+新字符串（“”，计数）；
//ls.Add（新字符串（“”，count））；
返回输入；
}

编辑：

---

我在问题中遗漏了一件重要的事情。子字符串在输入字符串中只能出现一次。字典中的任何键和值都有相同数量的字符。

这里有一个方法，它将接受一个输入字符串，并通过查找“单词”（任何连续的非空白），然后检查该单词是否在字典中，如果找到，则用相应的值替换它来构建一个新字符串。这将解决

Replace

替换“子单词”的问题（如果你有“hello hell”，你想用“天堂”替换“地狱”，但你不想让它给你“天堂”）。它还解决了交换的问题。例如，如果您想将“是”替换为“否”，将“否”替换为“是”，那么您不希望先将其转换为“否”，然后再转换为“是”

公共字符串替换词（字符串输入、字典替换）
{
var builder=新的StringBuilder（）；
int-wordStart=-1；
int字长=0；
for（int i=0；i=0）
{
//找到这个词并查字典
//如果发现，请使用替换，如果没有，请保留单词。
var word=input.Substring（wordStart，wordLength）；
if（replacements.TryGetValue（word，out var replace））
{
附加（替换）；
}
其他的
{
builder.Append（word）；
}
}
//确保重置起点和长度
wordStart=-1；
字长=0；
//追加找到的任何空格。
builder.Append（输入[i]）；
}
//如果这不是空白，如果还没有设置，我们就设置wordStart
//只需增加长度。
其他的
{
如果（wordStart==-1）wordStart=i；
字长++；
}
}
//如果wordStart不是-1，那么我们需要检查后面的单词。
如果（wordStart>=0）
{
var word=input.Substring（wordStart，wordLength）；
if（replacements.TryGetValue（word，out var replace））
{
附加（替换）；
}
其他的
{
builder.Append（word）；
}
}
返回builder.ToString（）；
}

这里有一个方法，该方法将获取一个输入字符串，并通过查找“单词”（任何连续的非空白），然后检查该单词是否在字典中，并在找到时用相应的值替换它来构建一个新字符串。这将解决

Replace

替换“子单词”的问题（如果你有“hello hell”，你想用“天堂”替换“地狱”，但你不想让它给你“天堂”）。它还解决了交换的问题。例如，如果您想将“是”替换为“否”，将“否”替换为“是”，那么您不希望先将其转换为“否”，然后再转换为“是”

公共字符串替换词（字符串输入、字典替换）
{
var builder=新的StringBuilder（）；
int-wordStart=-1；
int字长=0；
for（int i=0；i=0）
{
//找到这个词并查字典
//如果发现，请使用替换，如果没有，请保留单词。
var word=input.Substring（wordStart，wordLength）；
if（replacements.TryGetValue（word，out var replace））
{
附加（替换）；
}
其他的
{
builder.Append（word）；
}
}
//确保重置起点和长度
wordStart=-1；
字长=0；
//追加找到的任何空格。
builder.Append（输入[i]）；
}
//如果这不是空白，如果还没有设置，我们就设置wordStart
//只需增加长度。
其他的
{
如果（wordStart==-1）wordStart=i；
public string ReplaceWords(string input, Dictionary<string, string> replacements)
{
    var builder = new StringBuilder();
    int wordStart = -1;
    int wordLength = 0;
    for(int i = 0; i < input.Length; i++)
    {
        // If the current character is white space check if we have a word to replace
        if(char.IsWhiteSpace(input[i]))
        {
            // If wordStart is not -1 then we have hit the end of a word
            if(wordStart >= 0)
            {
                // get the word and look it up in the dictionary
                // if found use the replacement, if not keep the word.
                var word = input.Substring(wordStart, wordLength);
                if(replacements.TryGetValue(word, out var replace))
                {
                    builder.Append(replace);
                }
                else
                {
                    builder.Append(word);
                }
            }

            // Make sure to reset the start and length
            wordStart = -1;
            wordLength = 0;

            // append whatever whitespace was found.
            builder.Append(input[i]);
        }
        // If this isn't whitespace we set wordStart if it isn't already set
        // and just increment the length.
        else
        {
            if(wordStart == -1) wordStart = i;
            wordLength++;
        }
    }

    // If wordStart is not -1 then we have a trailing word we need to check.
    if(wordStart >= 0)
    {
        var word = input.Substring(wordStart, wordLength);
        if(replacements.TryGetValue(word, out var replace))
        {
            builder.Append(replace);
        }
        else
        {
            builder.Append(word);
        }
    }

    return builder.ToString();
}