¿Cómo puedo acelerar este método que elimina texto de una cadena?

Question

Escribí el siguiente método para eliminar el espacio de nombres entre corchetes de cadenas.

Me gustaría hacer esto como rápido como sea posible.

¿Hay alguna forma de acelerar el siguiente código?

using System; 

namespace TestRemoveFast 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      string[] tests = { 
      "{http://company.com/Services/Types}ModifiedAt", 
      "{http://company.com/Services/Types}CreatedAt" 
          }; 

      foreach (var test in tests) 
      { 
       Console.WriteLine(Clean(test)); 
      } 

      Console.ReadLine(); 
     } 

     static string Clean(string line) 
     { 
      int pos = line.IndexOf('}'); 
      if (pos > 0) 
       return line.Substring(pos + 1, line.Length - pos - 1); 
      else 
       return line; 
     } 
    } 
} 

Answer 1

Puede intentar el paralelismo ya que no parece que necesite un tratamiento sincrónico. Un foreach paralelo con PLINQ haría el truco.

Pero si usted no puede esperar hasta VS2010 está oficialmente fuera, podría intentar Poor Man's Parallel.ForEach Iterator by Emre Aydinceren

Answer 2

¿Has probado esto con expresiones regulares y/o utilizar un StringBuilder en lugar de una cadena?

Answer 3

en lugar de su foreach ...

for(int i=0;i<tests.Length;i++) 
    Console.WriteLine(tests[i].Replace("}",null)); 

Answer 4

Si ha cambiado la velocidad por el espacio, puede recorrer una vez en el conjunto dado, y copiar caracteres que no sean '{. *}'. Eso ahorraría dos llamadas (.IndexOf() y .Substring()).

Answer 5

El enfoque parece ser muy rápido. Pero de la cadena que tienes, concluyo que el nombre es generalmente más pequeño que el {URL}. Puede usar el método .LastIndexOf(). Creo que comienza desde el final de la secuencia

Answer 6

Digamos que encuentras una respuesta aquí. Creo que debes considerar cómo se verá la "solución" para el próximo tipo que mire tu código.

Tomaré un código más legible en comparación con un par de milisegundos todos los días.

Answer 7

Lo más lento que hay, con diferencia, es Console.WriteLine(). Tome el siguiente ejemplo:

public void TestCleanSpeed() 
    { 
     var start = DateTime.Now; 
     for (var i = 0; i < 10000; i++) 
     { 
      string[] tests = { 
           "{http://company.com/Services/Types}ModifiedAt", 
           "{http://company.com/Services/Types}CreatedAt" 
          }; 

      foreach (var test in tests) 
      { 
       Console.WriteLine(Clean(test)); 
      } 
     } 
     var end = DateTime.Now; 

     var ts = end - start; 
     Console.WriteLine(ts); 
    } 

Si lo ejecuta como está, demora unos seis segundos. A continuación, elimine Console.WriteLine y en su lugar asigne var newTest = Clean(test);. En mi prueba, tomó menos 0.02 segundos para las 10000 ejecuciones.

Answer 8

El único otro enfoque sería usar line.Remove(0, pos + 1);, pero creo que internamente es Eliminar más complejo que Subcadenas, debido a que Remove también puede cortar algo en el medio.

Por lo tanto, la subcadena() debe ser la más rápida.

Answer 9

Puede convertir su cadena en XName y obtener la sección de nombre de la siguiente manera.

((System.Xml.Linq.XName)"{http://company.com/Services/Types}ModifiedAt").LocalName 

Answer 10

¿Estás seguro de que esto es un cuello de botella en tu código? ¿Cuál es su especificación para los requisitos de tiempo de este método? ¿Ha perfilado el código que tiene ahora para ver si cumple con esas especificaciones?

Supongo que el código que tiene es casi óptimo. Tanto IndexOf como Substring invocan el código unsafe para hacer todo tipo de optimizaciones sofisticadas que no estarán disponibles para usted a menos que también vaya por la ruta unsafe.Si lo hace, terminará reescribiendo IndexOf y Substring de todos modos.

De modo que a menos que este código sea definitivamente un cuello de botella en su código y tenga una especificación razonable de los requisitos de tiempo para este método, concentraría sus esfuerzos en otra parte.

Answer 11

line.Substring(line.IndexOf('}') + 1); 

Marginally faster.