Me he decidido por probar la lectura de archivos XML por parte de LINQ y determinar quien tiene mayor velocidad de lectura, la librería de acceso a XML de .Net o la nueva tecnología: LINQ. Para ello, he creado un XML con 100.000 registros que simula una tabla de alumnos y realizaré consultas a dicho XML.

Éstas son las consultas que he decidido realizar utilizando ambos sistemas:

• Prueba 1: Extraer todos los alumnos que se llamen Jorge.
• Prueba 2: Contar cuantos alumnos han aprobado.
• Prueba 3: De entre los alumnos que se llaman Jorge, ¿cuántos han suspendido?
• Prueba 4: De entre los alumnos que han sacado más de un 8, ¿cual es el nombre más predominante?
• Prueba 5: Extraer sólo los nombres distintos de los alumnos y ordenarlos..

Y tras lanzar las mismas aquí están, en segundos, los tiempos que ha tardado cada método en cada una de las consultas anteriores:

Se puede apreciar claramente la diferencia en velocidades de acceso, siendo el XML Reader entre 7 y 8 veces más lento que LINQ. Pero además, las consultas en LINQ me han ocupado entre 1 y 3 líneas (y porque he querido dividirlo en líneas) mientras que las realizadas con el antiguo método ocupaban entre 10 y 30 líneas.

Por todo esto, LINQ parece batir al XML Reader tanto en velocidad de acceso como en simplificación de código, lo que reduce errores y costes de producción o mantenimiento.

Sé que existen otros métodos para acceder a un XML en .Net (la librería de XML ofrece otras opciones), pero yo me he decantado por ésta, quizás alguna otra resultase más eficiente, pero tras realizar varias pruebas con LINQ, realmente me ha convencido como tecnología de acceso a conjuntos de datos.

Por último, dejo aquí el código fuente utilizado, por si a alguien le pica la curiosidad o he metido la pata y alguien puede corregirme:

    Private Sub TestVelocidad1()
Dim rutaArchivo As String = "C:/test/xmlAlumnos100.xml"
Dim metodoReader As System.Xml.XmlTextReader
Dim metodoLINQ As System.Xml.Linq.XDocument = System.Xml.Linq.XDocument.Load(rutaArchivo)
Dim lstAlumnos As New Collections.Generic.List(Of Alumno)
Dim lstNombres As New Collections.Generic.List(Of String)
Dim oAlumno As Alumno = Nothing
Dim notaAux As Byte = 0
Dim cantAprobados As Integer = 0
Dim cantSuspendidos As Integer = 0

Page.Trace.IsEnabled = True

'Prueba 1: Extraer todos los alumnos que se llamen Jorge.
Trace.Warn("Empieza la prueba 1")
Dim alumnos = From alum In metodoLINQ.Descendants("alumno") _
Where alum.Attribute("nombre") IsNot Nothing AndAlso alum.Attribute("nombre").Value = "Jorge" _
Select Nombre = alum.Attribute("nombre").Value, Nota = alum.Attribute("nota").Value
Trace.Warn("Fin prueba 1 con LINQ")

metodoReader = New System.Xml.XmlTextReader(rutaArchivo)
Do While metodoReader.Read
If metodoReader.NodeType = System.Xml.XmlNodeType.Element AndAlso metodoReader.Name = "alumno" AndAlso metodoReader.HasAttributes Then
oAlumno = New Alumno
While metodoReader.MoveToNextAttribute
If metodoReader.Name = "nombre" Then
oAlumno.Nombre = metodoReader.Value
If oAlumno.Nombre <> "Jorge" Then Exit While
ElseIf metodoReader.Name = "nota" Then
Byte.TryParse(metodoReader.Value, oAlumno.Nota)
End If
End While
If oAlumno.Nombre = "Jorge" Then lstAlumnos.Add(oAlumno)
End If
Loop
Trace.Warn("Fin prueba 1 con Reader")

'Prueba 2: Contar cuantos alumnos han aprobado.
Trace.Warn("Empieza la prueba 2")
cantAprobados = (From alum In metodoLINQ.Descendants("alumno") Where alum.Attribute("nota") IsNot Nothing AndAlso Integer.Parse(alum.Attribute("nota").Value) > 4).Count
Trace.Warn("Fin prueba 2 con LINQ")

metodoReader = New System.Xml.XmlTextReader(rutaArchivo)
cantAprobados = 0
Do While metodoReader.Read
If metodoReader.NodeType = System.Xml.XmlNodeType.Element AndAlso metodoReader.Name = "alumno" AndAlso metodoReader.HasAttributes Then
notaAux = 0
While metodoReader.MoveToNextAttribute
If metodoReader.Name = "nota" Then
Byte.TryParse(metodoReader.Value, notaAux)
If notaAux > 4 Then cantAprobados += 1
End If
End While
End If
Loop
Trace.Warn("Fin prueba 2 con Reader")

'Prueba 3: De entre los alumnos que se llaman Jorge, ¿cuántos han suspendido?
Trace.Warn("Empieza la prueba 3")
cantSuspendidos = (From alum In metodoLINQ.Descendants("alumno") _
Where alum.Attribute("nombre") IsNot Nothing AndAlso alum.Attribute("nombre").Value = "Jorge" _
Where alum.Attribute("nota") IsNot Nothing AndAlso Integer.Parse(alum.Attribute("nota").Value) < 5).Count
        Trace.Warn("Fin prueba 3 con LINQ")

        metodoReader = New System.Xml.XmlTextReader(rutaArchivo)
        cantSuspendidos = 0
        oAlumno = New Alumno
        Do While metodoReader.Read
            If metodoReader.NodeType = System.Xml.XmlNodeType.Element AndAlso metodoReader.Name = "alumno" AndAlso metodoReader.HasAttributes Then
                notaAux = 0 : oAlumno.Nombre = "" : oAlumno.Nota = 0
                While metodoReader.MoveToNextAttribute
                    If metodoReader.Name = "nota" Then Byte.TryParse(metodoReader.Value, oAlumno.Nota)
                    If metodoReader.Name = "nombre" Then oAlumno.Nombre = metodoReader.Value
                End While
                If oAlumno.Nombre = "Jorge" And oAlumno.Nota < 5 Then cantSuspendidos += 1
            End If
        Loop
        Trace.Warn("Fin prueba 3 con Reader")

        'Prueba 4: De entre los alumnos que han sacado más de un 8, ¿cual es el nombre más predominante?
        Dim NombreMasEmpollon As String = ""
        Trace.Warn("Empieza la prueba 4")

        Dim empollon As Generic.List(Of String) = (From n In (From alum In metodoLINQ.Descendants("alumno") _
            Where (alum.Attribute("nota") IsNot Nothing AndAlso Integer.Parse(alum.Attribute("nota").Value) >  _
            Group alum By nombre = alum.Attribute("nombre").Value Into cantNombres = Count() _
            Select nombre, cantNombres Order By cantNombres Descending Order By cantNombres Descending Take 1) Select n.nombre).ToList
        NombreMasEmpollon = empollon.Item(0).ToString
        Trace.Warn("Fin prueba 4 con LINQ")

        metodoReader = New System.Xml.XmlTextReader(rutaArchivo)
        Dim klstNombres As New Generic.SortedList(Of String, Integer)
        oAlumno = New Alumno
        Do While metodoReader.Read
            If metodoReader.NodeType = System.Xml.XmlNodeType.Element AndAlso metodoReader.Name = "alumno" AndAlso metodoReader.HasAttributes Then
                oAlumno.Nombre = "" : oAlumno.Nota = 0
                While metodoReader.MoveToNextAttribute
                    If metodoReader.Name = "nota" Then Byte.TryParse(metodoReader.Value, oAlumno.Nota)
                    If metodoReader.Name = "nombre" Then oAlumno.Nombre = metodoReader.Value

                    If oAlumno.Nota > 0 And oAlumno.Nombre.Length > 0 Then
                        If oAlumno.Nota > 8 Then
                            If klstNombres.Keys.IndexOf(oAlumno.Nombre) < 0 Then
                                klstNombres.Add(oAlumno.Nombre, 1)
                            Else
                                klstNombres.Item(oAlumno.Nombre) = klstNombres.Item(oAlumno.Nombre) + 1
                            End If
                        End If
                        Exit While
                    End If
                End While
            End If
        Loop
        NombreMasEmpollon = klstNombres.Keys(0)
        For Each n As String In klstNombres.Keys
            If klstNombres(n) > klstNombres(NombreMasEmpollon) Then
                NombreMasEmpollon = n
            End If
        Next
        Trace.Warn("Fin prueba 4 con Reader")

        'Prueba 5: Extraer sólo los nombres distintos de los alumnos y ordenarlos.
        Trace.Warn("Empieza la prueba 5")
        Dim nombres As String() = (From alum In metodoLINQ.Descendants("alumno") Select n = alum.Attribute("nombre").Value Distinct Order By n.ToString).ToArray
        Trace.Warn("Fin prueba 5 con LINQ")

        metodoReader = New System.Xml.XmlTextReader(rutaArchivo)
        lstNombres.Clear()
        Do While metodoReader.Read
            If metodoReader.NodeType = System.Xml.XmlNodeType.Element AndAlso metodoReader.Name = "alumno" AndAlso metodoReader.HasAttributes Then
                While metodoReader.MoveToNextAttribute
                    If metodoReader.Name = "nombre" Then
                        If lstNombres.IndexOf(metodoReader.Value) < 0 Then
                            lstNombres.Add(metodoReader.Value)
                        End If
                        Exit While
                    End If
                End While
            End If
        Loop
        lstNombres.Sort()
        Trace.Warn("Fin prueba 5 con Reader")

    End Sub

Public Class Alumno

#Region "Variables"
    Private _nombre As String
    Private _nota As Byte
#End Region

#Region "Propiedades"
    Public Property Nombre() As String
        Get
            Return _nombre
        End Get
        Set(ByVal value As String)
            _nombre = value
        End Set
    End Property
    Public Property Nota() As Byte
        Get
            Return _nota
        End Get
        Set(ByVal value As Byte)
            _nota = value
        End Set
    End Property
#End Region

End Class

Dejando de lado cuestiones de usabilidad y diseño, he preferido probar su motor de búsqueda para intentar vislumbrar el potencial técnico de este nuevo buscador que, siendo desconfiado, me da que sigue siendo el mismo Live Search con un lavado de cara, ¿Me equivocaré?

Para ser lo más objetivo posible, voy a repetir el test de evaluación de buscadores que realicé hace año y medio:

Prueba 1: Buscar términos genéricos

Palabras clave: Guerra civil española
Resultados prácticamente idénticos, con la diferencia de que Bing no le da el primer puesto a la wikipedia.

Prueba 2: Buscar términos comerciales.

Palabras clave: pisos en barcelona
Resultados muy parecidos a los de Yahoo, no tanto a los de Google. Pero resulta difícil evaluar la calidad de los mismos dada la enorme optimización SEO que tienen todos esos sitios. Por cierto, que pisos.com sale en primera página de todos ellos.

Prueba 3: Buscar datos específicos y difíciles.

Palabras clave: Ruben Canton
He querido realizar la misma prueba que en la otra ocasión ya que fue aquí en donde fallaron Yahoo y MSN Search. En esta ocasión los resultados han sido mucho más acertados, también hay que decir que han tenido año y medio para indexarlos y a día de hoy es mucho más fácil indexar páginas, pero lo cierto es que han mejorado.

Prueba 4: Buscando imágenes.

Palabras clave: Parlamento europeo, Howard Gardner, Camara Digital Canon
En la primera búsqueda Yahoo falla bastante, mientras el resto te muestran muchos resultados correctos y variados. Lo sorprendente llega en la segunda búsqueda, Bing le da prioridad a los retratos que a los artículos que hablan de Howard, superando con creces los resultados de Google o Yahoo. Pero si con eso no tenías bastante esperad que aun llega lo mejor, si buscamos “Camara Digital Canon” no sólo nos muestra muy buenos resultados sino que además nos permite filtrar por una serie de características (tamaño, color, diseño, estilo, …) increíble!!!

Importante: Aquí es donde hay que darle otra medalla para Microsoft, su buscador de imágenes utiliza la tecnología AJAX JavaScript para mostrarte todas las imágenes en una sola página, que se van cargando conforme desplazas el scroll, mientras que Google o Yahoo tienen el incómodo sistema de páginas que te obliga a realizar muchos clicks y es mas lento.

Prueba 5: Nos vamos de compras…

Palabras clave: camara digital canon
Bueno, aquí si me siento algo decepcionado y estafado. Google no ofrece este servicio, Yahoo redirige tu búsqueda a Kelkoo y Bing la redirije a Ciao… sinceramente, no era esto lo que me esperaba, sino más bien un servicio de crawling de las webs de venta más punteras capaz de mostrarte los artículos que hay en todas ellas a la vez, incluyendo precios!! Eso sí sería algo que valga la pena… para buscar en ciao no necesito a Bing.

Conclusiones

Aunque quizás las búsquedas de palabras están más igualadas a día de hoy (o eso o yo no he sabido realizar buenas pruebas), la búsqueda de imágenes es descaradamente superior en Bing, respecto a lo de compras… creo que tendremos que esperar hasta que ese servicio tenga una utilidad real. En todo caso, mis malos augurios respecto a Bing desaparecen, este buscador realmente tiene potencial, o por lo menos, su buscador de imágenes.

¿Qué es LINQ?

LinQ (Language Integrated Query) es una nueva librería que se integra en Visual Studio 2008 y permite gestionar colecciones de datos de forma más directa utilizando un lenguaje similar al de SQL. Las colecciones de datos pueden proceder de un simple array, una base de datos relacional, un listado de objetos en caché, un archivo XML u orígenes de datos de terceros.

¿Cómo se usa LINQ?

Lo mejor para ver esto es poner un ejemplo de cómo se hacían antes las cosas y cómo pueden hacerse ahora gracias a LINQ:

Pongamos que por ejemplo tenemos una BDD de alumnos con la tabla TAlumnos y los campos Nombre, Nota y Aprobado por simplificar. Pongamos que nuestro proyecto realiza el 90% de las consultas a esa tabla, y el 70% son simples selects para mostrar datos. Como queremos ahorrarnos cientos de accesos a la BDD (abrir conexión, realizar consulta, cerrar conexión) realizamos una carga inicial de todos esos datos en caché, guardándolo todo en memoria a través de un listado de objetos definidos por la clase CAlumno de propiedades Nombre, Nota y Aprobado.

Imaginemos ahora que quiero consultar los alumnos que han aprobado, y para evitar acceder a la BDD y aprovechando que están en caché hago lo siguiente:

        Dim aprobados As New Collections.Generic.List(Of CAlumno)
        For Each alum As CAlumno In Cache.getAlumnos()
            If alum.Aprobado = True Then
                aprobados.Add(alum)
            End If
        Next

Aunque supongo que ya se entiende, Cache.getAlumnos devuelve una lista de objetos CAlumno. Por otro lado, meto los aprobados en una lista para luego insertarlos en un GridView sin problemas. Ahora veamos cómo hacer eso mismo con LINQ:

Dim aprobados As New Collections.Generic.List(Of CAlumno)
aprobados = From alum In Cache.getAlumnos() Where alum.Aprobado = True

Básicamente la sintaxis que lo inicia todo es “FROM” tras eso se coloca el origen y se le pueden añadir distintas cláusulas como “DISTINCT”, “WHERE”, “ORDER BY”, “GROUP BY”, “HAVING”, “JOIN”, “UNION”, etc y al final un “SELECT” en caso de que sólo queramos coger ciertos campos. Si en el caso anterior sólo quisiéramos los nombres:

Dim aprobados As String()
aprobados = From alum In Cache.getAlumnos() Where alum.Aprobado = True SELECT alum.Nombre

Más allá de la simplificación de código, mi pregunta ahora es… ¿qué resulta más eficiente? ¿Qué consume menos recursos o tiempo de proceso? Pues bien, lo mejor para esto es realizar un test de velocidad accediendo a los datos de un XML en LINQ y de la forma tradicional, pero otro día, que por hoy ya tenemos bastante.

Para quien quiera saber más sobre LINQ le recomiendo este post de Jorge Serrano.

Escribo éstas palabras conforme doy mis primeros pasos, empezamos por el formulario de registro, muy ergonómico, en que quizás sobraba pedir nombre y apellidos reales o la fecha de nacimiento (sí, sé para qué lo piden, hay que segmentar la BD, pero como usuario me resulta incómodo).

Tras esto volvemos a la Home y me encuentro 4 secciones, diré lo que opino sin entrar en ellas, lo primero, el texto largo al pasar por encima el ratón está muy forzado (se come los márgenes), lo redondearía un poco y lo acortaría, en menos se puede decir más, puede que incluso no sea necesario.

1. Seccion 1: Gestiona tus verdaderas inversiones: Mi primera impresión es que me da miedo, me pide datos para conectarse a mi banco y ver mis inversiones de forma que yo pueda seguirlas en directo. ¿En serio creen que voy a hacer eso? Ni loco!!
2. Comparte tus conocimientos: Ésta si resulta interesante, opciones de blogging y comunicación.
3. Compara tus carteras: Seguramente la sección mas interesante, poder ver las carteras de otros y aprender de lo que hacen. Transparencia absoluta para cuando un “experto” te diga que inviertas en Telecinco cuando él se ha salido o porque él se quedó pillado al comprar hace unos meses.
4. ¡Y es gratis!: No esperaba lo contrario…

Sigo adelante y decido ver de qué opciones dispongo. El área privada me encanta, tienes todos los módulos sueltos y personalizables con “drag and drop”, de forma que puedes poner a tu gusto las cosas que quieres ver y en el orden que prefieras para trabajar. Una cosa curiosa, no puedo poner mi foto, aunque me dejan elegir entre 6 o 7 avatares.

Escribo un post en el Blog y veo que dispongo de muy pocas opciones y no es personalizable. Quizás sería mejor dar la opción de poner el feed de tu propio blog, como en FaceBook, y que se vaya publicando automáticamente.

Quiero volver a la Home (donde las 4 secciones) y me encuentro con que ningún enlace me lleva allí excepto uno que me lleva a una zona que parece mas bien publicitaria. Cuando por fin consigo entrar en las secciones veo que casi todo es publicitario y no puedo chafardear las acciones de los demás… ¡Muy mal! =(

En general, la idea de la red social es buena. Si un inversor sabe hacer buenas inversiones y es capaz de ganar dinero no debe importarle mostrar al resto sus habilidades, ésto podría permitirle hacer muy buenos contactos y conseguir buenas oportunidades laborales. Sin embargo, para confirmar que realmente ésas son sus inversiones parece necesario ofrecer una serie de datos que yo, por lo menos, no estoy dispuesto a dar.

Por otro lado, la herramienta está muy bien hecha, es cierto que si buscas criticar podrás hacerlo, para gustos… pero me ha parecido un portal muy estable y con mucho potencial, yo lo abriría aun más en el futuro, permitiendo enlazarlo con tu blog, tu feed de Twitter e incluso otras redes sociales como Facebook.

Para el tema de los datos bancarios, ¿existiría la posibilidad de que los bancos pongan un servicio de feed para realizar estas consultas? Sería una forma de evitar tener que dar datos demasiado sensibles.

Build oficial 1583
Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13

En la página de presentación se nos muestran mas cosas acerca de Chrome, muchas de ellas ya se explicaban en el cómic que pudimos ver ayer, creo que una de las cosas que no comenté fueron las mejoras en seguridad que incorpora Chrome, impidiendo que las pestañas tengan permisos para acceder al contenido de otra o al contenido de tu PC, por ejemplo; aunque advertían que los plugins pueden saltarse los controles de seguridad, por lo que habrá que tener cuidado con lo que instalamos.

En general, me ha gustado mucho todo lo que he visto de Google Chrome, me pondré a utilizarlo y ya veremos que tal funciona con el tiempo, de momento, supera el test Acid 2 y CSS Selectors sin ningún problema, aunque el Acid 3 se le ha atragantado un poquillo (63/100 frente a 57/100 de Firefox); por lo que Chrome es el explorador que mejor cumple los estándares.

El nuevo explorador pinta muy bien si nos dejamos llevar por la campaña marketiniana googlera plasmada en este cómic, entre otras cosas, separa cada pestaña en un proceso distinto, lo que consume más memoria (el argumento googliano de la fragmentación de la misma en el largo plazo y los punteros vacíos no me convence ya que también podrían haber hecho un sistema de limpieza de la memoria mas optimizado) pero tiene otras ventajas como no perder todas las pestañas si una se colapsa o seguir trabajando con otras mientras una trabaja.

Al igual que Firefox, Google ha prestado mucha atención a la velocidad de ejecución de JavaScript y con eso en mente han desarrollado la máquina virtual V8, que entre otras cosas, parece que compilará el JS directamente a código máquina para que se ejecute más rápido en vez de interpretarlo. Esto permitirá que páginas como GMail se ejecuten más rápidamente.

No obstante, una de las mejores cosas que veo que piensa incorporar es una especie de “Administrador de tareas” del explorador que te informe de cuántos recursos está consumiendo cada pestaña y cada complemento, de forma que si Chrome te va lento o consume mucha RAM puedas saber el motivo y “matar” el proceso que incordia (o desinstalar el plugin de turno).

También incluye otra mejora muy interesante, al abrir una nueva pestaña, la página inicial que se te abre te mostrará las 9 páginas que mas visitas y tus buscadores más utilizados.

Ya estoy deseando probar que tal funciona y cuál es su interpretación de los estándares, aunque me toca esperar, ya que según he leído por ahí, se podrá descargar hoy mismo en cuanto se levanten los estadounidenses, que siempre son los últimos. =P

Actualización: Se podrá descargar a partir de las 4 de la mañana de esta misma noche hora española.

Me sorprende que el coincidente sea el que menos consuma, ¿significa eso que .Net sigue comparando el resto de caracteres? Pero lo que me deja sin explicación alguna es ver que el coincidente a medias es el que más tiempo tarda… podría pensar que este string es más largo que el anterior y tendría sentido, pero sería absurdo pensar que el algoritmo StartsWith sigue comparando caracteres aunque ya haya encontrado uno no coincidente… ¿No les enseñaron a usar el Exit While?

Y ya que estoy, lo comparo con el Contains y…

Parece que el Contains está bastante mejor optimizado, parece un absurdo ya que el StartsWith lo tiene más fácil, pero los resultados no engañan. Las diferencias en este caso son menores pero se aprecia que el No Coincidente tarda menos que el Coincidente a Medias, que a su vez tarda menos que el Coincidente, lo que daría sentido a la teoría de que deja de comparar chars en cuanto uno rompe la equivalencia. El StarsWith coincidente sí consume menos, pero usarlo conlleva el riesgo de topar con un no coincidente y tardar más.

¿Y el EndsWith? ¿Funcionará igual?

Bueno, lo del EndsWith ya resulta hasta triste, no sólo es el que más tarda si no que además vuelve a demostrar que no parece que hayan sabido hacer un algoritmo con lógica. Al ser un EndsWith tendrían que comparar los strings a la inversa, desde atrás hacia adelante, y saliendo del bucle en cuanto encontrase el primer char no coincidente, pero por los resultados obtenidos mas parece que se ponga a buscar a Wally y a tomarse una cerveza por el camino… ahora sólo faltaría hacer lo mismo en C# para ver si funciona mejor, de hacerlo, el mito del C# resultaría cierto… pero creo que no me atrevo a desmitificar mi querido Visual Basic. Oh Microsoft, ¿por qué nos has abandonado?

Aquí va el código por si queréis verlo por vosotros mismos o podéis encontrar en dónde me he equivocado para obtener estos incomprensibles resultados (que dado que ya me equivoqué con el experimento del otro día, no sería nada raro):

  Private Sub PruebaRendimiento_StartsWith()
        Dim i As Double
        Dim META As Double = 5000000

        Dim strPalabra As String = "escalifragilisticoespialidoso"
        Dim strCoincide As String = "escalifragilisticoespialidoso"
        Dim strCoincidenteAMedias As String = "escalifragilistPosVaSerQueNo"
        Dim strNoCoincide As String = "PosVaSerQueNo"

        Me.Trace.IsEnabled = True
        Me.Trace.Warn("PRUEBA DE RENDIMIENTO. START:")

        '**************************
        'STARTSWITH:

        'No
        Me.Trace.Warn("Empiezo bucle StartsWith no coincidente.")
        For i = 0 To META
            If strPalabra.StartsWith(strNoCoincide) Then
            End If
        Next
        Me.Trace.Warn("Bucle StartsWith no coincidente terminado.____________________________")

        'Casi
        Me.Trace.Warn("Empiezo bucle StartsWith casi coincidente.")
        For i = 0 To META
            If strPalabra.StartsWith(strCoincidenteAMedias) Then
            End If
        Next
        Me.Trace.Warn("Bucle StartsWith casi coincidente terminado.____________________________")

        'Si
        Me.Trace.Warn("Empiezo bucle StartsWith coincidente.")
        For i = 0 To META
            If strPalabra.StartsWith(strCoincide) Then
            End If
        Next
        Me.Trace.Warn("Bucle StartsWith coincidente terminado.____________________________")

        '**************************
        'CONTAINS:

        'No
        Me.Trace.Warn("Empiezo bucle Contains no coincidente.")
        For i = 0 To META
            If strPalabra.Contains(strNoCoincide) Then
            End If
        Next
        Me.Trace.Warn("Bucle Contains no coincidente terminado.____________________________")

        'Casi
        Me.Trace.Warn("Empiezo bucle Contains casi coincidente.")
        For i = 0 To META
            If strPalabra.Contains(strCoincidenteAMedias) Then
            End If
        Next
        Me.Trace.Warn("Bucle Contains casi coincidente terminado.____________________________")

        'Si
        Me.Trace.Warn("Empiezo bucle Contains coincidente.")
        For i = 0 To META
            If strPalabra.Contains(strCoincide) Then
            End If
        Next
        Me.Trace.Warn("Bucle Contains coincidente terminado.____________________________")

        '**************************
        'ENDSWITH:
        strCoincidenteAMedias = "PosNoticoespialidoso"

        'No
        Me.Trace.Warn("Empiezo bucle EndsWith no coincidente.")
        For i = 0 To META
            If strPalabra.EndsWith(strNoCoincide) Then
            End If
        Next
        Me.Trace.Warn("Bucle EndsWith no coincidente terminado.____________________________")

        'Casi
        Me.Trace.Warn("Empiezo bucle EndsWith casi coincidente.")
        For i = 0 To META
            If strPalabra.EndsWith(strCoincidenteAMedias) Then
            End If
        Next
        Me.Trace.Warn("Bucle EndsWith casi coincidente terminado.____________________________")

        'Si
        Me.Trace.Warn("Empiezo bucle EndsWith coincidente.")
        For i = 0 To META
            If strPalabra.EndsWith(strCoincide) Then
            End If
        Next
        Me.Trace.Warn("Bucle EndsWith coincidente terminado.____________________________")

    End Sub

¿Stringloqué? StringBuilder es una clase de .Net que representa un String como un objeto, se encuentra en System.Text y su principal particularidad consiste en un menor consumo de recursos a la hora de formar una cadena de texto (de ahí su nombre). StringBuilder reserva un buffer de memoria de forma que cuando vas a insertar nuevos caracteres mira si el buffer es suficiente, si lo es los mete, si no lo es, amplia el búffer y los mete.

Pero, ¿que hacía entonces el String normal? El String normal tiene varias formas de ser concatenado, .Concat, .Join, “+” y “&”. Cada una de ellas distinta pero en principio todas iguales, la idea, y a menos que alguien me corrija y me saque del error, es que crea un nuevo objeto a partir de los ya existentes (un nuevo string), lo que parece consumir bastante mas RAM además de tiempo de proceso.

Yo, por curiosidá de esa que sólo un frikie informático tiene y por culpa de la cual nos consideran un reducto mutante de la sociedad (nosotros nos creemos pr0s) decidí generar un algoritmo facilón y activar el sistema de trazas para realizar carreras… ¿Queréis saber quien gana?

Primero que todo os muestro el código fuente, por si alguien ve algún error en el mismo que pueda haber alterado los resultados:

    Private Sub PruebaRendimiento()
        Dim i As Integer
        Dim strTest As String = ""
        Dim strTestBuilder As New StringBuilder
        Dim META As Integer = 50000
        Dim arrStrings() As String = {""}

        Me.Trace.IsEnabled = True
        Me.Trace.Warn("PRUEBA DE RENDIMIENTO. START:")

        'STRING +
        Me.Trace.Warn("Empiezo bucle con String +.")
        For i = 0 To META
            strTest += i.ToString
        Next
        Me.Trace.Warn("Bucle con String + terminado.____________________________")

        'STRING &
        strTest = ""
        Me.Trace.Warn("Empiezo bucle con String &.")
        For i = 0 To META
            strTest = strTest & i.ToString
        Next
        Me.Trace.Warn("Bucle con String & terminado.____________________________")

        'STRING CONCAT
        strTest = ""
        Me.Trace.Warn("Empiezo bucle con String CONCAT.")
        For i = 0 To META
            strTest = String.Concat(strTest, i.ToString)
        Next
        Me.Trace.Warn("Bucle con String CONCAT terminado.____________________________")

        'STRING JOIN
        strTest = ""
        Me.Trace.Warn("Empiezo bucle con String JOIN.")
        For i = 0 To META
            Array.Resize(arrStrings, arrStrings.Length + 1)
            arrStrings.SetValue(i.ToString, arrStrings.Length - 1)
        Next
        strTest = String.Join("", arrStrings)
        Me.Trace.Warn("Bucle con String JOIN terminado.____________________________")

        'STRING BUILDER
        strTest = ""
        Me.Trace.Warn("Empiezo bucle con StringBuilder.")
        For i = 0 To META
            strTestBuilder.Append(i.ToString)
        Next
        Me.Trace.Warn("Bucle con StringBuilder terminado.____________________________")

    End Sub

Tras lo cual, hice 3 pruebas, una facililla de 5 vueltas al bucle, otra algo mas dura con 5000 y finalmente la bestia negra que casi tumba al .Net con 50.000 (y no quiero ni saber cuánto ocupaba ese string). Aquí tenéis los resultados:

Nota: Estas conclusiones las saqué bajo un error, los datos reales están más abajo

En principio no existen demasiadas diferencias entre las pruebas, el tiempo aumenta a la vez que lo hace la variable META, no obstante, al CONCAT y al & se les ha atragantado muchísimo la bestia negra mientras que StringBuilder ni se ha inmutado. StringBuilder es el ganador indiscutible y supera a todos los demás en todas las pruebas con una mayor velocidad de concatenación, pero claro, eso era lo que se esperaba de él… ¿no? (Hay que ver que poca fe tenéis en Microsoft…).

La sorpresa me ha llegado del Concat y del &, por un lado, el & no debería tener tantos problemas al concatenar dos cadenas, o cuanto menos debería tener menos problemas que un + que se puede utilizar para mas cosas, pero sobretodo, sorprende ver cómo el .Concat es el perdedor absoluto de esta carrera de concatenaciones, y eso que se supone que el método fue creado para algo… no parece que fuera para hacer códigos optimizados.

El resto de conclusiones podéis sacarlas vosotros mismos, eso sí, con cadenas se pueden hacer mas cosas, como replaces, substrings, remove, copy, … habría que ver una a una quién resulta mas eficiente, ¿alguien se anima?

Actualización

Parece ser que se me olvió limpiar la variable strTest tras cada bucle, con lo que los resultados anteriores estaban adulterados y eran erróneos. Tras rectificar el pequeño problemilla estos son los resultados de la bestia negra:

El ganador indiscutible sigue siendo el StringBuilder, el Join no se vio muy afectado por el error del algoritmo por ser un array y los demás son prácticamente idénticos, así que ya podré volver a usar el & como de costumbre…

Espero que quienes leyeran las conclusiones anteriores se lean las nuevas y no vivan pensando que el .Concat es el anticristo de la optimización de código. :S Por cierto, que si tenemos en cuenta que el error del algoritmo anterior acumulaba las cadenas bucle a bucle, el StringBuilder, por estar al final, se comía la peor cadena de todas y a pesar de eso ofrecía el mejor rendimiento de todos siendo casi instantáneo, un /clap bien grande desde aquí a Microsoft por semejante objeto ultraoptimizado que ponen a nuestra disposición (si, los informáticos decimos /clap, ¿que pasa?).