C# 查找字符串中带有[tokens]的子字符串的所有引用，并将它们放入int数组中

我有一个工作代码，用于替换字符串中[]内的单个子字符串。这对字符串中的“[1]”有效：

private string returnWithLinks(string adminString, int adminId)
    {
        var returnString = "Nothing at all";

        int pFrom = adminString.IndexOf("[") + "[".Length;
        int pTo = adminString.LastIndexOf("]");

        var getSourceId = adminString.Substring(pFrom, pTo - pFrom);

        int i = 0;
        bool tryParse = int.TryParse(getSourceId, out i);
        if(!tryParse) {returnString = "this is not an int!";} else {
            if(i == 1) {
                returnString = adminString.Replace("[1]", "<a>something</a>" + var1fromsomwhere + i);
            } else if (i == 2) {
                returnString = adminString.Replace("[2]", "<a>other something</a>" + var2fromsomwhere + i);
            } else if (i == 3) {
                returnString = adminString.Replace("[3]", "<a>other something</a>" + var3fromsomwhere + i);
            } else if (i == 4) {
                returnString = adminString.Replace("[4]", "<a>other something</a>" + var4fromsomwhere + i);
            } else if (i == 5) {
                returnString = adminString.Replace("[5]", "<a>other something</a>" + var5fromsomwhere + i);
            }
        }
        return returnString;
    }

我曾考虑将令牌中的所有整数放在一个整数数组上，然后用if子句循环每个整数，但创建数组完全是我的专长

我怎样才能做到这一点

---

拥有数组后，我将使用if子句对其进行循环。

您可以在循环中运行replace

var tokens = new[] { "[1]", "[2]", "[3]", "[4]" };
var replacements = new[] { "one", "two", "three", "four" };

var adminString = "[1][2]somthingelse[2]another[4]aa";
for (int i = 0; i < tokens.Length; i++)
{
   adminString = adminString.Replace(tokens[i], replacements[i]);
}
Console.WriteLine(adminString); //onetwosomthingelsetwoanotherfouraa

var-tokens=new[]{“[1]”、“[2]”、“[3]”、“[4]”；
变量替换=新[]{“一”、“二”、“三”、“四”}；
var adminString=“[1][2]somthingelse[2]另一个[4]aa”；
for（int i=0；i

您不需要数组，甚至不需要循环

有很多方法可以做到这一点。。。例如使用字典

但在你的情况下，没有必要把事情复杂化

一行代码将替换以下内容：

    private string returnWithLinks(string adminString, int adminId)
    {
            var returnString = adminString
               .Replace("[1]", "<a>something</a>" + var1fromsomwhere + 1)
               .Replace("[2]", "<a>something</a>" + var2fromsomwhere + 2)
               .Replace("[3]", "<a>something</a>" + var3fromsomwhere + 3)
               .Replace("[4]", "<a>something</a>" + var4fromsomwhere + 4)
               .Replace("[5]", "<a>something</a>" + var5fromsomwhere + 5);

            return returnString;
    }

private string returnWithLinks（string adminString，int adminId）
{
var returnString=adminString
.Replace（“[1]”，“something”+var1fromsomwhere+1）
.Replace（“[2]”，“something”+var2fromsomwhere+2）
.Replace（“[3]”，“[something”+var3fromsomwhere+3”）
.Replace（“[4]”，“[something”+var4fromsomwhere+4”）
.替换（“[5]”，“[something”+var5fromsomwhere+5”）；
返回字符串；
}

使用字典和循环执行以下操作：

    private static readonly Dictionary<string, string> _replacements = new 
    Dictionary<string, string>
    {
        { "[1]", "<a>something</a>" + var1fromsomwhere + 1 },
        { "[2]", "<a>something</a>" + var2fromsomwhere + 2 },
        { "[3]", "<a>something</a>" + var3fromsomwhere + 3 },
        { "[4]", "<a>something</a>" + var4fromsomwhere + 4 },
        { "[5]", "<a>something</a>" + var5fromsomwhere + 5 },            
    };
    private string returnWithLinks(string adminString, int adminId)
    {
            var keys = _replacements.Keys.ToArray();
            var returnString = adminString;

            for(var i = 0; i < keys.Length; i++)
            {
                var key = keys[0];

                returnString = returnString.Replace(key, _replacements[key]);
            }

            return returnString;
    }

private static readonly Dictionary\u replacements=new
字典
{
{[1]，“某物”+var1fromsomwhere+1}，
{[2]，“某物”+var2fromsomwhere+2}，
{[3]，“某物”+var3fromsomwhere+3}，
{[4]，“某物”+var4fromsomwhere+4}，
{[5]，“某物”+var5fromsomwhere+5}，
};
私有字符串returnWithLinks（字符串adminString，int adminId）
{
var keys=_replacements.keys.ToArray（）；
var returnString=adminString；
对于（变量i=0；i

正如您所看到的，字典看起来更干净，但在维护和代码行数方面是完全一样的

对于每次替换，您仍然需要在字典中添加一行

我使用字典在循环中执行此操作的唯一原因是如果字典不是硬编码的

例如，这意味着如果字典中填充了来自数据库的值

---

循环的另一个缺点是每次迭代一次额外分配的字符串分配量。

如果找不到像[12336588]这样的int，会发生什么？你说的“找不到”是什么意思？在那个例子中，标记之间有一个int。是的，但是你的代码只考虑1到5之间的int。。。。那么，如果int为6或32586255会发生什么情况。。。。。。。。。。然后呢？在上面的代码中，它将返回“什么都没有”。但是我想更好的选择是不替换令牌。您不需要数组。如果值不在循环范围内，则此代码将引发异常，并且对于非顺序的值（如2,7,95698,36158）不起作用。当然，此代码还没有准备好用于生产。例如，正如您在回答中所建议的，可以使用字典。循环在这里只是为了不为每个标记重复带有replace的行。这样一个简单的解决方案让我感到羞耻：）dict在这里没有帮助，因为我需要在替换变量之前检查变量是否不是null。例如，[1]被var1fromsomwhere替换，前提是它不为null。但是我可以在if子句之后使用.Replace一次替换一个。它工作完美无瑕。

    private static readonly Dictionary<string, string> _replacements = new 
    Dictionary<string, string>
    {
        { "[1]", "<a>something</a>" + var1fromsomwhere + 1 },
        { "[2]", "<a>something</a>" + var2fromsomwhere + 2 },
        { "[3]", "<a>something</a>" + var3fromsomwhere + 3 },
        { "[4]", "<a>something</a>" + var4fromsomwhere + 4 },
        { "[5]", "<a>something</a>" + var5fromsomwhere + 5 },            
    };
    private string returnWithLinks(string adminString, int adminId)
    {
            var keys = _replacements.Keys.ToArray();
            var returnString = adminString;

            for(var i = 0; i < keys.Length; i++)
            {
                var key = keys[0];

                returnString = returnString.Replace(key, _replacements[key]);
            }

            return returnString;
    }