¿Cuál es la diferencia entre And y AndAlso en VB.NET?

En VB.NET, ¿cuál es la diferencia entre Andy AndAlso? ¿Cuál debería usar?

El Andoperador evalúa ambos lados, donde AndAlsoevalúa el lado derecho si y solo si el lado izquierdo es verdadero.

Un ejemplo:

If mystring IsNot Nothing And mystring.Contains("Foo") Then
  ' bla bla
End If

Lo anterior arroja una excepción si mystring = Nothing

If mystring IsNot Nothing AndAlso mystring.Contains("Foo") Then
  ' bla bla
End If

Este no arroja una excepción.

Entonces, si vienes del mundo de C #, debes usarlo AndAlsocomo lo harías &&.

Más información aquí: http://www.panopticoncentral.net/2003/08/18/the-ballad-of-andalso-and-orelse/

El Andoperador verificará todas las condiciones en la declaración antes de continuar, mientras que el operador Andalso se detendrá si sabe que la condición es falsa. Por ejemplo:

if x = 5 And y = 7

Comprueba si x es igual a 5, y si y es igual a 7, luego continúa si ambas son verdaderas.

if x = 5 AndAlso y = 7

Comprueba si x es igual a 5. Si no lo es, no comprueba si y es 7, porque sabe que la condición ya es falsa. (Esto se llama cortocircuito).

En general, las personas usan el método de cortocircuito si hay una razón para no verificar explícitamente la segunda parte si la primera parte no es verdadera, como si arrojaría una excepción si se verifica. Por ejemplo:

If Not Object Is Nothing AndAlso Object.Load()

Si eso se usara en Andlugar de AndAlso, aún lo intentaría Object.Load()incluso si fuera así nothing, lo que arrojaría una excepción.

Curiosamente ninguna de las respuestas mencionó que Andy Oren VB.NET son los operadores de bits, mientras que OrElsey AndAlsoson estrictamente operadores booleanos.

Dim a = 3 OR 5 ' Will set a to the value 7, 011 or 101 = 111
Dim a = 3 And 5 ' Will set a to the value 1, 011 and 101 = 001
Dim b = 3 OrElse 5 ' Will set b to the value true and not evaluate the 5
Dim b = 3 AndAlso 5 ' Will set b to the value true after evaluating the 5
Dim c = 0 AndAlso 5 ' Will set c to the value false and not evaluate the 5

Nota : se considera un número entero distinto de cero true; Dim e = not 0establecerá epara -1demostrar Nottambién es un operador de bits.

||y &&(las versiones de C # de OrElsey AndAlso) devuelven la última expresión evaluada que sería 3y 5respectivamente. Esto le permite usar el idioma v || 5en C # para dar 5como valor de la expresión cuando vis nullo ( 0y un número entero) y el valor de lo vcontrario. La diferencia en la semántica puede pillar a un programador de C # incursionando en VB.NET desprevenido ya que este "idioma de valor predeterminado" no funciona en VB.NET.

Entonces, para responder la pregunta : Use Ory Andpara operaciones de bit (entero o booleano). Use OrElsey AndAlsopara "cortocircuitar" una operación para ahorrar tiempo, o pruebe la validez de una evaluación antes de evaluarla. If valid(evaluation) andalso evaluation thenoif not (unsafe(evaluation) orelse (not evaluation)) then

Bonificación: ¿Cuál es el valor de lo siguiente?

Dim e = Not 0 And 3

If Bool1 And Bool2 Then

Evalúa tanto Bool1 como Bool2

If Bool1 AndAlso Bool2 Then

Evalúa Bool2 si y solo si Bool1 es verdadero.

Solo para todas aquellas personas que dicen que los efectos secundarios son malos: un lugar donde tener dos efectos secundarios en una condición es bueno sería leer dos objetos de archivo en conjunto.

While File1.Seek_Next_Row() And File2.Seek_Next_Row()
    Str1 = File1.GetRow()
    Str2 = File2.GetRow()
End While

El uso de Andasegura que se consume una fila cada vez que se verifica la condición. Mientras que AndAlsopodría leer la última línea de File1y dejar File2sin una línea consumida.

Por supuesto, el código anterior no funcionaría, pero uso efectos secundarios como este todo el tiempo y no lo consideraría un código " malo " o " malo ", ya que algunos te harían creer. Es fácil de leer y eficiente.

Una manera simple de pensarlo es usar un inglés incluso más claro

If Bool1 And Bool2 Then
If [both are true] Then


If Bool1 AndAlso Bool2 Then
If [first is true then evaluate the second] Then

AndAlso es muy parecido a And, excepto que funciona como && en C #, C ++, etc.

La diferencia es que si la primera cláusula (la anterior a AndAlso) es verdadera, la segunda cláusula nunca se evalúa: la expresión lógica compuesta es "cortocircuito".

Esto a veces es muy útil, por ejemplo, en una expresión como:

If Not IsNull(myObj) AndAlso myObj.SomeProperty = 3 Then
   ...
End If

Usar el antiguo Y en la expresión anterior arrojaría una NullReferenceException si myObj fuera nulo.

Consulte también la pregunta sobre desbordamiento de pila: ¿Debería usar siempre los operadores AndAlso y OrElse? .

Además: un comentario para aquellos que mencionaron usar Andsi el lado derecho de la expresión tiene un efecto secundario que necesita:

Si el lado derecho tiene un efecto secundario que necesita, simplemente muévalo hacia el lado izquierdo en lugar de usar "Y". Realmente solo necesita "Y" si ambos lados tienen efectos secundarios. Y si tiene tantos efectos secundarios, probablemente esté haciendo algo mal. En general, realmente debería preferir AndAlso.

Además de las respuestas anteriores, AndAlso también proporciona un proceso de acondicionamiento conocido como cortocircuito. Muchos lenguajes de programación tienen esta funcionalidad incorporada como lo hace vb.net, y pueden proporcionar aumentos sustanciales de rendimiento en declaraciones de larga duración al eliminar evaluaciones que no son necesarias.

Otra condición similar es la condición OrElse que solo verificaría la condición correcta si la condición izquierda es falsa, eliminando así las verificaciones de condición innecesarias después de encontrar una condición verdadera.

Le aconsejaría que utilice siempre procesos de cortocircuito y estructurar sus declaraciones condicionales de manera que esto pueda beneficiarse al máximo. Por ejemplo, pruebe primero sus condiciones más eficientes y rápidas para que solo ejecute sus condiciones largas cuando sea absolutamente necesario y cortocircuite las otras veces.

Para la mayoría de nosotros, OrElse y AndAlso harán el truco, salvo algunas excepciones confusas (menos del 1% en las que tendremos que usar Or y And).

Trate de no dejarse llevar por personas que muestran sus lógicas booleanas y hacen que parezca una ciencia espacial.

Es bastante simple y directo, y ocasionalmente su sistema puede no funcionar como se esperaba porque, en primer lugar, no le gusta su lógica. Y, sin embargo, su cerebro sigue diciéndole que su lógica está 100% probada y comprobada y que debería funcionar. En ese mismo momento, deja de confiar en tu cerebro y pídele que piense de nuevo o (no OrElse o tal vez OrElse) te obligas a buscar otro trabajo que no requiera mucha lógica.

Para entender con palabras no bacalaos:

Caso de uso:
con “Y” el compilador verificará todas las condiciones, por lo que si está verificando que un objeto podría ser “Nada” y luego está verificando una de sus propiedades, tendrá un error de tiempo de ejecución.
Pero con AndAlso con el primer "falso" en las condiciones, verificará el siguiente para que no tenga un error.