VB.NET Comment donner de meilleures performances “Select case” ou if... ELSEIF ... ELSE... END if

J'ai un énorme DataTable, et j'ai besoin d'aller dans chaque ligne et de valider une valeur spécifique.

La méthode à me donner plus de performance, une structure de SI d'AUTRE ou SÉLECTIONNEZ CAS?
(Je suis concentré dans la méthode que m'offrent les meilleures performances)

SI D'AUTRE (MÉTHODE N ° 1)

For Each vRow In vDTtemp.Rows
    If vRow("Item") = "Time" Then
        vRow("Result") = "000"
    ElseIf vRow("Item") = "DateTime" Then
        vRow("Result") = "001"
    ElseIf vRow("Item") = "String" Then
        vRow("Result") = "002"
    Else
        vRow("Result") = "N/A"
    End If
Next

SÉLECTIONNEZ CAS (MÉTHODE N ° 2)

For Each vRow In vDTtemp.Rows
    Select Case vRow("Item")
        Case "Time"
            vRow("Result") = "000"
        Case "DateTime"
            vRow("Result") = "001"
        Case "String"
            vRow("Result") = "002"
        Case Else
            vRow("Result") = "N/A"
    End Select
Next
Quels résultats avez-vous fait des tests? Aussi, (1) il peut être plus rapide pour faire référence à des colonnes de l'index au lieu du nom et (2) Select Case est soumise à des optimisations dans une version qui n'a pas fait dans une version de débogage.
Autant que je sache, Il s'mêmes. Dans les deux cas, il va se casser après la découverte d'une véritable condition. Mais Sélectionnez Cas est beaucoup plus agréable et plus propre façon, lorsque vous avez à écrire de nombreux cas, Si les phrases.
Oui, les performances devraient être similaires, mais Sélectionnez Cas est plus lisible.
mmmm, je crois que SI la Méthode #1 peut consommer plus de ressources. Par exemple, toutes les données a la valeur "String", ensuite, les besoins du cycle de considérer le Temps et la date / heure, prendra plus de temps. Dans la méthode n ° 2 de l'sélectionnez cas, allez directement à l'option.
Vous pouvez utiliser le Chronomètre et de voir par vous-même (je n'ai pas beaucoup de données afin de tester moi-même) comme indiqué dans le dreamincode.net/forums/topic/...

OriginalL'auteur MiBol | 2013-02-28

  1. 3

    J'ai passé beaucoup de temps à travailler sur ce même problème depuis quelques jours et nous avons trouvé une approche qui est beaucoup plus rapide que les autres. J'ai aussi constaté que l'aide de Select sur une variable de chaîne était équivalent à une série de if/Else if, et les deux ont été d'une lenteur décevante.

    Cependant la technique suivante a très bien fonctionné, et réduit la quantité de temps de plus de 50%. Au lieu de l'original code:

    For Each vRow In vDTtemp.Rows
    Select Case vRow("Item")
        Case "Time"
            vRow("Result") = "000"
        Case "DateTime"
            vRow("Result") = "001"
        Case "String"
            vRow("Result") = "002"
        Case Else
            vRow("Result") = "N/A"
    End Select
Next

    Changer autour de basculer sur un simple Booléen, et l'utilisation de la Chaîne.Méthode Equals, comme ceci:

    For Each vRow In vDTtemp.Rows
    'Read out the row value so we only need to access the datarow once
    rowValue = vRow("Item")
    'Which of these statements is true?
    Select Case True
        Case rowValue.Equals("Time")
            vRow("Result") = "000"
        Case rowValue.Equals("DateTime")
            vRow("Result") = "001"
        Case rowValue.Equals("String")
            vRow("Result") = "002"
        Case Else
            vRow("Result") = "N/A"
    End Select
Next

    J'ai eu des améliorations significatives en l'approchant de cette façon, dans un cas, la réduction de mon code de 1,3 secondes plus de 100 000 itération de la boucle à 0,5 secondes. Si c'est dans un très fréquemment appelé à temps critique la section de code, qui peut faire une grande différence.

    Comme l'a souligné dans les commentaires ci-dessous, cependant, elle effectue un "Ordinal" comparaison de chaînes de caractères, qui peut ne pas se traduire dans le comportement attendu si les paramètres régionaux non anglais sont utilisés (voir les commentaires pour des exemples).

    Adam.

    Adam, merci pour la réponse. Je vais effectuer quelques test avec cette méthode.
    Ceci est incompatible avec le code d'origine d'une manière dangereuse, celui que vous avez vraiment besoin de mettre en garde au sujet de votre réponse. L'accélération est facilement expliqué, Chaîne.Equals() utilise StringComparison.Ordinal. La méthode la plus rapide pour comparer des chaînes, mais avec assez gênant de la sémantique dans différentes langues. Un allemand de l'utilisateur ne sera pas à comprendre pourquoi les ss ne correspond pas à ß. Le turc I est infâme. Etcetera. La voie normale pour obtenir ce hors de une unhacky instruction Select case est Option Compare Binary.
    C'est vrai et un bon point. Il y a d'autres paramètres qui peuvent être transmis à la Chaîne.Méthode Equals, mais dans mes tests, ils ont causé la performance de revenir à la même chose que (ou pire que) l'original de l'instruction Select case. Dans mon cas particulier, ce n'est pas l'intérêt que j'ai un contrôle complet sur les valeurs, mais n'importe qui à l'aide d'autres paramètres régionaux aurez certainement besoin d'être conscient de cela.
    Passant: Un très bon point que vous remarque! Je vais prendre en considération lors de la mettre en œuvre cette méthode. thnks!

    OriginalL'auteur Adam Dawes

  2. 5

    Il ne fait aucune différence, les deux styles de code générer exactement le même IL. Quelque chose que vous pouvez voir en exécutant la ildasm.exe outil sur votre assembly compilé.

    En général, le VB.NET compilateur ne faire un effort pour optimiser une instruction Select. Qui va travailler quand il utilise un simple type de valeur que le sélecteur et le Cas trivial consolidés. Le code généré va utiliser un dédié instruction IL, Opcodes.Commutateur. Qui sera compilé en code machine qui utilise une table de recherche. Très rapide.

    Cela, cependant, ne fonctionne pas lorsque vous utilisez une expression de chaîne que le sélecteur. Faire une table de recherche pour que l'on nécessiterait l'équivalent d'un dictionnaire des délégués. C'est trop d'impact, le compilateur ne peut pas faire n'importe quoi mais convertir chaque cas énoncé à l'équivalent d'une instruction if. Cependant, vous pouvez optimiser vous-même facilement par la création de ce Dictionnaire dans votre code, facile à faire depuis le dictionnaire de la clé et la valeur sont de simples chaînes de caractères. Vous n'avez pas assez de cas et les cordes sont trop courtes pour faire de ce payer majorly, mais il vaut la peine d'essayer. Il est très compact votre code.

    Je n'ai pas beaucoup d'expérience à l'aide de Dictionnaires, mais la peine de chercher plus d'informations à ce sujet. Merci!

    OriginalL'auteur Hans Passant

  3. 4

    Ok... c'était il y a longtemps pour ce post, mais maintenant, j'étais à la recherche de la même question et je peux ajouter de nouveaux optimisation pour cela. Pour l'instant j'ai choisi d'utiliser la sélection de cas, pour être plus lisible. En revanche, le rendement diminue beaucoup quand un "Dim" est à l'intérieur de la boucle suivante.

         For Each vRow In vDTtemp.Rows
------->  Dim rowItem = vRow("Item")
        If rowItem = "Time" Then
            vRow("Result") = "000"
        ElseIf rowItem = "DateTime" Then
            vRow("Result") = "001"
        ElseIf rowItem = "String" Then
            vRow("Result") = "002"
        Else
            vRow("Result") = "N/A"
        End If
    Next

    C'est beaucoup plus rapide lorsque dim est oitside même si vous souhaitez utiliser le si-alors la structure:

    ------->     Dim rowItem as string
             For Each vRow In vDTtemp.Rows
------->            rowitem= vRow("Item")
                If rowItem = "Time" Then
                    vRow("Result") = "000"
                ElseIf rowItem = "DateTime" Then
                    vRow("Result") = "001"
                ElseIf rowItem = "String" Then
                    vRow("Result") = "002"
                Else
                    vRow("Result") = "N/A"
                End If
            Next

    J'espère que ce sera utile pour quelqu'un de plus 😉

    OriginalL'auteur Ivan Font

  4. 2

    Si vous avez vraiment trouver ce qui est le goulot d'étranglement de performances, vous pouvez essayer de modifier le Si..Alors clause comme suit pour accéder au indexeur une fois:

    For Each vRow In vDTtemp.Rows
    Dim rowItem = vRow("Item")
    If rowItem = "Time" Then
        vRow("Result") = "000"
    ElseIf rowItem = "DateTime" Then
        vRow("Result") = "001"
    ElseIf rowItem = "String" Then
        vRow("Result") = "002"
    Else
        vRow("Result") = "N/A"
    End If
Next

    Cela étant dit, je suppose que chacun est un cas d'optimisation. Le compilateur doit à la meilleure chose ici. Si vous cochez la IL de une longue Sélectionnez Cas, vous pouvez trouver qu'il utilise une chaîne de Si..alors clauses de sous les couvertures avec "goto" pour échapper au reste de clauses. Votre meilleure option ici est d'obtenir le plus de code faciles à gérer que les avantages de performances vous pouvez gagner sera compensé par le minimum de coup de pouce que vous pouvez voir entre si..alors et sélectionnez cas.

    Merci par la pointe! Cela va m'aider à améliorer un peu plus le cycle.

    OriginalL'auteur Jim Wooley