c# - texto - La forma más rápida de eliminar caracteres de la cadena

quitar puntos de un string c#

Question

Tengo una cadena de la que tengo que eliminar los siguientes caracteres: ''/ r'', ''/ n'' y ''/ t''. He intentado tres formas diferentes de eliminar estos caracteres y los he evaluado para poder obtener la solución más rápida.

Los siguientes son los métodos y el tiempo de ejecución cuando los ejecuté 1000000 veces:

Debería ser la solución más rápida si tengo 1 o 2 caracteres para eliminar. Pero a medida que pongo más char, empieza a tomar más tiempo.

str = str.Replace("/r", string.Empty).Replace("/n", string.Empty).Replace("/t", string.Empty);

Tiempo de ejecución = 1695

Para 1 o 2 char, esto fue más lento que String.Replace, pero para 3 char mostró un mejor rendimiento.

string[] split = str.Split(new char[] { ''/t'', ''/r'', ''/n'' }, StringSplitOptions.None);
str = split.Aggregate<string>((str1, str2) => str1 + str2);

Tiempo de ejecución = 1030

El más lento de todos, incluso con 1 personaje. Tal vez mi expresión regular no sea la mejor.

str = Regex.Replace(str, "[/r/n/t]", string.Empty, RegexOptions.Compiled);

Tiempo de ejecución = 3500

Estas son las tres soluciones que se me ocurrieron. ¿Hay alguna solución mejor y más rápida que alguien aquí conozca, o alguna mejora que pueda hacer en este código?

Cadena que utilicé para el benchmarking:

StringBuilder builder = new StringBuilder();
        builder.AppendFormat("{0}/r/n{1}/t/t/t/r/n{2}/t/r/n{3}/r/n{4}/t/t/r/n{5}/r/n{6}/r/n{7}/r/n{8}/r/n{9}",
         "SELECT ",
         "[Extent1].[CustomerID] AS [CustomerID], ",
         "[Extent1].[NameStyle] AS [NameStyle], ",
         "[Extent1].[Title] AS [Title], ",
           "[Extent1].[FirstName] AS [FirstName], ",
           "[Extent1].[MiddleName] AS [MiddleName], ",
           "[Extent1].[LastName] AS [LastName], ",
           "[Extent1].[Suffix] AS [Suffix], ",
           "[Extent1].[CompanyName] AS [CompanyName], ",
           "[Extent1].[SalesPerson] AS [SalesPerson], ");
        string str = builder.ToString();

Answer 1

Aquí está la versión insegura súper-rápida, la versión 2.

    public static unsafe string StripTabsAndNewlines(string s)
    {
        int len = s.Length;
        char* newChars = stackalloc char[len];
        char* currentChar = newChars;

        for (int i = 0; i < len; ++i)
        {
            char c = s[i];
            switch (c)
            {
                case ''/r'':
                case ''/n'':
                case ''/t'':
                    continue;
                default:
                    *currentChar++ = c;
                    break;
            }
        }
        return new string(newChars, 0, (int)(currentChar - newChars));
    }

Y aquí están los puntos de referencia (tiempo para quitar 1000000 cadenas en ms)

cornerback84''s String.Replace: 9433 Andy West''s String.Concat: 4756 AviJ''s char array: 1374 Matt Howells'' char pointers: 1163

Answer 2

Aun más rápido:

public static string RemoveMultipleWhiteSpaces(string s)
    {
        char[] sResultChars = new char[s.Length];

        bool isWhiteSpace = false;
        int sResultCharsIndex = 0;

        for (int i = 0; i < s.Length; i++)
        {
            if (s[i] == '' '')
            {
                if (!isWhiteSpace)
                {
                    sResultChars[sResultCharsIndex] = s[i];
                    sResultCharsIndex++;
                    isWhiteSpace = true;
                }
            }
            else
            {
                sResultChars[sResultCharsIndex] = s[i];
                sResultCharsIndex++;
                isWhiteSpace = false;
            }
        }

        return new string(sResultChars, 0, sResultCharsIndex);
    }

Answer 3

Creo que obtendrás el mejor rendimiento posible al componer la nueva cadena como una matriz char y solo la convertirás en una cadena cuando hayas terminado, así:

string s = "abc";
int len = s.Length;
char[] s2 = new char[len];
int i2 = 0;
for (int i = 0; i < len; i++)
{
    char c = s[i];
    if (c != ''/r'' && c != ''/n'' && c != ''/t'')
        s2[i2++] = c;
}
return new String(s2, 0, i2);

EDITAR: usando String (s2, 0, i2) en lugar de Trim (), por sugerencia

Answer 4

Recorrer la cadena y usar (solo uno) StringBuilder (con el argumento del constructor adecuado, para evitar asignaciones de memoria innecesarias) para crear una nueva cadena podría ser más rápido.

Answer 5

prueba esto

string str = "something /tis /nbetter than nothing";
string removeChars = new String(new Char[]{''/n'', ''/t''});
string newStr = new string(str.ToCharArray().Where(c => !removeChars.Contains(c)).ToArray());

Answer 6

string str;
str = str.Replace(Environment.NewLine, string.Empty).Replace("/t", string.Empty);

Answer 7

String.Join(null, str.Split(new char[] { ''/t'', ''/r'', ''/n'' },
    StringSplitOptions.None));

podría darle un aumento de rendimiento con el uso de Aggregate() ya que Join() está diseñado para cadenas.

EDITAR :

En realidad, esto podría ser aún mejor:

String.Concat(str.Split(new char[] { ''/t'', ''/r'', ''/n'' },
    StringSplitOptions.None));