Filleral Mahecha
Para comentar también rápido funciona el comando: ctrl + k + c
Yangetze González
Company_adminMi favorito siempre. Y ctrl+k+u para descomentar :D
Agustin Del Giudice
Aporto con el de "uncomment" ctrl + k + u
Los operadores lógicos en C# te permiten comparar expresiones booleanas para construir reglas de decisión en tu código, desde validar contraseñas hasta diseñar flujos de seguridad con autenticación múltiple. Si programas en .NET 6 y quieres entender cómo combinar condiciones, aquí encontrarás cómo funcionan AND, OR, NOT y XOR con ejemplos prácticos.
¿Qué son los operadores lógicos en C#?
Son símbolos que comparan valores booleanos (true o false) y devuelven otro booleano. A diferencia de los operadores aritméticos, no suman ni restan: evalúan condiciones. En C# los más usados son cuatro y cada uno responde a una pregunta distinta sobre tus variables [01:05].
¿Para qué sirven los operadores lógicos? Sirven para combinar condiciones y decidir si un bloque de código se ejecuta. Por ejemplo, validar que una usuaria ingrese contraseña y huella digital antes de acceder a su cuenta.
Antes de comparar, necesitas declarar tus variables booleanas. Puedes hacerlo de forma explícita con bool valor1 = true; o de forma implícita agrupándolas entre paréntesis con var, siempre que sean del mismo tipo. C# detecta automáticamente que trabajas con booleanos por los valores que asignas [09:30].
¿Cómo funcionan AND y OR en C#?
El operador AND se escribe con && y exige que todas las condiciones sean verdaderas para devolver true. Si alguna falla, el resultado es false [02:45].
Piensa en una app bancaria de máxima seguridad: para entrar necesitas contraseña, código 2FA y huella digital. Si una sola falla, el acceso se niega. Eso es AND en acción [04:10].
El operador OR se escribe con || (las dos barras verticales en la esquina superior izquierda del teclado) y devuelve true si al menos una condición se cumple [05:20].
csharp bool valor1 = true; bool valor2 = false; bool valor3 = false;
bool resultadoAnd = valor1 && valor2 && valor3; // false bool resultadoOr = valor1 || valor2 || valor3; // true
En la analogía de seguridad, OR equivale a permitir acceso con contraseña o con 2FA o con huella: cualquiera abre la puerta.
¿Puedo combinar AND y OR en una misma expresión?
Sí, y aquí entra la precedencia de operaciones. Usa paréntesis para indicar qué se evalúa primero, igual que en álgebra [07:15].
csharp bool combinado = (valor1 && valor2) || valor3;
Esto se lee así: si valor1 y valor2 son ambos verdaderos, o si valor3 es verdadero por sí solo, el resultado es true. Es como decir: "entra con contraseña más 2FA, o directamente con huella digital".
¿Para qué sirven NOT y XOR?
El operador NOT se escribe con ! y simplemente invierte el valor. Si una variable es true, !variable la convierte en false, y viceversa [10:45].
csharp bool valor1 = true; bool resultNot = !valor1; // false
Es útil cuando quieres verificar que algo no se cumple, como "si el usuario no está autenticado, redirigir al login".
¿Qué hace el operador XOR en C#? Compara dos valores y devuelve
truesolo si son diferentes. Si ambos son iguales (los dostrueo los dosfalse), devuelvefalse. Se escribe con el símbolo^.
Mientras AND pregunta "¿son ambos verdaderos?", XOR pregunta "¿son distintos entre sí?" [12:00].
csharp bool resultXor = valor1 ^ valor2;
¿Por qué XOR con tres variables da resultados inesperados?
Cuando encadenas valor1 ^ valor2 ^ valor3, C# evalúa de izquierda a derecha. Primero compara valor1 ^ valor2 y obtiene un booleano intermedio; luego compara ese resultado con valor3 [13:20].
Por eso, si valor1 y valor2 son ambos true, el primer XOR da false, y al compararlo con valor3 = false, el resultado final es false. No son diferentes entre sí en la segunda comparación. Usar paréntesis te ayuda a visualizar el orden:
csharp bool resultXor = (valor1 ^ valor2) ^ valor3;
¿Cómo aplicar operadores lógicos en proyectos reales?
La analogía de la caja fuerte funciona perfecto: imagina cuántas llaves necesita girar tu usuario y en qué combinaciones. Esa lógica se traduce directamente a &&, ||, ! y ^.
Para declarar varias booleanas en una sola línea, recuerda la sintaxis con paréntesis y var:
csharp var (valor1, valor2, valor3) = (true, false, true);
C# infiere el tipo automáticamente porque los valores asignados son booleanos. Te ahorra repetir bool tres veces y deja el código más limpio.
Si algo no quedó claro, déjalo en los comentarios y entre la comunidad lo resolvemos.
Filleral Mahecha
Para comentar también rápido funciona el comando: ctrl + k + c
Yangetze González
Company_adminMi favorito siempre. Y ctrl+k+u para descomentar :D
Agustin Del Giudice
Aporto con el de "uncomment" ctrl + k + u
Silas Duarte
Si se les complica entender los operadores AND y OR, piensen en está analogía jaja 😜
Cada valor es un vasito de agua🥛, los cuales pueden contener agua sucia (false) o agua purificada (true).
AND los obliga a probar todos los vasos de agua, mientras que con OR pueden beber solo el que esté limpio.
El resultado de cualquier sentencia con AND y OR, será TRUE si se pueden librar de beber agua sucia o FALSE si se van con diarrea... 😜
Siganme para más lecciones de lógica.
Jaime Alberto Mariño Beaz
Perfecto!!
MARCO ANTONIO REYES GONZALEZ
Excelente ejemplo :)
Operadores Logicos
Los operadores lógicos en C# son utilizados para comparar y combinar valores booleanos. Los operadores lógicos disponibles en C# incluyen:
&& (and): Devuelve verdadero si ambos operandos son verdaderos.|| (or): Devuelve verdadero si al menos uno de los operandos es verdadero.! (not): Invierte el valor booleano del operando.^ (xor): Devuelve verdadero si sólo uno de los operandos es verdadero.Ejemplo:
bool a = true; bool b = false; bool c = (a && b); // c es false bool d = (a || b); // d es true bool e = !b; // e es true bool f = (a ^ b); // f es true
Hernán Alexis Moreno Castro
Juan Manuel Rubio Gallego
Gracias, tenia dudas y con tu explicacion se me aclaro un poco todo. Muy bien!
Hans Joel
Muchas gracias por el aporte. Eres un genio!!
German Cavani
Si no sabes como poner el XOR o "^" en tu teclado, prueba con alt + 94.
Jhoan Sebastián Lopera Gallego
Graciass
ROSSANA IVON CALDERA SERRANO
|| = (Alt+124)2
Miguel Angel Reyes Moreno
Una imagen dice más que mil palabras
Esteban Cerda Román
Esto me acordó las clases de intro a electrónica.
Eduardo Cruz
Si manejas bien las tablas de verdad, Xor es como la bicondicional pero con negación.
Ejemplo:
La bicondicional dice: Es verdadero si ambos tienen el mismo valor (VV-FF).
P q P(Bicondicional)q
V V V
V F F
F V F
F F V
Xor dice: Es Verdadero si ambos tienen diferente valor (VF-FV). Por lo tanto si ambos tienen el mismo valor es Falso. Supongamos: 0=Falso, 1= Verdadero
A B (Salida A B)
0 0 0
0 1 1
1 0 1
1 1 0
Recomendación: Estudia las tablas de verdad.
Espero haberte ayudado.
Raúl Adolfo Sánchez Rodríguez
⭐Operador Lógico AND - &&
⭐Operador Lógico OR -||
⭐Operador Exclusive OR - ^
⭐Operador Negación - !
Yangetze González
Company_adminEsa forma de declarar las variable (min 11 en adelane) se llama Deconstruct
var (valor1, valor2, valor3) = (true, true, false)
Tengo poco tiempo estudiándolo, pero es una forma abstracta de declarar pero a la vez fácil para asignar resultados, al menos así lo veo.
Jhoan Sebastián Lopera Gallego
¡Gracias por el aporte!
Juan Roberto Adolfo Esquivel Segovia
espero que les sirva mis apuntes
/* Operadores logicos y cuales son cada uno en c# * operador && este es un and lo que funciona como necesita dos ciertos para ser cierto * OPERADOR || OR este operador tiene la funcion de pasar un cierto y un falso como un cierto y si ambos son ciertos pasa como cierto * Operador ! NOT tiene la capacidad de pasar todo al contrario de lo que es * ^ OPERADOR XOR */ /* bool valor1 = true; bool valor2 = true; aqui lo que hicimos es declarar las variables de forma clasica bool valor3 = false; */ var (valor1, valor2, valor3) = (true, true, false);//aqui dejamos que visual studio declare solo las variables Console.WriteLine(" los valors de son " + valor1 + " " + valor2 + " " + valor3); bool resultAND = valor1 && valor2 && valor3; Console.WriteLine("el resultado de AND es : "+resultAND); bool resultOR = valor1 || valor2 || valor3; Console.WriteLine("el resultado de OR es : "+resultOR); bool resultAndOr = (valor1 && valor2) || valor3; Console.WriteLine("el resultado de AND Y OR es : "+resultAndOr); bool resultNOT = !valor1; // usamos el operador not y vemos como cambia el true al false Console.WriteLine("el resultado de NOT es : "+resultNOT); bool resultXOR = valor1 ^ valor2; Console.WriteLine("el resultado de XOR es : "+resultXOR); // este funciona como un or pero negativo no hay pierde creo...
William Chapuez
hay operadores no para realizar operaciones, si no para comparar expresiones & AND: Determina su veracidad cuando todos sus enunciados son verdaderos, de lo contario todos son falsos
|| u OR: Solamente es falso, cuando todos los datos son falsos
! Negar el valor lógico
^ o xor: determinar la diferencia de valores*/
Carlos andres Orduz
no dices el paso en donde cambias result por resultAnd, ¿ por que lo cambias?
Juan José Valencia Villa
Tu a las variables le puedes poner el nombre que tu quieras, no hay explicaciones porque se pueda cambiar en realidad
Pablo Matias Fernandez Maza
El cambia el nombre de dicha variable por dos motivos esenciales:
German Pinilla
++OPERADORES ARITMETICOS++
Operador Logical operator Example ! NOT !false && AND x && y || OR x || y
Jhoan Sebastián Lopera Gallego
Nice one
Carlos Enrique Membreño Barrientos
Carlos Enrique Membreño Barrientos
Para que entendamos el or (||)
// Podemos usar el or (||) cuando los eventos no son mutuamente excluyentes bool tieneHambre = true; // tiene hambre, necesita comida bool tieneSed = false; // no tiene sed // si ambos fueran falso, retornaria falso, ya que la persona no necesita nada // Una persona puede tener hambre Y sed al mismo tiempo, no se excluyen. // Queremos saber si necesita algo (comida o agua o ambas) bool necesitaAlgo = tieneHambre || tieneSed; //Aqui se determina si ocupa algo, no el que Console.WriteLine(necesitaAlgo); // true
Carlos Enrique Membreño Barrientos
Para que entendamos el XOR (^)
/* statement4 = hace calor * statemet5 = hace frio */ bool statement4 = true; //Hace Calor bool statement5 = false; //Hace Frio // Estamos de acuerdo que estos son eventos mutuamente excluyentes es decir // que si hace calor no puede hacer frio y viceversa // por lo tanto usamos XOR ^ // en este caso retornará true, ya que hace calor y no hace frio // sin embargo si ambos statements estuviera true nos daria como resultado false (ya que eso es imposible, que haya calor y frio al mismo tiempo) bool result2 = statement4 ^ statement5; Console.WriteLine(result2); // Aqui se imprime el resultado
Carlos Enrique Membreño Barrientos
Para que entendamos el AND (&&) con un tema que todos en LATAM estamos familiarizados
/* statement1 = esta lloviendo * statemet2 = hace frio * statemnet3 = es buena idea tomar cafe porque esta lloeviendo y hace frio */ bool statement1 = true; //Aqui se indica que SI esta lloviendo bool statement2 = true; //Aqui se indica que SI esta haciendo frio bool statement3 = true; //Aqui se indica que es una buena idea tomar cafe bool result = statement1 && statement2 && statement3; ; //Aqui se evalua, si todas son verdadero, //esto nos confirma que es buena idea tomar cafe //porque si esta lloviendo y si esta haciendo frio Console.WriteLine(result); // Aqui se imprime el resultado
Sergio Daniel Flamenco
Apuntes de los operadores lógicos AND, OR, NOT y XOR
/*
&&
||
!
^
*/
var (valor1, valor2, valor3) = (true, true, false);
bool resultAnd = valor1 && valor2 && valor3;
Console.WriteLine(resultAnd);
bool resultOr = valor1 || valor2 || valor3;
Console.WriteLine(resultOr);
bool resultAndOr = (valor1 && valor2) || valor3;
Console.WriteLine(resultAndOr);
bool resultNot = !valor1;
Console.WriteLine(resultNot);
bool resultXor = (valor1 ^ valor2)^ valor3;
Console.WriteLine(resultXor);
En** OR || **cualquier valor que sea verdadero , dará como resultado VERDADERO.
**Ejemplo: ** Verdadero OR Verdadero = Verdadero Verdadero OR Falso = Verdadero Falso OR Verdadero = Verdadero Falso OR Falso = Falso
En AND && si existe un valor que sea diferente al resto será, FALSO
Ejemplo: Verdadero AND Verdadero = Verdadero Verdadero AND Falso = Falso Falso AND Verdadero = Falso Falso AND Falso = Verdadero
En NOT ! es una negación al resultado existente.
Ejemplo: Si valor1 es Verdadero !Valor1 será Falso
En Xor compara valores e indica si son diferentes(Verdadero) o iguales(Falso)
Ejemplo: Verdadero ^ Verdadero = Falso Falso ^ Verdadero = Verdadero
var (valor1, valor2, valor3) = (true, true, false); bool resultAnd = valor1 && valor2 && valor3; Console.WriteLine("resultAnd " + resultAnd); bool resultOr = valor1 || valor2 || valor3; Console.WriteLine("resultOr " + resultOr); bool resultAndOr = (valor1 && valor2) || valor3; Console.WriteLine("resultAndOr " + resultAndOr); bool resultNot = !valor1; Console.WriteLine("resultNot " + resultNot); bool resultXor = (valor1 ^ valor2) ^ valor3; Console.WriteLine("resultXor " + resultXor);
Resumen Niños
================================================ OPERADORES LÓGICOS EN C# - CUÁNDO USARLOS ================================================ AND (&&) -------- Úsalo cuando TODAS las condiciones deben ser true. Ambas condiciones pueden ocurrir al mismo tiempo. Ejemplo: Para acceder necesitas usuario Y contraseña correctos. bool tieneUsuario = true; bool tieneContrasena = true; bool puedeAcceder = tieneUsuario && tieneContrasena; // true Regla: Si UNA es false, el resultado es false. OR (||) ------- Úsalo cuando AL MENOS UNA condición debe ser true. Ambas condiciones pueden ocurrir al mismo tiempo y eso es VÁLIDO. Ejemplo: Puedes pagar con efectivo O con tarjeta (o ambas). bool tieneEfectivo = false; bool tieneTarjeta = true; bool puedePoagar = tieneEfectivo || tieneTarjeta; // true Regla: Si AL MENOS UNA es true, el resultado es true. XOR (^) ------- Úsalo cuando EXACTAMENTE UNA condición debe ser true. Ambas condiciones NO pueden ocurrir al mismo tiempo (mutuamente excluyentes). Ejemplo: Un foco solo puede estar encendido O apagado, no ambos. bool estaEncendido = true; bool estaApagado = false; bool estadoValido = estaEncendido ^ estaApagado; // true Regla: Si AMBAS son true o AMBAS son false, el resultado es false. ================================================ TABLA RESUMEN ================================================ A B AND(&&) OR(||) XOR(^) ----- ----- ------- ------ ------ true true true true false true false false true true false true false true true false false false false false ================================================ PREGUNTA CLAVE PARA DECIDIR ================================================ ¿Ambas condiciones deben ser true? → AND (&&) ¿Pueden ser true al mismo tiempo? → OR (||) ¿Solo una puede ser true a la vez? → XOR (^) ================================================