Existe um equivalente VB.NET para o ??
operador de C # ?
Existe um equivalente VB.NET para o ??
operador de C # ?
Respostas:
Use o If()
operador com dois argumentos ( documentação da Microsoft ):
' Variable first is a nullable type.
Dim first? As Integer = 3
Dim second As Integer = 6
' Variable first <> Nothing, so its value, 3, is returned.
Console.WriteLine(If(first, second))
second = Nothing
' Variable first <> Nothing, so the value of first is returned again.
Console.WriteLine(If(first, second))
first = Nothing second = 6
' Variable first = Nothing, so 6 is returned.
Console.WriteLine(If(first, second))
If()
declaração em VB é o mesmo que o if...?...:
em C #, não o ??
operador
??
(ver outra resposta a esta pergunta: stackoverflow.com/a/20686360/1474939 )
If
com três parâmetros . Isso não é semelhante ao ??
operador do C # . Melhor resposta é If, do Code Maverick, com dois argumentos . (Nick teve uma resposta semelhante, anos antes, mas não inclui a explicação da MSDN.)
O IF()
operador deve fazer o truque para você:
value = If(nullable, defaultValueIfNull)
A resposta aceita não tem nenhuma explicação e é apenas um link.
Portanto, pensei em deixar uma resposta que explique como o If
operador trabalha, retirado do MSDN:
Utiliza a avaliação de curto-circuito para retornar condicionalmente um dos dois valores. O operador If pode ser chamado com três argumentos ou com dois argumentos.
If( [argument1,] argument2, argument3 )
O primeiro argumento para If pode ser omitido. Isso permite que o operador seja chamado usando apenas dois argumentos. A lista a seguir se aplica somente quando o operador If é chamado com dois argumentos.
Term Definition
---- ----------
argument2 Required. Object. Must be a reference or nullable type.
Evaluated and returned when it evaluates to anything
other than Nothing.
argument3 Required. Object.
Evaluated and returned if argument2 evaluates to Nothing.
Quando o argumento booleano é omitido, o primeiro argumento deve ser um tipo de referência ou anulável. Se o primeiro argumento for avaliado como Nothing , o valor do segundo argumento será retornado. Em todos os outros casos, o valor do primeiro argumento é retornado. O exemplo a seguir ilustra como essa avaliação funciona.
' Variable first is a nullable type.
Dim first? As Integer = 3
Dim second As Integer = 6
' Variable first <> Nothing, so its value, 3, is returned.
Console.WriteLine(If(first, second))
second = Nothing
' Variable first <> Nothing, so the value of first is returned again.
Console.WriteLine(If(first, second))
first = Nothing
second = 6
' Variable first = Nothing, so 6 is returned.
Console.WriteLine(If(first, second))
Um exemplo de como lidar com mais de dois valores ( if
s aninhados ):
Dim first? As Integer = Nothing
Dim second? As Integer = Nothing
Dim third? As Integer = 6
' The LAST parameter doesn't have to be nullable.
'Alternative: Dim third As Integer = 6
' Writes "6", because the first two values are "Nothing".
Console.WriteLine(If(first, If(second, third)))
Você pode usar um método de extensão. Este funciona como SQL COALESCE
e provavelmente é um exagero para o que você está tentando testar, mas funciona.
''' <summary>
''' Returns the first non-null T based on a collection of the root object and the args.
''' </summary>
''' <param name="obj"></param>
''' <param name="args"></param>
''' <returns></returns>
''' <remarks>Usage
''' Dim val as String = "MyVal"
''' Dim result as String = val.Coalesce(String.Empty)
''' *** returns "MyVal"
'''
''' val = Nothing
''' result = val.Coalesce(String.Empty, "MyVal", "YourVal")
''' *** returns String.Empty
'''
''' </remarks>
<System.Runtime.CompilerServices.Extension()> _
Public Function Coalesce(Of T)(ByVal obj As T, ByVal ParamArray args() As T) As T
If obj IsNot Nothing Then
Return obj
End If
Dim arg As T
For Each arg In args
If arg IsNot Nothing Then
Return arg
End If
Next
Return Nothing
End Function
O interno If(nullable, secondChoice)
pode lidar apenas com duas opções anuláveis. Aqui, você pode Coalesce
quantos parâmetros desejar. O primeiro não nulo será retornado e o restante dos parâmetros não serão avaliados depois disso (curto-circuito, como AndAlso
/ &&
e OrElse
/ ||
)
Return args.FirstOrDefault(Function(arg) arg IsNot Nothing)
:-)
A única limitação significativa da maioria dessas soluções é que elas não causam um curto-circuito. Portanto, eles não são realmente equivalentes a ??
.
O If
operador interno não avaliará os parâmetros subsequentes, a menos que o parâmetro anterior seja avaliado em nada.
As seguintes declarações são equivalentes:
C #
var value = expression1 ?? expression2 ?? expression3 ?? expression4;
VB
dim value = if(expression1,if(expression2,if(expression3,expression4)))
Isso funcionará em todos os casos em que ??
funciona. Qualquer uma das outras soluções teria que ser usada com extrema cautela, pois elas poderiam facilmente introduzir bugs em tempo de execução.
Consulte a documentação da Microsoft sobre o If Operator (Visual Basic) aqui: https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/operators/if-operator
If( [argument1,] argument2, argument3 )
Aqui estão alguns exemplos (VB.Net)
' This statement prints TruePart, because the first argument is true.
Console.WriteLine(If(True, "TruePart", "FalsePart"))
' This statement prints FalsePart, because the first argument is false.
Console.WriteLine(If(False, "TruePart", "FalsePart"))
Dim number = 3
' With number set to 3, this statement prints Positive.
Console.WriteLine(If(number >= 0, "Positive", "Negative"))
number = -1
' With number set to -1, this statement prints Negative.
Console.WriteLine(If(number >= 0, "Positive", "Negative"))