Conversión

int count = (int) 40.0; guarda el entero 40, y Console.WriteLine(count) escribe 40. La pantalla es una línea. El punto no está en esa línea, y tampoco el 0 que va después del punto. Mantén el nombre de la clase pública Pine.

La palabra de tipo no encaja con los dígitos

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra bool ripe si esa línea sigue ahí, incluidos true y false. Borra string plant si sigue. Borra plant.Length y toda línea que haga una pregunta tras un punto. Borra cualquier línea ReadLine. Borra int count = 40; si la línea no tiene punto ni paréntesis. El archivo que conservas no tiene espera, ni plant, ni ripe, ni la palabra true. El número solo lo escribe la línea de escritura que usa el nombre.

La página de números ya mostró el conflicto. int count = 40.0; pide a un nombre int que guarde un número escrito con punto. El build escribe un error. No se queda callado. No quita el punto por ti. No hay pantalla que leer mientras se escribe el error. Esta página no deja la línea así. La palabra de tipo int no encaja con 40.0. Escribes esa misma palabra otra vez, entre paréntesis, entre el = y los dígitos.

Dentro de Main, la línea de guardado es int count = (int) 40.0;. El primer int es la palabra de tipo del nombre. Dice que count guarda un entero. count es el nombre y empieza con c minúscula. El = guarda. Luego (int) es la misma palabra de tipo, sola dentro de un par de paréntesis. No hay dígito dentro de esos paréntesis. El valor queda fuera, tras el paréntesis de cierre: 40.0. El 4 y el 0 antes del punto son el entero. El punto dice que hay otro dígito. Ese dígito es 0. El punto y coma termina la línea. Esta línea guarda 40. No escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco con esta línea. Los paréntesis no son un segundo número. No son comillas. No son una pregunta tras un nombre. No hay plant en esta página, así que el punto en 40.0 no es un punto que pregunte por Length.

La línea de escritura es el nombre desnudo: Console.WriteLine(count);. Sin comillas y sin paréntesis alrededor de count. C# lee el nombre count, escribe el entero que ese nombre guarda y termina la línea. En el archivo que conservas, ese número es 40. Las letras del nombre no están en pantalla. int no. Los paréntesis no. El punto no. El 0 que iba tras el punto no. La pantalla muestra 40, una línea. Guarda el archivo.

El archivo que conservas

Conserva esta forma didáctica. Un nombre, count. Una palabra de tipo para ese nombre, int. Un par de paréntesis, y dentro solo int. Un valor, 40.0, fuera de los paréntesis. Una línea de escritura, y esa línea usa el nombre desnudo.

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. No hay línea string plant ni línea bool. int count = (int) 40.0; guarda 40. No escribe nada. Console.WriteLine(count); escribe 40 y termina la línea. Una línea en pantalla. Sin punto. Sin segunda línea.

Ejecútalo con dotnet run. El programa escribe 40. No espera a que escribas. Los dígitos ya estaban en el archivo. Si dotnet run espera, aún hay ReadLine en el archivo. Borra esa línea y conserva int count = (int) 40.0; y la única línea de escritura. El programa termina tras la línea de escritura. La pantalla muestra 40. Una línea. Sin punto. Si la pantalla muestra 40.0, la línea de escritura imprime un número que aún tiene punto, o los paréntesis no están en la línea de guardado que ejecutaste. El archivo que conservas imprime count, y count guarda un entero. Si muestra 40.9, imprimes el decimal, no el entero tras los paréntesis. Si muestra 41, el archivo guarda 41. Estos paréntesis no redondean 40.9 a 41. Si muestra true o false, sigue el archivo de booleanos. Borra ripe. Si muestra leaf, plant sigue en el archivo. Si muestra count, la línea de escritura tiene comillas alrededor del nombre. No reinstalas el .NET SDK por una pantalla equivocada.

Una pantalla con 40 no prueba los paréntesis por sí sola. int count = 40; sin punto ni paréntesis también escribe 40. La pantalla puede verse igual. El archivo no. El archivo que conservas tiene (int) y 40.0. Cuando juzgues esta página, busca paréntesis y punto en el archivo. No juzgues los paréntesis solo por la pantalla.

Sin paréntesis, el conflicto sigue siendo un error. int count = 40.0; hace que el build escriba un error. No escribe 40. No se queda callado. No ejecutas mientras el build escribe un error. No necesitas el texto exacto del error. Pon (int) entre = y 40.0 para que la línea vuelva a ser int count = (int) 40.0;. El valor no va dentro de los paréntesis. int count = (int 40.0); hace que el build escriba un error. La palabra de tipo va sola dentro. Los dígitos van fuera, tras el paréntesis de cierre.

Las comillas y la palabra true no caben en este par de paréntesis. int count = (int) "40"; pide convertir letras en entero. El build escribe un error. int count = (int) true; pide convertir true en entero. El build escribe un error. No escribe 1. bool ripe = (bool) 1; pide al otro tipo convertir un dígito en true. El build escribe un error. No escribe true. No hay pantalla que leer porque no ejecutas mientras el build escribe un error. Al reparar el archivo que conservas, borra comillas, true y la línea bool.

El nombre debe existir antes de que una línea lo use. Si Console.WriteLine(count); está encima de int count = (int) 40.0;, el build escribe un error. Pon la línea de guardado encima de la de escritura. No escribas int otra vez para el mismo nombre. Un segundo int count bajo una línea que ya creó count es otro error. El segundo archivo de esta página sustituye la línea de guardado. No añade otro int count debajo. int count = (int); sin nada tras los paréntesis hace que el build escriba un error. El valor tiene que estar ahí. Un espacio dentro, int count = ( int ) 40.0;, aún guarda 40 y no provoca error de build por sí solo. El archivo que conservas no tiene espacio dentro de los paréntesis. Sin espacio tras el cierre, int count = (int)40.0;, también guarda 40. El archivo que conservas tiene un espacio ahí. Ni el espacio extra ni la falta de espacio es un segundo número.

Los dígitos tras el punto se descartan

40.9 no se guarda como 41 ni como 40.9 cuando los paréntesis llevan int. int count = (int) 40.9; guarda 40. El 9 se descarta. No se redondea hacia arriba. No es un segundo número en la línea. No es una segunda línea en pantalla. La línea de escritura sigue siendo Console.WriteLine(count);. La pantalla muestra 40. Una línea. Sin punto. El nombre count no está en pantalla.

Este es el segundo archivo. No es el que conservas. El que conservas usa 40.0, y el dígito tras el punto es 0. Guarda esta segunda forma como programa para ver que el 9 se descarta, luego vuelve a int count = (int) 40.0;.

Ejecuta dotnet run. La pantalla muestra 40. Una línea. El 9 no hace fallar el build. Si muestra 41, no es el archivo que ejecutaste. Si muestra 40.9, faltan paréntesis o la línea de escritura imprime el decimal tal cual. Si muestra 40.0, sigues en el archivo que conservas; es el correcto para volver, pero no es esta comprobación. Tras ver 40 desde 40.9, restaura el archivo guardado: int count = (int) 40.0; y un Console.WriteLine(count);.

Los paréntesis pueden ir delante de un nombre

Un nombre puede guardar primero el decimal. double es la palabra de tipo que encaja con el punto. double weight = 40.9; guarda 40.9 en weight. Esa línea no lleva paréntesis, porque double ya encaja con un valor escrito con punto. La siguiente línea es la que no encaja: int count = (int) weight;. Los paréntesis llevan int, el tipo que count puede guardar. Van delante del nombre weight, no delante de dígitos nuevos. weight ya guarda 40.9. Los paréntesis descartan el 9 y count guarda 40. La línea de escritura sigue siendo Console.WriteLine(count);. La pantalla muestra 40. weight no está en pantalla. double no. 40.9 no.

Este es el tercer archivo. No es el que conservas. El que conservas no tiene double ni weight. Escribe los dígitos 40.0 en la línea de guardado. La palabra dentro de los paréntesis debe ser un tipo que el nombre pueda guardar. int count = (double) 40.0; pone double dentro y int en el nombre. Esas dos palabras de tipo no coinciden. El build escribe un error. No escribe 40.0. No se queda callado.

Ejecuta dotnet run. La pantalla muestra 40. Una línea. double weight = 40.9; no necesita paréntesis y no hace fallar el build. Si muestra 40.9, la línea de escritura es Console.WriteLine(weight);. Vuelve a Console.WriteLine(count);. Si muestra weight, la línea de escritura tiene comillas alrededor de ese nombre. Tras ver 40, restaura el archivo guardado. No dejes double en el archivo que conservas.

Ya puedes guardar un entero a partir de un valor escrito con punto. int count = (int) 40.0; guarda 40. Console.WriteLine(count); escribe 40 y termina la línea. El punto no sale en pantalla. int count = (int) 40.9; también escribe 40. El 9 se descarta, no se redondea. Los mismos paréntesis pueden ir delante de un nombre que guarda 40.9 y la pantalla sigue siendo 40. Sin paréntesis, int count = 40.0; hace que el build escriba un error. (int) true hace que el build escriba un error. La página siguiente deja estos paréntesis. Mira un nombre que no guarda ningún número que hayas escrito ni ninguna palabra que hayas escrito.

La pantalla es el entero que cabe

El archivo que conservas escribe 40. El nombre en la línea de escritura es count, y count no está en pantalla. Los paréntesis están en el archivo, no en pantalla. Un WriteLine es una línea. Un 9 tras el punto se descarta. Un nombre que guarda 40.9 puede ir dentro de los mismos paréntesis y la pantalla sigue siendo el entero.