Est-il préférable d'utiliser [Type].Parse ou C[Type] ?

Question

Si j'essaie de mettre une chaîne de caractères dans une variable booléenne, comme ceci :

    Dim testValue As String = "True"
    Dim bool1 As Boolean = testValue

Avec Option Strict On J'obtiens une erreur et la solution suggérée est de changer la deuxième ligne en :

    Dim bool1 As Boolean = CBool(testValue)

C'est bien, mais quels sont les avantages et les inconvénients de cette solution ?

    Dim bool1 As Boolean = Boolean.Parse(testValue)

CBool Cela ressemble beaucoup à du VB6 pour moi, mais lequel devrions-nous utiliser et pourquoi ?

Answer 1

Si vous savez que c'est une chaîne dans les deux cas, le processus devrait être équivalent. Puisque Cbool appellera éventuellement une fonction pour le convertir. (Tant que votre valeur est "True" ou "False").

Il y a une différence si vous utilisez quelque chose comme cbool(valeur) et que la valeur est un booléen.

de MSDN :

Notez que l'opération d'analyse syntaxique réussit o est "True" (la valeur du champ TrueString) ou "False" (la valeur du champ FalseString). le champ FalseString) dans une comparaison insensible à la casse.

En MSDN en ce qui concerne Cbool (et d'autres méthodes de ce type) :

Ces fonctions sont compilées en ligne, ce qui signifie que la commande c partie du code qui évalue l'expression. Parfois, il n'y a pas appel à une procédure pour effectuer la conversion, ce qui améliore les performances. Chaque fonction convertit une expression en un type de données spécifique. de données spécifique

Ainsi, si vous utilisez cbool(valeur), si votre valeur est un booléen, il l'utilise simplement, sans conversion. Cela le rend potentiellement plus efficace.

Vous pouvez également consulter cette page : Integer.Parse vs. CInt

Answer 2

Je pense que la grande différence est que Boolean.Parse est très strict sur ce qu'il accepte (vrai/faux) alors que CBool est plus indulgent (0/1, vrai/faux, je pense que oui/non bien que je doive retester cela).

Si vous envisagez de porter le code en C# ou si vous savez que vous n'aurez jamais que des valeurs vrai/faux, alors Parse est la solution. Sinon, j'utiliserais CBool pour sa flexibilité supplémentaire.

Answer 3

CBool(value) est un opérateur de cast, avec cette méthode, value est supposé être un Bool, mais VB fait quelques conversions pour vous.

Avec Bool.Parse(value), la valeur est censée être une chaîne de caractères, et elle sera analysée pour obtenir une valeur booléenne.

Vous pouvez également utiliser Convert.ToBoolean(value), qui utilise les méthodes de conversion de .net pour effectuer une conversion d'un type à un autre.

Dans votre code, il est incorrect de transformer une chaîne vide en une valeur fausse. C'est possible, mais source d'erreurs.

En utilisant Strict en VB.Net, vous êtes obligé d'utiliser le bon type.

Donc, tu ne peux pas faire ça :

Dim v1 as String = "1"
Dim v2 as Integer = 1

Dim r = v1 + v2

r pourrait être 2 ou "11", et ce type d'erreur est très courant.

Answer 4

Cela semble montrer que dans le cas d'une chaîne de caractères vers un booléen, Boolean.Parse est beaucoup plus rapide.

    Dim t As String = "True"
    Dim f As String = "False"
    Const tries As Integer = 1000000
    Dim t_or_f As Boolean = True
    Dim stpw As New Stopwatch

    stpw.Restart()
    For x As Integer = 1 To tries
        t_or_f = CBool(f)
    Next
    stpw.Stop()
    Debug.WriteLine(stpw.Elapsed)

    stpw.Restart()
    For x As Integer = 1 To tries
        t_or_f = Boolean.Parse(f)
    Next
    stpw.Stop()
    Debug.WriteLine(stpw.Elapsed)

Lorsque je vois ce genre de questions, je ne peux m'empêcher de me demander pourquoi / comment un programmeur se retrouve dans la situation de convertir certaines données en un booléen direct. Le mieux que je puisse faire pour accepter cela est que la valeur numérique de 1 = Vrai et 0 = Faux, mais même dans ce cas, vous êtes confronté au fait que .Net interprète les booléens différemment.

    Dim t_or_f As Boolean = CBool(1)
    Debug.WriteLine(t_or_f.ToString & " " & CLng(t_or_f))
    t_or_f = CBool(0)
    Debug.WriteLine(t_or_f.ToString & " " & CLng(t_or_f))

sortie de débogage

True -1
False 0