Reemplazo de caracteres en cadenas en VB.NET

Question

¿Qué tan rápido puedo reemplazar caracteres en una cadena?

El trasfondo de esta pregunta es este: tenemos un par de aplicaciones que se comunican entre sí y con las aplicaciones de los clientes a través de sockets. Estos mensajes de socket contienen caracteres no imprimibles (por ejemplo, chr (0)) que necesitan ser reemplazados por una cadena predeterminada (por ejemplo, "{Nul}"}, porque los mensajes de socket se guardan en un archivo de registro. En una nota lateral, no cada mensaje de registro tendrá que tener caracteres reemplazados.

Ahora se ubicó en esta pequeña aventura de lectura de this MSDN link que encontré de un puesto diferente de este sitio.

el método actual se utilizó en el ... principio del día ... estaba usando StringBuilder para buscar todos los reemplazos posibles, como ...

Public Function ReplaceSB(ByVal p_Message As String) As String 
     Dim sb As New System.Text.StringBuilder(p_Message) 

     sb.Replace(Chr(0), "{NUL}") 
     sb.Replace(Chr(1), "{SOH}") 

     Return sb.ToString 
    End Function 

Ahora, como indica la publicación del blog, dejar StringBuilder fuera y usar string.replace produce resultados más rápidos. (En realidad, el uso de StringBuilder era el método más lento de hacer esto durante todo el día.)

p_Message = p_Message.Replace(Chr(0), "{NUL}") 
    p_Message = p_Message.Replace(Chr(1), "{SOH}") 

Sabiendo que no necesitaría cada mensaje que pasar por este proceso que pensé que sería ahorrar tiempo al no tener que procesar esos mensajes que podría ser dejado afuera. Entonces, al usar expresiones regulares, primero busqué la cadena y luego determiné si necesitaba ser procesada o no. Esto era más o menos lo mismo que usar el string.replace, básicamente un lavado al guardar el tiempo de no procesar todas las cadenas, pero perder tiempo de revisarlas todas con expresiones regulares.

Luego se sugirió probar el uso de algunas matrices que coinciden con sus índices con las antiguas y las nuevas y usarlas para procesar los mensajes. Entonces sería algo como esto ...

Private chrArray() As Char = {Chr(0), Chr(1)} 
Private strArray() As String = {"{NUL}", "{SOH}"} 

Public Function TestReplace(ByVal p_Message As String) As String 
    Dim i As Integer 

    For i = 0 To ((chrArray.Length) - 1) 
     If p_Message.Contains(chrArray(i).ToString) Then 
      p_Message = p_Message.Replace(chrArray(i), strArray(i)) 
     End If 
    Next 

    Return p_Message 
End Function 

Hasta ahora, esta ha sido la forma más rápida que he encontrado para procesar estos mensajes. He intentado varias otras formas de resolver esto, así como convertir la cadena entrante en una matriz de caracteres y compararla con también intentar recorrer la cadena en lugar de chrArray.

Así que mi pregunta a todos es: ¿Puedo hacer esto más rápido? ¿Qué me estoy perdiendo?

Answer 1

Es posible que pueda exprimir un poco más de velocidad reduciendo algunas búsquedas. Tomemos, por ejemplo esto:

If p_Message.Contains(chrArray(i).ToString) Then 

El .Contains método es O (n). En el peor de los casos, vas a atravesar todos los caracteres en toda la cadena sin encontrar nada, por lo que esperas atravesar al menos una vez para cada carácter en tu matriz, por lo que es O (nm) donde n es la longitud de su cadena ym es la cantidad de caracteres que está reemplazando.

Es posible conseguir un poco mejor rendimiento de la siguiente manera (mi VB-fu es oxidado, no se ha probado;)):

Private Function WriteToCharList(s as String, dest as List(Of Char)) 
    for each c as Char in s 
     dest.Add(c) 
    Next 
End Function 

Public Function TestReplace(ByVal p_Message As String) As String 
    Dim chars as new List(Of Char)(p_Message.Length) 

    For each c as Char in p_Message 
     Select Case c 
      Case Chr(0): WriteToCharList("{NUL}", chars) 
      Case Chr(1): WriteToCharList("{SOH}", chars) 
      Case Else: chars.Add(c); 
     End Select 
    Next 

    Return New String(chars) 
End Function 

Este atravesará caracteres en p_Message como máximo dos veces (una vez para atravesar , una vez cuando el constructor de cadenas copia la matriz de caracteres), haciendo que esta función sea O (n).

Answer 2

StringBuilder ofrece la función Replace() más rápida en .NET.

Answer 3

Un par de notas generales aquí:

1. que podría ser capaz de mejorar la función de búsqueda mediante el uso de una llanura .IndexOf() o .Contains() búsqueda, ya que sólo está buscando caracteres individuales.
2. Es posible que pueda mejorar su rendimiento total devolviendo el objeto StringBuilder desde su función directamente y proporcionando sobrecargas para otras funciones que acepten constructores de cadenas como entrada o llamando a .ToString() en algún momento posterior del proceso (nota: También puede llamar a .ToString() en objetos que ya son cadenas)
3. Definitivamente, debe poder mejorar aún más el rendimiento/rendimiento mediante el uso de un StringReader/TextReader en la cadena y continuar tratando todo como transmisiones que siguen pasando por la cadena .

Al menos puede modificar su método final de esta manera:

Public Function TestReplace(ByVal p_Message As String) As String 
    Static chrArray() As Char = {ChrW(0), ChrW(1)} 
    Static strArray() As String = {"{NUL}", "{SOH}"} 

    Dim rdr As New StringReader(p_Message) 
    Dim result As New StringWriter() 

    Dim i As Integer 
    While (i = rdr.Read()) <> -1 
     Dim c As Char = ChrW(i) 
     Dim index As Integer = Array.IndexOf(chrArray, c) 
     If index >= 0 Then result.Write(strArray(index)) Else result.Write(c) 
    End While 

    Return result.ToString() 
End Function 

Nota que sus puntos de referencia dependerán en gran medida del tipo de cuerdas que está lanzando en ella, por lo que asegúrese de que está utilizando la muestra más representativa (y debe ser una muestra de buen tamaño) posible.

Answer 4

Echa un vistazo a este example. Tiene algunas estadísticas de referencia que comparan los dos métodos.

Answer 5

Esto también debería ser más rápido:

Private Shared strList As New Dictionary(Of Char, String) 

    Shared Sub New() 
     strList.Add(Chr(0), "{NUL}") 
     strList.Add(Chr(1), "{SOH}") 
    End Sub 

    Public Function TestReplace(ByVal p_Message As String) As String 
     For Each c As Char In strList.Keys 
      If p_Message.IndexOf(c) <> -1 Then 
       p_Message = p_Message.Replace(c, strList(c)) 
      End If 
     Next 

     Return p_Message 
    End Function