Originalmente quería preguntar por la forma más rápida de consultar una tabla de datos para una fila especial.Sorprendentes diferencias de rendimiento: List.Constains, SortedList.ContainsKey, DataRowCollection.Contains, DataTable.Select, DataTable.FindBy
He probado 5 métodos diferentes por su rendimiento con un resultado sorprendente (para mí).
Antecedentes: He creado una vista en una base de datos MS Sql-Server 2005. Esta vista tiene un conteo total de 6318 filas. Debido a que debo verificar muy a menudo si existe una identificación dada en esta vista, me pregunté cuál es la forma más eficiente de hacerlo. Creé un DataAdapter en un conjunto de datos fuertemente tipado que devuelve todas las filas y llena una tabla de datos. Mi primer enfoque fue crear una lista genérica compartida (de Int32) y llenarla con los ID de la vista una vez al inicio de la aplicación. Luego use List.Contains para verificar si la ID actual está en esta Lista. Debido a que todas las filas son distintas, me preguntaba si no es más rápido utilizar una SortedList y su ContainsKey -metod. Luego revisé también el rendimiento del acceso directo al Datable con su Select-Method, se genera automáticamente (cuando la columna se define como clave principal) FindBy-method y por último pero no menos importante, el DatarowCollection.Contains -Método. Así que tengo 5 métodos para verificar si mi ID está en esa vista (o lista mapeada/lista ordenada).
Medí su rendimiento con el System.Diagnostics.StopWatch y obtuve algunos resultados interesantes. Pensé que SortedList.ContainsKey debe ser más rápido que List.Contains porque son distintos y ordenados, pero lo contrario es cierto. Pero lo más sorprendente para mí fue que el DataRowCollection.Contains-Method (que primero olvidé) es, con mucho, el más rápido. Es incluso 50 veces más rápido que el método dataTable.FindBy.
- ¿Qué causó estas diferencias?
- ¿He olvidado una manera mejor?
- ¿Mi método de medición es correcto (creo que es mejor que los buclee y tome esos valores)?
- ¿Los valores son transferibles o dependen del tamaño de la tabla de datos/colección?
- Después de mi actualización (1000000 iteraciones) ContainsKey es la más rápida. ¿Esto es porque siempre busco la misma identificación o en general? ¿Hay algún tipo de SortedList sin la sobrecarga de KeyValue-Pair de un diccionario?
Resultados [para 1000000 iteraciones *]
- intervalo de tiempo 1 = SortedList.ContainsKey = Ø 0.65634 [238.1095] ms
- intervalo de tiempo 2 = List.Contains = Ø 0.06802 [57045,37955] ms
- Timespan 3 = DataTable.FindByIdData (método autogenerado) = Ø 0.31580 [1542.62345] ms
- intervalo de tiempo 4 = DataTable.Select = Ø 0,27790 [26029.39635] ms
intervalo de tiempo 5 = DataRowCollection.Contains = Ø 0,00638 [1202.79735] ms
1.) Timespan 1: 0,6913 ms Timespan 2: 0,1053 ms Timespan 3: 0,3279 ms Timespan 4: 0,1002 ms Timespan 5: 0,0056 ms 2.) Timespan 1: 0,6405 ms Timespan 2: 0,0588 ms Timespan 3: 0,3112 ms Timespan 4: 0,3872 ms Timespan 5: 0,0067 ms 3.) Timespan 1: 0,6502 ms Timespan 2: 0,0588 ms Timespan 3: 0,3092 ms Timespan 4: 0,1268 ms Timespan 5: 0,007 ms 4.) Timespan 1: 0,6504 ms Timespan 2: 0,0586 ms Timespan 3: 0,3092 ms Timespan 4: 0,3893 ms Timespan 5: 0,0063 ms 5.) Timespan 1: 0,6493 ms Timespan 2: 0,0586 ms Timespan 3: 0,3215 ms Timespan 4: 0,386 ms Timespan 5: 0,0063 ms Timespan 1: 0,6913 0,6405 0,6502 0,6504 0,6493 = Ø 0,65634 Timespan 2: 0,1053 0,0588 0,0588 0,0586 0,0586 = Ø 0,06802 Timespan 3: 0,3279 0,3112 0,3092 0,3092 0,3215 = Ø 0,31580 Timespan 4: 0,1002 0,3872 0,1268 0,3893 0,3860 = Ø 0,27790 Timespan 5: 0,0056 0,0067 0,0070 0,0063 0,0063 = Ø 0,00638
Y por el bien de la parte integridad de la fuente VB.Net:
Dim applies As Boolean
Dim clock As New System.Diagnostics.Stopwatch
clock.Start()
For i As Int32 = 1 To 1000000
applies = sortedListAC17NextClaims.ContainsKey(myClaim.idData)
Next
clock.Stop()
Dim timeSpan1 As String = "Timespan 1: " & clock.Elapsed.TotalMilliseconds.ToString & " ms"
clock.Reset()
clock.Start()
For i As Int32 = 1 To 1000000
applies = listAC17NextClaims.Contains(myClaim.idData)
Next
clock.Stop()
Dim timeSpan2 As String = "Timespan 2: " & clock.Elapsed.TotalMilliseconds.ToString & " ms"
clock.Reset()
clock.Start()
For i As Int32 = 1 To 1000000
applies = Not MyDS.AC17NextClaims.FindByIdData(myClaim.idData) Is Nothing
Next
clock.Stop()
Dim timeSpan3 As String = "Timespan 3: " & clock.Elapsed.TotalMilliseconds.ToString & " ms"
clock.Reset()
clock.Start()
For i As Int32 = 1 To 1000000
applies = MyDS.AC17NextClaims.Select("idData=" & myClaim.idData).Length > 0
Next
clock.Stop()
Dim timeSpan4 As String = "Timespan 4: " & clock.Elapsed.TotalMilliseconds.ToString & " ms"
clock.Reset()
clock.Start()
For i As Int32 = 1 To 1000000
applies = MyDS.AC17NextClaims.Rows.Contains(myClaim.idData)
Next
clock.Stop()
Dim timeSpan5 As String = "Timespan 5: " & clock.Elapsed.TotalMilliseconds.ToString & " ms"
ACTUALIZACIÓN: he cambiado de resultados y la fuente de arriba. En paréntesis cuadrados son los valores para 1000000 iteraciones. Ahora el resultado es completamente diferente. El método más rápido ahora es definitivamente ContainsKey de SortedList.
ACTUALIZACIÓN 2: me olvidó la alternativa de utilizar List.BinarySearch. Este parece ser el más rápido para mí:
clock.Start() For i As Int32 = 1 To 1000000 applies = listAC17NextClaims.BinarySearch(myClaim.idData) > -1 Next clock.Stop()sólo necesita 219,1805 ms para realizar iteraciones 1000000 y por lo tanto es el más rápido y sin la sobrecarga de un SortedList-KeyValue-Pair. Puedo usarlo sin para ordenar la lista porque el DataAdapter llenó la tabla de datos con una cláusula Order By.
Haga una última con 600M elementos en la tabla y búsquela dos veces con cada método, descartando el tiempo para la primera ejecución de cada uno. –
Eso tomaría demasiado tiempo y sería otro requisito que el mío. –