if y else

bool ready = true; guarda la palabra true. Luego if (ready) mira esa palabra y ejecuta solo un grupo de líneas. Cuando ready es true, Console.WriteLine("pass") escribe pass. Cuando ready es false, corre el grupo else y escribe wait. La pantalla es una línea. Mantén el nombre de la clase pública Pine.

Un bool decide qué bloque corre

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra bool both si esa línea sigue ahí, incluyendo true && true, true || false, !true y toda marca de combinación entre dos palabras true o false. Borra bool match si sigue. Borra int total si sigue. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura, no tiene both, no tiene match y no escribe sola una palabra combinada. La pantalla solo la escribe una línea de escritura dentro de las llaves elegidas.

Dentro de Main, guarda un bool antes de elegir camino: bool ready = true;. bool es la palabra de tipo. ready es el nombre y empieza con r minúscula. No hay comillas alrededor de true. El punto y coma termina la línea de guardado. Esa línea no escribe la pantalla. Después viene la elección:
if (ready) {
Console.WriteLine("pass");
} else {
Console.WriteLine("wait");
}
La palabra if va en minúsculas: i, luego f. No es un nombre que inventes. Un espacio después de if está bien; if(ready) sin espacio también compila. Dentro de los paréntesis va el nombre ready — sin comillas, sin ==, sin &&. Cuando ready guarda true, C# entra en el primer par de llaves y ejecuta Console.WriteLine("pass");. Las comillas alrededor de pass marcan letras para la pantalla. Esas letras — p, a, s, s — son lo que debes ver, una línea. El bloque else se salta por completo en esta ejecución. Guarda el archivo.

El archivo que guardas

Mantén esta forma de enseñanza. Una palabra de tipo, bool. Un nombre, ready, guardado como true. Un if con paréntesis alrededor de ready. Una línea de escritura que escribe pass dentro de las primeras llaves. Un else con una línea de escritura que escribe wait. No hay línea both, no hay línea match y no se escribe la palabra suelta true fuera de las llaves.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca la ejecución. bool ready = true; guarda true. No escribe nada. if (ready) pregunta si esa palabra guardada es true. Lo es, así que corre Console.WriteLine("pass");. Las llaves de else se saltan. Una línea en pantalla: pass. Sin comillas en pantalla. Sin segunda línea. En el archivo que guardas no hay línea bool both.

Ejecútalo con dotnet run. El programa escribe pass. No espera a que escribas. La palabra guardada y la elección ya estaban en el archivo. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y deja bool ready = true; y el if / else de arriba. El programa termina después de la línea de escritura elegida. La pantalla muestra pass. Una línea. Si la pantalla muestra true, aún escribes el propio bool, o sigue en Main una combinación de la página lógica. Cámbialo por Console.WriteLine("pass") dentro de las llaves del if cuando ready es true. Si la pantalla muestra wait, ready es false; ese es el segundo archivo de esta página, no el que guardas. Si la pantalla muestra las letras if (ready), una línea de escritura tiene comillas alrededor de esos caracteres. No reinstales el .NET SDK por una línea mala en pantalla.

¿Por qué pass y no wait? Porque la prueba entre paréntesis era true. C# no escribe la palabra true en esta ejecución. Escribe la línea de escritura que corre dentro de las llaves elegidas. Piensa en tres trabajos: los paréntesis guardan la prueba, las llaves agrupan las líneas que van juntas, y solo Console.WriteLine escribe en la pantalla. Una pantalla que muestra pass no prueba sola el if. Busca if (ready) y las llaves en el archivo. No juzgues el archivo solo por la pantalla.

Cuando ready es false

Cambia solo el valor guardado: bool ready = false;. Deja la estructura if / else igual. Ahora la prueba falla, así que C# salta las primeras llaves y corre las llaves de else. La pantalla debe mostrar wait, una línea.

Este es el segundo archivo. No es el que guardas. Ejecuta dotnet run. La pantalla muestra wait. Una línea. No muestra pass. No muestra false como palabra de pantalla a menos que la escribas a propósito. Si la pantalla muestra pass, sigues en el archivo que guardas, donde ready es true. Después de ver wait, vuelve al archivo guardado: bool ready = true; y el mismo if / else que escribe pass en el camino true. Ambas versiones son C# válido. Enseñan la misma forma if / else con pruebas opuestas.

Lee otra vez la ejecución false en orden. ready guarda false. Se pregunta if (ready). La respuesta es false, así que se salta cada línea entre el primer { y su } que cierra — incluido Console.WriteLine("pass");. El control sigue en else. Corren las líneas entre las llaves de else, así que se ejecuta Console.WriteLine("wait");. Una línea en pantalla. Sin segunda línea. La palabra false no aparece a menos que la escribas a propósito.

Reglas que dejan la elección clara

Los paréntesis alrededor de la prueba son obligatorios. Escribir if ready { … } sin paréntesis hace que el build escriba un error. La prueba de esta página es un bool: un nombre como ready, o las palabras sueltas true o false sin comillas. if ("true") pone letras donde debe ir una prueba bool; el build escribe un error. Quita las comillas, o sigue usando un nombre bool. Un entero solo como if (1) no es cómo esta lección guarda la preparación; quédate con true, false o un nombre bool.

Las llaves importan para leer la lección. Esta página siempre envuelve cada camino en { }. C# permite un if de una línea sin llaves, pero en cuanto pones una segunda línea bajo ese if, solo la primera queda ligada a la prueba si no hay llaves. Los principiantes pierden ese detalle con facilidad. Mantén llaves en ambos demos para que cada camino quede claro: una llave de apertura después de la prueba, una de cierre antes de else, y luego otro par para else.

else pertenece a un if. Un else solo hace que el build escriba un error. En esta página un if tiene un else. Puedes escribir if sin else cuando solo te importa el camino true; el archivo que guardas sigue mostrando ambos lados para que veas la bifurcación. Elegir entre varios valores fijos es switch en una página posterior — no inventes aquí una tercera rama con otro else.

También puedes escribir la prueba sin un nombre aparte: if (true) { … } else { … }. Eso compila y corre. Los demos usan ready para que veas un bool guardado que decide la elección, como se ven los programas cuando ya sabes guardar true y false. Comparaciones como if (score > 10) vienen después de que te sientas cómodo con esta bifurcación true / false; esta página deja la prueba como un valor bool que ya entiendes.

Usa la tabla como comprobación después de una ejecución, no en lugar de una. true con el archivo que guardas escribe pass. false con el segundo archivo escribe wait. Si de algún modo corren las dos líneas de escritura, las llaves o el emparejamiento if / else están mal — arregla la estructura en vez de reinstalar el .NET SDK.

Una confusión frecuente es escribir la propia sintaxis: Console.WriteLine("if (ready)");. Eso escribe los caracteres if (ready). No elige un camino. Otra confusión es dejar demos de && o == en el mismo Main y preguntarte por qué la pantalla muestra true en vez de pass. El Main de esta sesión debe guardar solo el bool y el if / else.

Ya puedes guardar un bool, ponerlo en if (…), y dar a cada resultado su propio bloque con llaves. Cuando la prueba es true, corre una línea de escritura; cuando es false, corre la línea de escritura de else. La siguiente página es switch, donde varios valores fijos tienen cada uno su propio case en vez de una sola bifurcación true / false.

La pantalla es el camino elegido

El archivo que guardas escribe pass. El nombre ready está en los paréntesis, y ready no está en pantalla. La palabra true está en la línea de guardado, y true no está en pantalla. El camino else está en el archivo, y no corre en la ejecución guardada. Las comillas alrededor de if (ready) escriben letras, no un camino elegido.