Buscar todas las ocurrencias de subseries con fichas [] en cadena y colocarlos en int matriz

João Gomes:

Tengo un código de trabajo para la sustitución de una sola subcadena dentro de [] en una cadena. Esto funcionó para un "[1]" en una cadena:

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;
    }

Sin embargo ahora la necesidad de ser capaz de reemplazar todas las ocurrencias de los símbolos tales como:

adminString = "[1][2]somthingelse[2]another[4]aa";

Estaba pensar en colocar todos los enteros dentro ficha en una matriz int, entonces cada bucle con el int si las cláusulas, pero la creación de la matriz está completamente fuera de mi Leage.

¿Cómo puedo conseguir esto?

Después de tener el bucle voluntad array I a través de él con el caso cláusulas.

Jonathan Alfaro :

No es necesario una matriz o incluso un bucle.

Hay muchas maneras de hacer esto ... por ejemplo, utilizando un diccionario.

Pero en su caso no hay necesidad de complicar las cosas.

Una sola línea de código reemplazará todo como esto:

    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;
    }

Haciendo con un diccionario y un bucle:

    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;
    }

Como se puede ver el diccionario parece más limpio, pero en términos de mantenimiento y el número de líneas de código es exactamente lo mismo.

De todos modos tendrá que añadir una línea al diccionario para cada reemplazo.

La única razón por la que lo haría en un bucle con un diccionario sería si el diccionario no está codificado.

Es decir, si el diccionario se llena de valores a partir de una base de datos, por ejemplo.

Otra desventaja del bucle es la cantidad de asignaciones de la secuencia una asignación adicional por iteración.