Transcripciones
1. 0-1. Es este el curso para ti y sobre el instructor: Así que bienvenidos a todos. Bienvenido a mi curso de
video tutorial de C Sharp. Aquí tengo alrededor de
11 horas de metraje enseñándote
de todo, desde lo básico absoluto. Esto supone que no tienes ningún conocimiento de
programación en absoluto. Y al final de esto,
tendrás los mismos,
si no más, conocimientos, sobre programación
y C Sharp que un típico estudiante universitario de
posgrado. Entonces, si quieres aprender C sharp como hobby, no
es problema. Vas a
sacar eso de este curso. Sin embargo, si quieres
conseguir un trabajo o potencialmente una carrera
al final de este curso, entonces de nuevo tampoco vas a tener ningún problema en hacerlo. Y para aquellos de ustedes
que tal vez quieran un repaso de C Sharp o un repaso de programación
genérico, entonces este curso también es
bueno para eso también Entonces, ¿este curso de video
tutorial de tienda es bueno para ti? Bueno, ¿quieres aprender tienda? Entonces la respuesta es sí. Pero quizás una mejor
pregunta es ¿por qué debería elegir este
curso sobre cualquier otro? Bueno, el secreto para
aprender es, número uno, el maestro, y así es como el maestro enseña
la información. Y número dos, el proceso
de aprendizaje. ¿El curso es atractivo? Sí, lo es. ¿Es aburrido? No, desde luego que no.
¿Es confuso? No, porque explico
principios no sólo de una manera, sino quizás de dos o
tres maneras distintas. Entonces al final de esto,
vas a obtener una comprensión completa de cada técnica que te
enseñe en este curso. Y el ritmo, ¿
es el ritmo rápido? No, no es un
ritmo rápido en absoluto. Este curso está diseñado
para principiantes absolutos. Entonces el ritmo es lento, en el mejor de los casos. ¿Para quién es este curso? Este curso es para principiantes
absolutos. Asume que no tienes ningún conocimiento de
programación, cero conocimiento de
desarrollo de software y quieres comenzar
con la programación C sharp. A lo mejor quieres hacer
algunos juegos en Unity. Tal vez quieras desarrollar aplicaciones de
software, aplicaciones móviles, sitios web en C shop. Todo eso se puede lograr
viendo este curso de video
tutorial Este curso sí asume
que sabes usar una computadora. Sabes genéricamente,
puedes mover un mouse, tal vez revisar tus correos electrónicos, y descargar un archivo Pero el punto es que no asume ningún
conocimiento de programación en absoluto. Entonces la
experiencia de aprendizaje, bueno, disfruto de la psicología
en mi tiempo libre, así entiendo cómo funciona
la mente humana, especialmente al aprender
y retener información. Pero quizás un tema nuevo y
desalentador. Entonces eso me lleva al
siguiente punto, el ritmo. ¿Cómo es el ritmo
del curso? Bueno, la programación tiene muchas palabras
técnicas
grandes y complicadas. Pero no te preocupes, introduzco palabras
técnicas muy lentamente a
lo largo del curso. Muchos profesores usan
palabras complicadas de inmediato, y causa
mucha confusión y
obstaculiza la capacidad de
retener el tema en cuestión Este me parece un
paso muy importante para evitar que
tu mayor enemigo, que es la sobrecarga de información. Así que no te preocupes,
vas a aprender las palabras complicadas y
técnicas, pero no antes del
tema que nos ocupa. Lo introduciré lentamente para que la experiencia
de aprendizaje sea muy placentera. Entonces a medida que avanza el curso, poco a poco
comenzaré a introducir
los términos correctos de la industria y la jerga técnica al ver los videos
de este Agradezco que
no estés ahí para hacer preguntas de inmediato
y obtener comentarios directos. Entonces, lo que hago, explico temas de varias
maneras distintas, no solo de una manera,
y de esa manera
se puede entender completamente
el tema que nos ocupa. Siento que este método de
aprendizaje es mucho mejor que hacer videos donde no se
proporciona suficiente información. Si no se proporciona suficiente
información, entonces te sientes perdido
y frustrado y no hay ningún maestro
ahí para hacer preguntas. No vas a experimentar
esto con mi curso. Y lo garantizo
porque incluso después haber explicado un
tema complicado, por ejemplo, numerosas
maneras diferentes, entonces si tienes alguna duda, puedes sentirme libre de
dejarme un mensaje o un comentario. Y estaré más que
feliz de atender cualquier duda o inquietud que tengas en cualquier momento
durante este curso. Y por último, si te enseño
un principio de programación, no sólo
te enseño la información. De hecho explico
por qué son útiles, por qué aplicas esto
en la vida cotidiana y por qué es importante en el desarrollo agudo de
C hacer
este principio en particular. Entonces ahí es donde mi curso difiere de muchos
cursos por ahí. Se aprende el cómo y el qué, pero también el por qué, que es muy importante. Engagement, uno de los
mayores asesinos para aprender nueva información es el
compromiso y la motivación Los dos tipos van de la mano. Entonces lo que hago,
utilizo ejemplos divertidos. También utilizo
ejemplos de tendencias para mantener
las cosas interesantes. Entiendo lo que se
siente perder la motivación y perder el compromiso y aburrirme un poco al
aprender un nuevo tema. Entonces trato de mantener
las cosas frescas y actuales para que
nunca pierdas la motivación. Y siempre te mantendrás comprometido
con los temas en cuestión. Entonces, ¿qué voy a sacar
de aprender este curso? ¿Por qué debería aprender de ti? ¿Cuál es el resultado final? ¿Qué puedo lograr? Bueno,
muy buenas preguntas. Te enseñaré todo lo
que necesitas saber sobre la tienda, pero no solo la
programación de la tienda C en general. Las herramientas y técnicas y principios para
hacerte un buen desarrollador, un buen programador,
especialmente en tienda. Y va a ser similar, si no mejor, que un estudiante
universitario de posgrado. ¿Cómo garantizo
estas afirmaciones audaces? Bueno, he estado en la universidad, fui por cuatro años enteros. Y puedo garantizar
que el contenido de este curso es exactamente lo que
aprendí en la universidad. Pero no sólo eso, sino más. Y también te enseño
las herramientas, técnicas y mejores prácticas que he recogido trabajando también en
la industria,
así que de manera profesional. Entonces, ya sea que vayas a la
universidad o no vayas, tienes una ventaja porque no
estás sentado en un aula llena de gente
con muchas distracciones Esta es una experiencia única uno
a uno. Entonces, por último, voy a
resumir diciendo, no
importa qué
tipo de aprendiz seas, ya seas un aprendiz visual
o no un aprendiz visual, puedes ver este
curso
sentándote en
una silla y comiendo una
pizza, por una silla y comiendo una
pizza No obstante, si quieres
ser más interactivo, entonces proporciono los archivos completos del proyecto junto
con este curso, todo el código fuente que utilizo. Entonces, si quieres
seguir adelante en tu computadora, puedes hacerlo. No hay problemas en absoluto. Este curso ofrece
múltiples formas de aprendizaje para varios
tipos diferentes de alumnos por ahí. Entonces sobre mí, ¿quién
soy, cuál es mi nombre? Bueno, soy Sean y es un
placer conocerlos a todos. Soy ingeniero de software profesional,
autónomo. Pero no sólo eso, sino que enseño desarrollo de
software
y programación. Trabajo con muchos lenguajes de
programación diferentes y también con muchas
arquitecturas diferentes Pero debido a que regularmente
enseño a los estudiantes, no
he perdido la capacidad comunicarme
con nuevos alumnos, especialmente a nivel principiante. Yo me gradué de la universidad
ahora en 2007. Tengo más de 20 años de experiencia
profesional
en desarrollo de software. Incluso estaba trabajando junto a mis estudios universitarios
en el mismo campo. He estado enseñando
programación desde 2003. Así que hace mucho tiempo, lo
usé como una forma de financiar mis estudios universitarios antes de que
Youtube fuera siquiera una cosa. Te voy a mostrar mi sitio web muy
antiguo ahora donde hice
cursos de video tutorial en Visual Basic, seis C plus más Java, Direct X, y varias cosas. Para que veas que ahora he enseñado a mucha
gente a programar. Y siempre me
vuelven después, ya
sabes, diez años
después, 15 años después. Y cuéntame todo sobre
sus historias de éxito, las empresas en las que están
trabajando ahora y en qué proyectos
han estado involucrados. Entonces es realmente saludable
e interesante
escuchar estas historias de éxito
de mis alumnos anteriores Y me encanta cuando los alumnos vuelven a mí
y me cuentan
sus historias de éxito y
cómo ha cambiado su vida. Aprender, programar,
es realmente interesante y es la
mejor parte de la enseñanza. Así que ahora soy autónomo, pero he trabajado para muchos
negocios en el pasado. Empresas pequeñas y
grandes también, quizás hayas oído hablar de algunas. He trabajado para The Guardian, que es una compañía de periódicos con
sede en el centro de Londres. He trabajado para el
Ministerio de Defensa británico, donde trabajamos en software
Cad para modelar sus
naves de superficie y submarinos He trabajado para Pfizer, una compañía farmacéutica, de la que estoy seguro que todos han
oído hablar estos días Pero cuando estaba trabajando ahí, no mucha gente ha
oído hablar de esa compañía. Y he trabajado para
varias agencias pequeñas de las que quizás estoy seguro de que nunca
has oído hablar. Para poder compartir mis
experiencias al trabajar en equipos
pequeños y también en equipos
muy grandes. Y ejemplos de
ambos tipos diferentes de experiencias que compartiré a
lo largo de este curso también. Entonces, si te estás preguntando de dónde es
mi acento, bueno, nací en Reino Unido y mis emprendimientos de programación me han llevado por todo el mundo. Me mudé a América cuando tenía 25 años y ahí obtuve la ciudadanía. Y ahora vivo
en Sudamérica. Pero una cosa que
se ha mantenido consistente, más que mi casa
y mi acento, por ejemplo, es que
siempre he estado enseñando programación y siempre he estado haciendo desarrollo de software. Así que basta de mí.
Hablemos de C sharp ahora.
2. 0-3. ¿Qué es C# en el diseño de juegos? y por qué aprender C #?: Entonces, ¿qué es C Sharp? Bueno, C sharp es lo que se llama un lenguaje de
programación orientado a objetos. Y no te preocupes, estaremos
hablando de eso más tarde. Es creado por Microsoft y
se ejecuta en lo que se llama
el.net Framework C Sharp tiene sus raíces
en la familia C. Entonces no sé si has
oído hablar de C o C Plus Plus, pero es bastante similar
a esos idiomas, y aquí es de donde
se desarrolló. Es muy similar a lenguajes
populares como
C plus Plus y Java. Y la primera versión de C Sharp se estrenó
en el año 2002. Ahora, entonces tiene más de 20 años. Y la última
versión al momento de filmar es C Sharp versión 11. Así que el lenguaje C Sharp
evoluciona lentamente más o menos como
todo lo demás en la vida. Entonces, ¿por qué debería aprender C
Sharp? ¿Para qué se utiliza? Bueno, puedes crear aplicaciones
móviles, aplicaciones escritorio, aplicaciones web como
sitios web, videojuegos, juegos realidad
virtual,
por ejemplo, aprendizaje automático,
software, aplicaciones de base de datos,
y mucho, mucho más. Es uno de los lenguajes
de
programación más populares del mundo. Y por eso es
realmente bueno aprender un idioma como C
Sharp porque
habrá más
oportunidades laborales por
ahí y más oportunidades para que apliques tus conocimientos. Es fácil de aprender y
de usar. Cuenta con un enorme apoyo comunitario. Si ya conoces C
o C plus o Java, o tal vez quieras
aprenderlos en el futuro, entonces son muy similares. Los principios
que te enseño en este curso, puedes aplicar a C plus plus y Java si deseas recoger un
nuevo idioma en el futuro. Una de las tendencias en estos
momentos es crear videojuegos en un paquete de
desarrollo de software llamado Unity. Unity apoya a C Sharp
detrás de escena. Si quieres que tu
videojuego haga cosas, que tus personajes se muevan, entonces puedes usar C sharp
para lograr esto. Entonces ahora mismo, la gente está
aprendiendo C sharp más que nunca, solo para que puedan crear
videojuegos en Unity. Así que aquí hay muchas
razones para aprender C sharp y por qué deberías aprender C Sharp sobre quizás
otros idiomas. Entonces ojalá, a través de
mi explicación hasta ahora, te
he convencido de que
comiences tu viaje
aprendiendo C Sharp y convirtiéndote
quizás en un programador profesional, o incluso aficionado Ahora comencemos nuestras
aventuras en C Sharp y descarguemos las herramientas
que necesitamos para comenzar.
3. 0-4. Descarga e instalación de Visual Studio (C # IDE): ¿Cómo empezamos a
codificar en C Sharp? Bueno, la forma más fácil de
comenzar es usar
lo que se llama un IDE. Esto significa Ambiente de
Desarrollo Integrado. Y el entorno que
vamos a
usar se llama Visual Studio. Así que no vamos
a estar codificando en el Bloc de Notas ni nada de
miedo como eso Vamos a
utilizar herramientas para principiantes y
fáciles de usar que
son proporcionadas por Microsoft. Y no sólo eso,
son gratuitos. Déjame mostrarte
cómo descargar y comenzar con Visual Studio. Empecemos a descargar
Visual Studio ya. Si venimos a Google y simplemente escribimos en Visual
Studio Community, y podemos hacer clic en el
primer resultado aquí mismo. Ahora, la última versión
al
momento de filmar es
Visual Studio 2022. Pero aunque tengas
una versión anterior o una versión posterior, muchas de las técnicas que
vamos a estar cubriendo en este curso van
a funcionar. No hay problemas. Entonces vamos a hacer click en
este primer enlace aquí. Aquí podemos descargar
el IDE
aquí mismo si estás usando un
Apple Mac, por ejemplo. Entonces puedes hacer clic en
este botón aquí arriba. Y luego Visual Studio viene
en tres sabores diversos. Tenemos el para
Windows justo aquí, el para Macos, y también uno ligero
para Mac, Windows y Linux. Entonces, dependiendo de tu sistema
operativo, deberías estar
prácticamente cubierto. Pero estoy ejecutando una máquina con
Windows y eso no coincide realmente. Si ejecutas Mac, aún puedes seguir los tutoriales,
no hay problema. Entonces voy a hacer click en
este enlace de descarga aquí, y luego Visual Studio
va a comenzar a descargar. Es sólo un archivo de 34 megabytes, así que es muy pequeño, Pero todo se
descargará dentro del propio archivo configurado Justo antes de instalar
Visual Studio, quiero mencionar una cosa. Visual Studio no solo está
ligado al desarrollo de C Sharp. Se puede hacer tanto
en visual studio. Visual studio funciona con
HTML, CSS, Javascript. Incluso puedes crear aplicaciones
móviles, Php, Python, Spot, Net. Todas estas diversas cosas, herramientas, tecnologías y lenguajes de
programación que puedes hacer en Visual Studio. Entonces, si ya conoces
un idioma diferente, o tal vez quieres
probar diferentes idiomas en el futuro después de
mirar C Sharp, entonces Visual Studio también te
apoyará a través de
esos esfuerzos Entonces es una
pieza de software muy poderosa, y de nuevo, es gratis. Vamos a abrir el archivo de instalación de Visual
Studio, que acabamos de descargar y obtener con la instalación de
Visual Studio. Así que hagamos clic en continuar aquí. Ahora solo está preparando
el instalador, está descargando un archivo un
poco más grande. Ahora bien, esta es la ventana
que vas a ver una vez que se inicialice la
configuración Entonces, muchas
cosas diferentes que puedes hacer aquí para los fines
de este curso. Lo único con lo que vamos a
estar trabajando es con C Sharp. Lo único que necesitamos es entorno de
escritorio.NET aquí mismo Así que solo tienes que hacer clic en
esta casilla aquí mismo, y luego podemos obtener
con la instalación estos componentes. ¿Algo más? Aquí es totalmente
opcional, y hasta usted, tenemos varias cosas para
desarrollar sitios web en Aspet También contamos con Azure Node, Python. De nuevo, cosas de escritorio y móviles, cosas en C Plus Plus. E incluso puedes instalar
Unity desde dentro del instalador de Visual Studio y también varios
componentes de datos. Así que hay mucho por
hacer, mucho que instalar y mucho que aprender en términos de programación y trabajo
con Visual Studio. Pero para lo que necesitamos es sólo
esta sencilla caja de aquí mismo. Si hablas otro idioma o estás más familiarizado
con otro idioma, puedes seleccionarlo desde aquí. No es ningún problema en absoluto. Entonces, si venimos a aquí ahora, esto es todo lo que se
va a instalar aquí. Para ser honesto, no
creo que necesitemos constructores de modelos de
live share o blend. Simplemente va a
volar nuestra instalación. Pero creo que esta es una buena
configuración para empezar
y te va a dar todo lo
necesario para seguir este curso e
incluso un poco más. Entonces ahora lo que vamos a hacer es
simplemente hacer clic en este botón de instalación. Aquí tienes un
par de opciones. Puede descargarlo todo, luego instalarlo, o puede
instalarlo mientras descarga. Realmente no importa, solo
depende tu preferencia y quizás de
tu conexión a Internet. Entonces, hagamos clic en el
botón de instalar y comencemos. La instalación puede
tardar unos minutos, pero una vez que veas esta
pantalla aquí mismo, eso significa que Visual Studio
se ha instalado correctamente. También puedes tener iconos en tu escritorio o en el menú de
tus programas, dependiendo del
sistema operativo que estés ejecutando. Pero esencialmente, una vez que
aparece en esta lista, entonces tienes instalado Visual
Studio. Lo que podemos hacer,
podemos simplemente hacer clic en este botón ahora e
iniciar Visual Studio, y luego comenzar con nuestro desarrollo de
software
en C. Sharp.
4. 1-1. Hello World (logotipo de Mr. Beast): En esta lección,
vamos a crear una pieza de
software muy simple llamada aplicación de consola, y va a
mostrar el logo de Mr .
Beast a quien abra
nuestra pieza de software. Vamos a ponernos en marcha ya. Visual Studio ha sido
recién instalado. Vamos a crear nuestra primera aplicación de
software. Va a ser
nuestro primero. Va a ser amigable para
principiantes, y vamos a tomarlo
desde arriba. Vamos a ponernos en marcha. Una vez que Visual Studio está abierto, vamos a hacer clic en
Archivo, Nuevo proyecto. Entonces tendremos una ventana
que se parece a esta. Ahora bien, si no tienes
Visual Studio 2022, esa es la versión que
estoy usando ahora mismo. Puede verse ligeramente diferente. Es posible que veas ajustes
en diferentes lugares. Las cosas podrían llamarse
algo ligeramente diferente. Pero el tipo general de
principio sigue aplicándose. Ahora nuestra primera aplicación de
software, va a ser una aplicación de consola. Y esto está representado por
esta plantilla de proyecto aquí. Lo que es una aplicación de consola, es como
una ventana negra. Simplemente tiene texto en él. Y la razón por la que estoy usando eso es
porque es muy amigable
para principiantes. No hay botones, listas, imágenes, ni nada complicado. Esto es muy amigable para principiantes y es por eso que estoy usando
una aplicación de consola. Si en realidad no lo
ves en esta lista, puedes
buscarlo aquí escribiendo en consola o aplicación de
consola. Y puedes ver que todas estas
plantillas se cargarán aquí arriba. Queremos éste porque
estamos escribiendo en C Sharp. En realidad se ejecutará en
Linux, Mac, Windows. Vamos a usar este,
vamos a hacer clic en siguiente. Podemos llamar a esto como
queramos. Depende de ti. Puedes dejarlo
así, o puedes elegir algo
más descriptivo. Entonces vamos a llamarlo
primer programa, la ubicación. Puedes elegir un
directorio donde
quieras guardar todos
tus archivos de proyecto. Eso depende de usted.
Entonces, hagamos clic en siguiente. Ahora bien este framework,
voy a hablar de todo sobre frameworks
en un tutorial posterior. Quiero que esto sea
muy simple, esta lista, podría tener 4567,
todos números diferentes Sólo lo vamos a
dejar a las siete. Si tu cuatro está
bien, todavía va a funcionar. Si ve esta casilla de verificación
aquí que dice, no use declaraciones de nivel superior Asegúrate de que esté comprobado. Esto es muy importante. Vamos a hacer clic en Crear. Y esto
es lo que vemos aquí mismo. Ahora Visual Studio en realidad se nos
da todo este código, y la razón por la que
lo hacen es hacerlo más fácil de usar
para que podamos comenzar. Como usuario por primera vez, probablemente no tengas
idea de lo que esto significa. Eso realmente no importa. Todas estas líneas aquí las estaré cubriendo en un
tutorial posterior y
aprenderás lo que significan a tiempo para mantener a este
principiante amigable. La única línea en este momento de todos modos, debes
preocuparte es esta de
aquí en este tutorial. Vamos a poner
todo nuestro código entre esta llave de aquí y esta de aquí, todo
en el medio. Y podemos poner más líneas
aquí si queremos. En este tutorial, sólo estamos hablando de esta sección aquí. No te preocupes por nada de esto. Eliminemos toda
esa complejidad. Hablemos de esto.
¿Qué hace? Dice consola
línea derecha, Hola mundo. Para poder realmente intentar
ejecutar este programa, necesito hablar de lo que
se llama compilador Ahora, Visual Studio, tiene un compilador incorporado porque
estamos escribiendo C Sharp Tiene un
compilador Sharp ahí dentro. Lo que hace el compilador C Sharp, toma todo nuestro código aquí, eso es todo en esta ventana
blanca, lo compila. Si estamos usando
Windows, por ejemplo, va a crear un
archivo EX para nosotros lo que es un archivo E. Se llama archivo binario, tal vez realmente no necesitas
saberlo en este momento, pero se llama archivo binario. Si queremos ejecutar
este programa en digamos, una Mac, por ejemplo, entonces va a
crear un archivo binario que un Mac entendería. Si queremos que ejecute un Android, como un teléfono Android, creará un archivo binario que el
teléfono Android pueda entender. Eso es realmente lo que
hace un compilador en pocas palabras muy pequeñas y no
complicadas Toma todo nuestro
código y
lo compila en un archivo binario Para ello, para
poder ejecutar el compilador, ve este pequeño botón
verde de reproducción
aquí arriba donde dice nuestro
nombre de proyecto llamado Primer Programa Cuando hacemos clic en este botón, aquí es donde decimos,
oh, oye, Visual Studio. ¿Puedes decirle a nuestro
compilador que tome todo nuestro código y lo
convierta en un archivo para que podamos
ejecutar el software Eso es exactamente lo que hace, así que vamos a
hacer click aquí mismo. Lo que sucede es que nuestra
pequeña ventana negra aparece y
desaparece de inmediato. Dos cosas aquí, todas
estas cosas aquí abajo, viste todo ese
texto volviéndose loco. Ese es el compilador. El compilador está diciendo,
bien, yo he hecho esto, esto,
esto, ¿puedo escupir este
archivo EXE en la parte inferior del mismo Eso es porque estoy
usando Windows. Se ha creado un archivo EXE para mí. Ahora se
ha creado el archivo EXC. El software se ejecuta. Intenta abrir
el archivo EC por nosotros. Esa fue esa ventana negra
que acaba de aparecer. Pero luego
desapareció instantáneamente. Desapareció instantáneamente porque en realidad no le
estamos
diciendo que se mantenga abierto. Visual Studio hizo un buen trabajo al poner este código
de
muestra para nosotros, pero también mantiene abierto
el software para que
podamos ver realmente
lo que está pasando. Voy a escribir una
línea más y eso va a mantener abierta la
ventana negra para nosotros. Entonces voy a escribir consola
porque la consola es
la ventana negra. Entonces queremos decir, oh, oye, línea de lectura de
consola, ¿verdad? Entonces eso es lo que estoy
poniendo ahí y eso mantendrá abierta la ventana de la
consola. Hablemos de esta
línea muy rápido. Lo que esto hace,
espera la entrada del usuario. Entonces, por ejemplo,
¿has visto un software, alguna pieza de software que diga, oye, cuál es tu nombre? ¿Y luego escribas tu nombre? Entonces lo que sucede es cuando
ejecutamos esta línea de código, la ventana negra está
esperando nuestra entrada. Y eso solo mantiene
la ventana abierta. Vamos a ejecutar
este software ahora. Ahora puedes ver que la
ventana está abierta. En realidad se ha mantenido abierto, no
va a desaparecer. Eso es solo porque está
esperando la entrada de nuestro usuario. Pero es algo
así como una forma un poco sucia, una
especie de hacky de mantener Para que podamos ver lo que está pasando. Esta ventana negra aquí es
nuestra aplicación de consola. Es nuestra primera
pieza de software. Date palmaditas en la
manada. No hace mucho. Lo único que hace
es decir hola mundo. Te está diciendo que está vivo. Es saludar al mundo. Eso es todo lo que hace ahora mismo. Muy simple, pero no te
vendas corto, es tu primera
pieza de software. Podemos cerrar esto
golpeando Enter o
cruzándolo aquí. Y eso es todo en nuestra palabra, nuestra primera aplicación de
software Ahora, ¿cómo ampliamos esto? Bueno, hablemos primero de otra
cosa, es
decir, la
sensibilidad de mayúsculas y minúsculas en C sharp. Y algunas pequeñas
advertencias también. Se nota aquí donde dice línea
roja y línea derecha, realidad
es sensible a mayúsculas y minúsculas. Lo que eso significa es que si cambio esta L mayúscula
a una L minúscula, puedes ver que tengo esta línea roja debajo que dice, oh, realidad no
puedo encontrar esto en el sistema.
No existe. Eso es porque una L
minúscula y una
L mayúscula en C sharp son dos cosas
muy diferentes. Téngalo en mente. Tiene que ser sensible
a mayúsculas y minúsculas. Lo último es que todas las líneas deben terminar con un punto y coma. Si olvidas el punto y coma, entonces vamos a conseguir
que suceda algo similar. Ves aquí a este pequeño garabato
rojo. Si pasamos el cursor sobre
eso con el ratón, es decir punto y coma esperado Entonces en realidad
te está diciendo cuál es el problema. Si alguna vez tienes una
época en la que tienes la línea
roja ondulada e
intentas ejecutar el programa, vas a conseguir
algo como esto Y te vas a
familiarizar mucho con este diálogo en tus emprendimientos de
programación, créeme. Y entonces te dirá cuál es
el problema aquí abajo. Puedes hacer doble clic en él
y te avisa de esto. Y eso es sólo decir que falta
el punto y coma. Ahora, he hablado muy
brevemente sobre lo que hacen estos. Hablemos de esta parte aquí. Lo que queremos hacer es decir, oh, oye, ventana negra. Escribe la línea a la ventana y queremos
escribir hola mundo. Eso es todo lo que está haciendo. Eso lo resolviste por completo tú mismo. Pero ahora te he dicho que en realidad
podemos ampliar esto. De hecho podemos decir, oh, oye, así es,
Tres hola mundos. Lo guardamos, hacemos clic en el botón, y ahora tenemos tres de esos. Ahora ya ves a dónde
va esto en nuestro ejemplo. Justo al principio
dije que vamos a exhibir el logo de Mr. Beast. Ahora tengo un
expediente de solicitud para el logo de Mr .
Beast. El esquí es solo una
representación textual de una imagen. Te voy a mostrar lo
que eso significa ahora. Todo va a tener sentido. Para que puedan ver
aquí, tengo un logo de Mr. Beast aquí en Bloc de notas Y he añadido las líneas
correctas de consola antes de ella, para que podamos ver eso aquí. Sólo voy a
copiar todo eso. Y voy a
pegarlo entre estos rizados como ya
hablé antes ahí mismo.
Voy a salvar eso. Voy a presionar
el botón verde. Voy a abrir esta
ventana para que podamos verla. Y voy a desplazarme hacia arriba. Esa es nuestra primera
pieza de software. Tan pronto como alguien abra
tu pieza de software, van a ver
el logo de Mr. Beast. Es así de simple cómo podemos modificar ese mensaje y
crear una imagen completamente nueva. Cuando analizamos el código aquí, son solo múltiples declaraciones de
línea derecha
lo que crea todas estas Ms aquí y un
diseño de personaje muy agradable en el logotipo aquí. Antes de que termine esta lección, sólo
voy a mostrarles
cómo se une todo esto. Tiene sentido en tu cabeza. ¿Recuerdas cuando creamos un proyecto completamente nuevo y
tenemos este campo de ubicación? Bueno, ahora mismo voy a
entrar en esta carpeta. Ahora estoy en ese directorio
en nuestra computadora. Podemos ver que Visual
Studios creó una serie de carpetas
y archivos para nosotros. Aquí dentro tenemos lo que
se llama un archivo de solución aquí, y se crea otra carpeta. Entonces entraremos ahí. Se ha
creado aún más archivos. Este tiene nuestra codificación. Pero si miramos dentro de
esta carpeta bin aquí, y luego dentro de esta carpeta de
depuración aquí mismo, dentro de esta,
puedes ver que hay algunos archivos aquí mismo
en el medio aquí. Este es nuestro archivo binario, y como estoy usando Windows, se ha creado un archivo EXE, Fas. Si hacemos doble clic en esto, incluso
podemos enviarlo a
un amigo, por ejemplo. Pueden hacer doble clic en él. Cuando lo maximizas,
puedes ver el logo de Mr .
Beast. Se puede ver así
es como se une todo. Visual Studio le dice
al compilador, oh oye, toma todo el código,
crea un archivo EXE, Fas, y póngalo en esta
carpeta aquí mismo Todos los demás archivos de los que
hablaré en una fecha posterior. Pero con el propósito
de simplicidad, crea nuestro archivo EXE fas, y esa es nuestra
primera pieza de software.
5. 1-2. Variables: Ahora vamos a hablar de es que voy a introducir
una variable muy sencilla. Te voy a mostrar
cómo funciona, qué son las variables
y cómo pueden beneficiarse y cosas
así, variables. Hablemos de lo que son. Para empezar, tenemos una aplicación
de muestra aquí. Simplemente dice, hola
mundo a una ventana negra. Y eso es todo lo que hace, como
puedes ver ahí mismo. Ahora voy a
introducir lo que se llama una variable y
voy a hablar de
cómo nos pueden ayudar. Simplemente introduzcamos una variable. Puedo hablar de
esto en un segundo. Voy a llamarlo prueba. Vamos a darle
un valor de Hello world. Sólo voy a poner aquí
el nombre de la variable. Entonces hablemos de esto
y de lo que esto hace. Entonces lo que estoy haciendo aquí, estoy inicializando lo que
se llama una variable Ahora esta es la variable. Se llama test, así que este es
el nombre de nuestra variable. Ahora bien, esta variable se puede
llamar como quieras. Podría llamarse sándwich de jamón. Realmente no importa. Pero el punto es que
necesitas darle un nombre donde tenga sentido para
ti, puedes referirte a él. Porque cuando tienes
una aplicación de software que tiene miles de variables, te vas a
confundir mucho si los llamas a todos los
diferentes tipos de sándwiches o nombres aleatorios como test o
algo así. Entonces necesita que tenga
sentido para ti. Así que sólo voy a
llamarlo hola Mundo. Entonces ese es el nombre
de nuestra variable, este es el valor
de nuestra variable. Entonces esto es lo que estamos poniendo
dentro de nuestra variable aquí. Ahora bien, esta parte de aquí es
lo que se llama un tipo. Ahora bien, esta es una variable de cadena. Qué es una variable de cadena, es un contenedor para
palabras, oraciones. Puedes poner un libro
entero aquí si quieres. Todo son letras
y números alfanuméricos , pero como cadena, no son números por sí mismos, no
es un valor decimal, no
es una fecha o una hora o algo
complicado así. Eso es lo que es una cuerda. Eso es lo que se llama
un tipo de variable. Ese es el tipo de variable
que está diciendo, oye, computadora, queremos iniciar una nueva variable
y ponerla en la memoria. El nombre de nuestra
variable es este. El signo igual es cómo lo
inicializamos, como darle un valor Cuando se trabaja
con cadenas, siempre
ponemos el valor
en comillas dobles. Al igual que dentro de las comillas dobles está el valor para nuestra variable. Siempre terminamos cada
línea con un punto y coma. Ahora nuestra variable se llama Hola Mundo. Vamos a
ejecutar el programa. Se puede ver que da salida
Hello World a la ventana. Hace exactamente lo
mismo que hacía antes. Eso es de esperar porque no hemos
cambiado nada. Acabamos de declarar
e inicializar una variable y la estamos emitiendo a la ventana
negra como antes Exactamente lo mismo
que estamos haciendo aquí. Una cosa muy rápida,
con nombres de variables, lo que siempre hago es usar
mayúsculas y minúsculas siempre con un carácter
inferior al inicio. Ahora bien, esto depende de ti, pero generalmente así es como la
gente tiende a usar variables. A lo mejor cuando trabajas en una
empresa en el futuro, si eso es lo que quieres hacer, otras personas harán
algo similar. Es bueno introducir
buenas prácticas. Ahora bien, esa es la única
razón por la que hago eso. Entonces cada
palabra siguiente, hola mundo. Esto tendrá mayúscula. Si tenemos otra palabra aquí, entonces esa
comenzará con mayúsculas. Eso es lo que se llama
estándares, es opcional. Hablemos de qué es
la declaración y
qué es la inicialización para
cubrir esos dos términos Voy a ampliar
nuestro pequeño ejemplo aquí. Ahora voy a saber, ¿cómo
estás así? Y luego voy a volver a sacar la variable a la pantalla. Entonces voy a
ejecutar la aplicación. Para que veas lo que está pasando. Se puede ver aquí en la
ventana dice, hola mundo. ¿Cómo estás? ¿
Echar un vistazo a cómo funciona eso? Puedes ver aquí, hemos
definido nuestra variable, le
hemos dado un tipo. Ahora, sólo le damos un tipo a la
variable una vez. Estamos diciendo, oh, oye, computadora, esta es nuestra variable que
quiero usar. Esta es nuestra nueva variable, por cierto, es una variable de
cadena. Ahora, ya lo hemos hecho una vez. Ya no necesitamos decirle a
la computadora que es una cadena, la computadora ya lo sabe
y recuerda esto Ahora, cada vez que
modificamos nuestra variable, le damos un nuevo valor, sólo
vamos a sobrescribir
lo que ya está ahí dentro Cuando llegue esta línea, esta parte será
reemplazada por ¿cómo estás? Y luego
lo estamos volviendo a poner aquí. No tenemos que declarar e inicializar nuestra
variable en una línea Echemos un vistazo a
este ejemplo aquí. Yo también podría hacer esto. Lo mismo va a pasar. Lo que estoy haciendo aquí, estoy
declarando nuestra variable, declarando significa oye, computadora, quiero crear una nueva Sé que va
a ser una cadena, pero aún no sé cuál será el
valor. A lo mejor voy a decidir en un
momento posterior. En un momento posterior. Bien, he decidido cuál será
el valor. Va a ser hola Mundo. Entonces quiero
sacarlo a la pantalla. Y luego lo estoy volviendo a inicializar aquí y
sacarlo a la pantalla Esto es declaración o
declaración de una variable. Esto es inicialización
o asignación. Hay algunas palabras que
vas a escuchar en el futuro si continúas
programando con C Sharp. Se puede ver que estamos haciendo
esto en dos líneas y la salida es exactamente
la misma que antes, lo que es de esperar. Una última cosa, si declaramos
una variable aquí e
intentamos sacarla sin
inicializarla ni asignarla, entonces va a
arrojar un error Podemos ver esta línea
roja squigly. Cuando colocamos el mouse
sobre la línea roja, tenemos una pequeña pista sobre
cuál es el problema Y es solo decir uso de variable
no asignada,
hola mundo Nos está diciendo cuál es
el problema. Cada vez que tenemos un error, no
podemos ejecutar el programa porque siempre
necesitamos
corregir estos errores. Esa es una visión muy básica sobre cómo funcionan las variables en C sharp.
6. 1-3. Tipos de datos: Bien, hablemos de
los tipos de datos, qué son, cómo nos pueden ayudar, por qué podemos usarlos y todo lo demás. Entonces tengo una
aplicación de muestra aquí. Realmente no hace mucho. Declaramos e inicializamos
dos variables de cadena aquí, y las sacamos
a nuestra ventana negra Cuando ejecuto la aplicación aquí, solo
dice
Bob Esponja pantalón cuadrado. Pensé en un ejemplo sobre cómo explicar los
tipos de datos mucho más fácil. Se me ocurrió un ejemplo. Alguna vez has jugado a
Top Trumps o cartas o equipo de
Pokémon
o algo así, donde tienes el
nombre del personaje,
tal vez algunos atributos como la edad, el
peso, la altura, la rareza,
o cosas así Creo que eso representaría bastante bien
los tipos de datos. Y ayúdame a explicarlos para que
los entiendas mucho más fácilmente. Imagina una tarjeta que tenga nombre
y que pueda tener una edad. Por ejemplo, esta es la
edad del personaje. Ahora Bob Esponja es uno
de esos personajes que trasciende a todas las edades Voy a poner 21. Esta es una variable de tipo cadena, Este es un tipo de datos. Otro tipo de datos que podemos usar
es lo que se llama un entero. Ahora lo que
es un entero, es un número. De hecho, podemos pasar el cursor sobre él y Visual Studio realmente nos
da más
información al respecto Representa un entero con signo 32 bits 32 bits solo significa el tamaño. Cuánta información
puedes poner aquí. Creo que va
desde 2 mil millones negativos hasta
2 mil millones positivos. Creo que usar la edad le
queda bastante bien a
esto, sólo van a ser 23 dígitos. Cuando usamos variables de
tipo entero, no
necesitamos estas
comillas dobles como en cadenas. Sólo necesitamos un
número aquí mismo. Otro, tal vez el peso, y eso será en libras. A lo mejor esta esponja es
alrededor de 120 libras, algo así.
Otro de altura. Ahora la altura, la vamos a
poner en pies y pulgadas. Voy a ponerlo
en pies y pulgadas para poder mostrarte un nuevo tipo de datos. A esto se le llama doble. Ahora lo que es un doble, representa números decimales. Pongamos la altura aquí. Digamos que nuestra esponja
es de tres pies, 4”, por ejemplo.
Algo así. Así que esa es la altura
de nuestra esponja. Si tenemos un over double aquí, representa un punto flotante
de doble precisión. Muy complicado, ¿no? Y es por ello que la gente
aprende de los tutoriales, un doble representa un decimal. Esto es cualquier cosa con un punto
decimal. Ahora, decimales. Hablemos de
decimales muy rápido. En C sharp, podemos representar un número decimal en
una de tres formas. A otro se le llama flotador. Pongamos números después de esto. Cuando usas una variable, todas
necesitan
tener nombres únicos. Hagamos decimal. Esa es otra forma de cómo
podemos los números decimales. Estas son las tres formas en las que podemos representar decimales en Do sharp La principal diferencia
es la precisión. Ahora flotar es, creo, de 32 bits. Son sólo siete dígitos. Se le puede dar
más de siete dígitos, pero lo cortará. Truncarlo a las siete. Pierdes todo
después de siete dígitos, que es toda esta precisión aquí. Ahora un poco 64. Un poco más, creo. 15 dígitos, 15 a 16 dígitos.
Entonces es más preciso. Por lo que podemos poner hasta 15 aquí. Por defecto, se
usa un doble cuando se usan
números decimales en C sharp. Cuando diga default, lo
explicaré en un segundo. El último es decimal. Esta es,
creo que es de 128 bits, muchos y muchos dígitos. Creo que 28 dígitos, bastante largos. Usamos decimales cuando
hablamos de cosas que hacer con el dinero A lo mejor si escribes una
solicitud para manejar impuestos como agencia gubernamental, por ejemplo, queremos
asegurarnos de que todos paguen sus impuestos para muy lejos de
su punto decimal. Cuando tratas con dinero, tiene
que ser
realmente, muy preciso y
ahí es donde usaríamos un decimal. Puedes ver aquí
cuando inicializo este tipo de datos float
variable altura uno, pongo un poco de F
al final aquí Esto le dice a C agudo. Oye, quiero inicializar
un valor flotante. Esto se debe a que usa
double como predeterminado. Se ve cuando
inicializo un doble, no
necesito poner
una letra al final Cada vez que pongo un valor
decimal aquí, C sharp asumirá
que es un doble. Si quiero inicializar
un float aquí, tengo que decir, oh, por cierto, este es un tipo de datos float Porque si no hago eso, se
puede ver que hay una línea roja. Yo vuelo el cursor sobre él. Dice, tipo
literal doble no puede ser implícitamente
complicado, ¿no es así? Básicamente dice, usar un sufijo para crear un
literal de este tipo Básicamente es decir, oye, tienes un tipo de datos flotante, pones una F al final
y luego estamos contentos. Lo mismo con decimal, no
sé dónde no usas una D o algo
más descriptivo, probablemente
sea usado
por otra cosa Este quiere una M. Y de
igual manera, si no ponemos una M, es decir que
pongas una M.
Es por eso que IDEs se llama IDE, como visual studio, realmente bueno. En realidad te está diciendo lo que te estás perdiendo y
lo que tienes que hacer. Si usas algo
como Bloc de notas, no te va a decir esto Te ayuda a programar
mucho más rápido. Entonces estas son las tres
formas en las que podemos representar los números
decimales y
solo vamos a usar un
doble para la altura. La altura de nuestra
esponja es de tres puntos, no
sé, tres pies, 4 “, algo así. Creo que eso estaría
bien. Ahora, el siguiente que quiero presentar es un
Bolen representado por bool ¿Esto lo que podría ser el booling? ¿Si nuestra
carta comercial es la primera adición? Entonces voy a poner
es la primera adición. Voy a decir verdad. Bob Esponja es una carta
coleccionable muy rara y es la primera adición,
así que va a ser verdad Ahora los tipos de datos booling pueden tener el valor true o
pueden tener el valor false Sólo uno de esos
dos valores es cierto. Si es sí o falso. No. Así es como usamos
boolings en C sharp Es cierto o falso.
Sólo dos objetos de valor. Si quieres una variable que pueda tener tres o cuatro valores, entonces no uses un booling Booling son para sólo dos valores. El último del que voy
a hablar ahora, hay montones de
tipos de datos en C Sharp, Podemos hacer fechas, horarios, varias cosas complicadas como listas y cosas así. Pero para ser honestos con
cadenas, enteros, valores
decimales como los dobles
boolings y caracteres, aquí podemos escribir prácticamente cualquier cosa,
mucho y
mucho software
con solo estos tipos de A lo mejor vamos a cubrir
más en el futuro. El último del que voy
a hablar son personajes representados
por Shah, aquí mismo Para esto, voy
a llamarlo grado. El grado de nuestra tarjeta,
¿es excelente? Entonces eso podría ser un o
es malo? Eso podría ser un. Entonces una tarjeta promedio podría ser
como cuando tomas un examen. Entonces nuestra calificación podría ser
algo así. Y esta es una muy buena tarjeta. Es primera edición de
calidad de menta darle una calificación de A. Cuando inicializas variables de
carácter, usamos comillas simples, aquí
usamos comillas simples,
no comillas dobles Visual studio hace
un buen trabajo aquí. Si olvidas las cotizaciones, probablemente te
dirá que
las necesitas o te dará un
error críptico como este Sí, así que ahora hemos declarado e inicializado
todas nuestras diversas variables con todos sus diferentes tipos Ahora solo quiero
sacarlos a la pantalla. puede ver que tienen la
línea verde debajo de cada una
ahora mismo cuando uso la edad aquí abajo. Mira esa línea verde
desaparecer menores de edad, y eso es porque ahora la
estamos usando ahora. Voy a poner uno por cada variable diferente aquí a través del poder de edición. Podemos ver aquí ahora
estamos sacando todos estos a la pantalla si
ejecutamos esta aplicación Ahora podemos ver todos nuestros diversos valores para
todas nuestras diferentes variables. Vemos el
nombre, el apellido, la edad, el peso, la estatura. Cierto porque es
primera edición y además es una muy
buena carta coleccionable.
7. 1-4. C # - un lenguaje fuertemente escrito estáticamente: Quiero hablar de dos
cosas ahora que hacer con C Sharp, ahora que entendemos
qué tipos de datos son. Ahora C Sharp es lo que se llama un lenguaje fuertemente mecanografiado
y también un lenguaje estáticamente
mecanografiado Hablemos de cuáles son
esos dos términos. Un lenguaje fuertemente escrito, eso significa que una vez que hemos
definido una variable llamada first name y le hemos dado la cadena de tipo de datos, tiene
que ser una cadena a
lo largo de toda su vida útil
de la aplicación No podemos, por ejemplo, tomar el nombre y luego darle un valor entero
porque no le va a gustar eso. Eso es porque es un lenguaje
fuertemente mecanografiado. Sin embargo, si usas un
lenguaje como Python, por ejemplo, puedes hacer esto, no
es ningún problema en absoluto. Eso es porque no es un lenguaje
fuertemente mecanografiado. En este caso, eso es lo que es un lenguaje
fuertemente mecanografiado. Una vez que has definido una cadena, le has dado un nombre único. Entonces no puedes introducir un tipo de datos
diferente aquí. No se puede decir, oh, ahora quiero decir que es verdad, Por ejemplo,
no va a funcionar. Te va a decir que ese es lenguaje
fuertemente mecanografiado
como C Sharp, el último es lo que se llama un lenguaje estáticamente mecanografiado Si cometemos un error que ver
con uno de estos tipos de datos, por ejemplo, tenemos nombre. Por lo tanto espera una
cadena entre comillas dobles, como aquí, si le damos un entero, se
va a quejar. Va a dar una
línea roja por debajo cuando. Cada vez que tenemos una línea
roja debajo, algo así como este error aquí, no
podemos compilar
la aplicación. No va a letras, no
va a letras. Por ejemplo, si
estás usando Windows, compila tu código en un archivo EXC y dáselo a un amigo para que lo ejecute.
No va a funcionar. Eso es porque estos errores
son capturados en tiempo de compilación. Y eso es lo que es un lenguaje estáticamente
mecanografiado. Si cometemos un error
como este, no
vamos
a descubrirlo en una fecha posterior cuando un usuario
esté utilizando el software. Esa es una
ventaja bastante buena de C Sharp y también lenguajes como C
plus plus, muy similares. Una vez que tenemos una cadena de tipo de datos, necesita un valor de cadena. Estos errores serán
capturados en tiempo de compilación. Y ahí es cuando pulsamos aquí este pequeño botón
verde de Reproducir. Eso es lo que es un lenguaje fuertemente
mecanografiado. Y también un lenguaje estáticamente
mecanografiado, C Sharp es ambos de estos
8. 1-5. Trabajar con cuerdas y subcuerdas: Bien, veamos
cómo podemos trabajar con algunas
variables de tipo cadena en C sharp. Aquí tenemos una aplicación
de muestra. Solo tenemos
nombre, apellido, y estamos dando salida a ambos de esos dos nuestra ventana de consola Ahora bien, ¿cómo podemos
unir dos cadenas juntas? Tengo un nombre de variable, un apellido de variable. En este momento los pone por separado
en dos líneas distintas. Pero, ¿cómo puedo unir
estos juntos? Lo que podemos hacer aquí, lo que
se llama concatenar
dos cadenas, y eso es solo una forma elegante
de decir que las unan. Concatenación, podría
ser como concat para abreviar. Estas son palabras que
vas a escuchar quizás en el futuro si continúas
tu C agudo viaje. Veamos unir estas
dos cuerdas juntas. Lo que voy a
hacer, voy a usar lo que se llama operador. Para que puedas ver este plus aquí. Y lo que eso
hace, solo toma esto, esta cuerda y los
une . Muy sencillo, ¿no? Entonces ahora ejecutamos la aplicación. Podemos ver que tenemos Bob Esponja, pantalón
cuadrado en una línea. Pero se puede ver que no hay ningún espacio en
blanco entre aquí. Entonces veamos agregar eso. Lo que podemos hacer aquí es agregar otra cadena y
usar el símbolo más. Nuevamente, lo que estamos haciendo aquí, estamos tomando la primera
variable, el nombre de pila. Lo estamos concatenando,
uniéndolo a este espacio vacío y, que también es una Y luego unirlo
al apellido, que aquí es una variable. Ahora bien, esto no es una variable, no
necesitamos variables aquí. Fácilmente podríamos hacer esto, y es exactamente lo mismo. De esa manera ni siquiera estamos
usando esa variable, pero la salida
será exactamente la misma. Así es como podemos unir
dos cuerdas juntas. Solo para que entiendas completamente, incluso
podemos crear
una variable aquí y podemos hacer nombre
más apellido. Entonces podemos poner el nombre completo aquí y vamos a tener
exactamente el mismo resultado. No olvidemos nuestro espacio en
blanco aquí. Se ve presentable y vamos a ejecutar
la aplicación Puedes ver aquí tenemos
exactamente el mismo resultado. Solo estamos usando una variable
aquí llamada nombre completo. Y eso es solo
sumarlos juntos, concatinarlos, espacios en
blanco Así es como podemos unir
dos cadenas juntas, Muy simple, subcadenas. ¿Qué es una subcadena? Ahora, una subcadena es solo una de muchas cosas diferentes que puedes
hacer con cuerdas en Do sharp He aquí un ejemplo. Aquí
tenemos una variable llamada name. Tiene Bob esponja
libra cuadrada establece el valor. Y estamos afuera poniéndolo a
la pantalla ahora, por ejemplo, digamos que quiero extraer
cierta parte de esta cadena. Quiero extraer de ella la
palabra esponja. No quiero el
resto de estas cosas, solo
quiero esta
parte de aquí. Ahora lo que podemos hacer,
podemos usar algo llamado método de subcadena para extraer
una porción de nuestra cadena Y eso es lo que es una subcadena. Es parte de una cuerda. Podría tomar esto,
podría tomar esto. Podría tomar lo que quiera. Incluso podría tomar una
letra si quisiera. Veamos cómo podemos usar
realmente una subcadena. Lo que voy a hacer, quiero
extraer esponja, la variable. Podemos llamarlo como queremos, llamémoslo esponja. ¿Por qué no? Queremos inicializar esponja
así que usamos nuestro signo igual. Cuando trabajamos con una variable, lo que podemos hacer es poner el
nombre de la variable aquí, que es nombre, en
este caso cuando usamos un punto o un dardo, como
quieras llamarlo. Después tenemos todas estas
cosas diferentes que podemos hacer con él. Algunos de
los comunes siempre están en la cima con esta
estrella negra junto a ellos. Uno de ellos es la subcadena. Podemos hacer muchas
cosas que podemos reemplazar. Podemos bajar los caracteres. Podemos dividirlo, muchas cosas
diferentes que podemos hacer. Substring es lo
que queremos usar. Podemos hacer doble clic en esto cuando
abrimos paréntesis aquí, tenemos algunas opciones
que podemos hacer con él Ahora, voy a
hablar de estas cosas
mucho más tarde cuando
hable de métodos. Pero en su mayor parte, sólo
voy a poner dos cosas aquí. Y eso es lo
que quiero hacer aquí. Ahora, en C en punto, todo empieza en cero. El índice está en cero. Esta cadena aquí,
este carácter aquí, esa es la posición cero. La P es la posición 123. Todo empieza en cero. Recuerda que avanzar es posición cero del
personaje de nuestro pantalón cuadrado
Bob Esponja de hilo. Entonces el primer valor aquí es cero porque queremos
comenzar en la posición cero. Entonces el siguiente valor es cuántas letras
quieres extraer de
la esponja de cuerda 12345.
En realidad son seis. Ahora queremos extraer aquí mismo
la
esponja de los primeros seis caracteres . Estos son los valores
que ponemos aquí. Ahora bien, si esto te resulta confuso, volvamos a donde
hablamos de consola de línea derecha. Teníamos la línea derecha de consola y
abrimos los paréntesis aquí Queremos poner nuestra variable
en la ventana negra. Ahora subcadena, en este ejemplo, queremos darle dos valores Y cuando le damos dos valores, los separamos con una
coma como así queremos el primer carácter
y queremos contar seis caracteres hacia adelante los cuales
debemos extraer esponja Ahora queremos poner esponja en la ventana de
nuestra consola para que podamos ver
realmente el resultado. Vamos a compilar nuestra aplicación. Podemos ver con
esponja de salida aquí mismo. Así es muy simplista
como funciona la subcadena. Si queremos extraer,
digamos, Bob por ejemplo, entonces iniciamos una posición seis y contamos tres
caracteres hacia adelante. Entonces podemos ver
que hemos extraído a Bob,
así es como funciona una subcadena Otra cosa que podemos hacer es
lo que se llama un reemplazo. Tenemos pantalones
cuadrados Bob Esponja aquí. Digamos que queremos sustituir a
Bob Esponja por otra cosa, digamos Patrick o
algo así. Vamos a crear una nueva variable. Lo llamaremos Pat para Patrick. No importa
cómo lo llamemos. Estamos trabajando con nuestra cadena de nombres aquí.
Vamos a dejar esto. Cuando presionamos de nuevo el punto, obtenemos todas estas cosas que podemos hacer con él y vamos a doble clic, reemplazar
con, reemplazar. Podemos reemplazar cualquier cosa
por cualquier otra cosa. Lo que quiero hacer, quiero sustituir
a Bob Esponja. Quiero darle el
nuevo valor, Patrick. Siempre termina con un punto y coma. Lo que eso va a
hacer es tomar el nombre, todo dentro del nombre,
está tomando todo esto, queremos reemplazar
cada ocurrencia con tipo
Bob Esponja que queremos
reemplazarlo con Patrick Entonces el resultado de esa
operación se almacena en Pat. Entonces podemos poner aquí a Pat. Si ejecutamos la aplicación, ya
podemos ver que dice
Patrick pantalón cuadrado. Eso es porque estamos reemplazando cada ocurrencia de Bob
Esponja por Patrick. Y cuando digo cada ocurrencia, probemos esto, ejecutemos
la aplicación. Se reemplazó cada ocurrencia de Bob Esponja por Patrick. Así es como
funciona el reemplazo en C Sharp. Y nuevamente,
no es necesario almacenar el resultado de este cálculo
en una variable completamente nueva. Podemos atajar eso, solo ponlo ahí, y eso
va a funcionar igualmente bien. Se puede ver Patrick libras
cuadradas Patrick. Patricio Patricio. Se puede ver así es como
funciona el reemplazo cuando se trata de cuerdas. Otra cosa que podemos hacer con las cuerdas es calcular la
longitud de la cuerda. Ese es muy sencillo. Aquí tengo una variable
llamada ejemplo. Esto es todo dentro de
esa variable para trabajar. Ejemplo, puse un pequeño
dardo después y
tecleo longitud para
que esto sea más rápido. Puedes hacer doble clic en
esto o puedes presionar la tecla tab
en el teclado. Eso podría ser mucho más rápido para que introduzcas estos valores en el futuro cuando
compile la aplicación. Ahora podemos ver que esta frase aquí tiene
44 caracteres de longitud. Eso es bastante útil
cuando usas subcadenas para extraer ciertas
cosas de una subcadena Hablemos de otro
método llamado índice de. Ahora lo que índice de hace es
si especificas una palabra
como Bob Esponja, en
realidad te dirá el índice de dónde está
esta en la cadena. En lugar de contar
1-234-567-8910, posición de
carácter
22, por ejemplo, no
tenemos que contar, en
realidad podemos usar Si pongo índice, entonces quiero poner, por ejemplo, Bob Esponja. Eso será entre comillas dobles, porque Bob Esponja es una cuerda, queremos almacenar
el resultado de esto. Ahora bien, si pasamos el cursor sobre el índice de, se
puede ver por aquí
junto a este cubo rosa, dice t Eso significa que
el resultado de esto
será un entero s
definir un nuevo entero. será un entero s
definir un nuevo entero Yo sólo lo llamaré índice. Entonces voy a sacar
el índice a la ventana. Ejecutemos esto muy rápido. Se puede ver al parecer Bob
Esponja es un personaje posición 22 aquí. Eso son 22 caracteres en índice de es otro método que es bastante útil para obtener el índice de
cualquier palabra que le gustaría. Podrías poner, por ejemplo,
simplemente algo así. Si ejecutamos eso, obtiene la primera ocurrencia de la
cual es esta de aquí, 012, esa es la
primera ocurrencia De nuevo, tiene muchas cosas
diferentes que puedes hacer con índice de,
pero ese es un ejemplo.
9. 1-6. Trabajar con números: Bien,
veamos algunos ejemplos de trabajar con
números en C sharp. Vamos a ver
multiplicación, suma,
resta, división,
todas esas cosas buenas Así que vamos a ir. Echemos un vistazo a
un ejemplo adicional. Entonces, cómo sumamos números en agudo. Tenemos una
aplicación de muestra aquí. Solo estamos definiendo una variable, poniéndola a cero y
emitiéndola a la pantalla Así que en realidad no
está pasando mucho aquí. Vamos a usar nuestra variable. Sólo voy a
hacer cinco más cuatro, lo que sabemos equivale a nueve. Yo sólo voy a
ejecutar el programa y obtenemos nueve es
la salida ahí. La adición es muy simple, puedes seguir adelante con esto, etcétera. Muy fácil. Lo mismo otra vez con la resta, podemos
hacer prácticamente lo mismo Cinco menos seis es uno negativo. Se puede ver la resta
también muy fácil. Nuevamente, puedes hacer
esto, mezclarlos a los dos. Realmente no importa. Esto va a resolverlo
por ti. Multiplicación. Hagamos tres multiplicados por cuatro para multiplicar
números en C agudo. Usa este astérix aquí, la estrellita, y como
resultado deberíamos conseguir 12 Ahí de nuevo, podemos combinar la multiplicación con la
suma y la resta,
tal como lo haces en
matemáticas, por ejemplo Ahora aquí es donde hay un par de
trampas Con división, el signo de división es un delantero, hagamos un 13/3 fácil Vamos a
ejecutar la aplicación es Porque hay uno, hay
13.3 El resultado es uno. Así es como dividimos
los números sin embargo. ¿Bien? Gotcha. El número
uno es dividir por cero. En realidad no podemos
dividir por cero. En realidad ya se puede ver. De todas formas, en
el pasado hace unos años, si hicieras tres por cero, podrías ejecutar la aplicación
y obtendrías un error. Porque no es un cálculo realista,
no puede resolverlo. Ahora tenemos una
línea roja debajo, y cuando pasamos el cursor sobre
eso, dice división
por cero constante En realidad no
nos permitirá ejecutar nuestro programa, sino como el
resultado de la variable es cero, alimentemos eso
ahí y ejecutemos el programa. Y nuevamente, se errores
como debería. El primer error que captamos en tiempo de
compilación cuando
intentamos ejecutar la aplicación, porque aquí estamos usando cero, nos está diciendo que no pudimos
ejecutar la aplicación. Pero cuando le di una
variable que es resultado, que también es igual a cero, podemos engañarla
para poder ejecutar el programa, pero aun así obtenemos ese error intentado dividir por
cero, lo cual no podemos hacer. Entonces eso es algo que siempre
debes tener en cuenta a la hora de trabajar
con división. Nunca debes dividir por cero. Cuando hablamos de
declaraciones if en el futuro, voy a mostrar cómo
puedes proteger tu programa para evitar
dividir por cero y el otro gotcha
con respecto a división es usar números
decimales Veamos un ejemplo de
número decimal. Aquí vamos a usar un tipo de datos
doble, y solo vamos a
inicializarlo a cero Ahora solo hagamos un ejemplo. Hagamos 3.45 0.6 que
debería funcionar bien. Puedes ver aquí,
aquí está el resultado que está en formato decimal. Sin embargo, si decimos 200/3 este no es un número
entero entero, tendrá un lugar
decimal en
él Sin embargo, cuando ejecutamos
la aplicación, puedes ver que en realidad está
haciendo algunos redondeos aquí Es, creo, hasta el entero más cercano,
que es 66. Sin embargo, si agregamos 0.0 al final de estos
y ejecutamos la aplicación, puedes ver que esta es
la verdadera respuesta aquí, 66.666 repitiendo Entonces está redondeando a siete. Esto es algo a lo que debes prestar atención al trabajar
con números decimales. C sharp hará una suposición porque si tienes
dos números aquí, este 200 es un entero, tres es un entero. Ninguno de
estos de decimales, es sólo el resultado
que es un decimal Lo que
hace C sharp es decir, oh, oye, aquí hay
un entero. Oh, oye aquí hay un entero. Te voy a dar el
resultado como un entero. Eso es un poco molesto. Lo que hay que hacer es cambiar al
menos uno de estos
a un número decimal. Cuando haces eso, puedes ver que aquí obtenemos el verdadero resultado. Eso es algo que realmente
debes tener en cuenta hora de trabajar con la
división de números decimales. El siguiente operador que te voy a mostrar es el operador de
módulo. Vamos a poner esto de
nuevo como un entero. Ahora bien, lo que hace el
operador de módulo, te da el resto
de un cálculo. Déjame hacer un ejemplo muy rápido. El módulo está representado
por una marca porcentual. Aquí, lo que hace esto, dice, ¿cuántas veces
tres entran en seis? Bueno, tres va a seis dos veces y luego no
queda nada. El resultado de esto será cero porque es el
resto de esto. De nuevo, si hago 22
entra en 63 veces, perfectamente otra vez, no
hay resto. No obstante, si pongo cuatro aquí, cuatro va a seis una vez. No obstante, queda un
resto de dos, por lo que este será el resultado dos. Qué módulo hace, te da el resto de un cálculo. Después de dividir esta en
ésta, 14 entra en seis una vez
con un resto de dos. Si ejecuto la
aplicación, obtenemos dos, al
igual que el
primer ejemplo, tres va a seis dos veces
y no hay resto, el resultado debería ser cero. El módulo es bastante útil
cuando queremos saber si un número va exactamente
a otro número. Si el resultado es cero, sabemos que es perfectamente
divisible por ese número Eso es lo que es el módulo, o módulo como
quieras llamarlo. Y está representado por un solo porcentaje,
así como así. Ahora quiero
hablar del orden de las operaciones cuando se trabaja
con multiplicación, suma, resta,
todas esas cosas buenas Déjame mostrarte un ejemplo. Tengo resultado, que es nuestra variable cinco multiplicada por cuatro -2/7 quiero
sumar sobre el resultado
de cinco más uno Echemos un
vistazo a este ejemplo. Si has hecho muchas
matemáticas en el pasado, entonces tal vez puedas
saltarte esta sección. Puede ser bastante
obvio para usted, pero C sharp funciona
prácticamente exactamente igual que
las matemáticas
en el mundo real. Si alguna vez has visto estas cosas en Facebook o Instagram, y dicen, oh, ¿cuál
es la respuesta de esto? Y la gente está dando todas
las respuestas equivocadas
porque no entienden
el orden de las operaciones. Aquí tenemos esta cosa en matemáticas llamada masa de
puja o Bodmass Déjame mostrarte eso ahora. Oferta masiva, algunas personas lo
llaman Bodmass. Realmente no importa.
La única diferencia es el yo aquí y el o aquí. Pero significan lo mismo. Entonces lo primero son los brackets. Si tenemos un
cálculo como este, cualquier cosa dentro de los
paréntesis sucede primero. Cinco más uno. Eso pasa
primero, que son seis. Y entonces podemos quitar eso y eso se sustituye por seis. Lo siguiente que
sucede es el yo o el o que es al poder de, o la raíz cuadrada de. No tenemos nada de eso aquí, así que podemos saltarnos eso. Lo siguiente es la división. La división pasa a continuación, y eso es 2/7 Ahora bien, no
estoy seguro de qué es 2/7,
es un número decimal, pero eso sucederá a Este cálculo aquí. Lo siguiente que
sucede es la multiplicación. Esto de aquí mismo,
esto se
resolverá los próximos cinco multiplicados
por cuatro, que es 20. Entonces cualquier adición después de eso, entonces el resultado de eso se
sumará a seis
seguido de resta a
lo último que sucede es este de aquí Ese es el orden en el que se calcula
esto. No pasa
de izquierda a derecha. Cinco veces cuatro comida para llevar dos. Siempre sucede
en el orden de
los símbolos, al
igual que las matemáticas. Por ejemplo, si
ejecutamos el programa, bueno, todo se puede resolver. Para nosotros, el resultado es 26. Ese es el orden de las operaciones. Algo solo a tener en cuenta hora de trabajar con
esto en C sharp. Lo último de lo que voy a
hablar que ver con
trabajar con números, es dos a la potencia de
dos, que es cuatro. Si no estás muy
familiarizado con las matemáticas, el poder de solo significa
cuántas veces se
multiplica por sí mismo. Dos al poder de
dos es lo
mismo que decir dos multiplicado
por 22 al poder de tres básicamente significa dos por
22 multiplicado por dos
multiplicado por dos. Nuevamente, de eso es lo que tiene el poder. La razón por la
que te estoy mostrando el poder de es porque el
poder de no
tiene un símbolo como la
multiplicación o la resta, tenemos que utilizar lo que
se llama el espacio de nombres matemáticos Ahora veamos eso.
Ahora bien, si digo resultado, que es la variable que
hemos definido aquí, entonces digo matemáticas MAT H con mayúscula M. Cuando presiono
el símbolo de punto aquí, hay muchas
cosas diferentes que podemos hacer. Todos estos están integrados en
nuestra biblioteca C sharp aquí, y podemos usar cualquiera de estos. Mira, el letrero, autos, bronceado,
trunca, logaritmo,
todas estas Pero lo que sólo
voy a usar es el poder, que está representado por POW Si abrimos corchetes aquí, es pedir nuestro
primer número aquí abajo, dice un número de punto
flotante de doble precisión para ser elevado a una potencia. Digamos que queremos
mirar dos al poder de dos. Es pedir un doble, que es un decimal. Voy a poner 2.0 porque lo quiere
en formato decimal. Quiero volver a elevarlo
al poder de dos, terminarlo con punto y coma. Dos al poder de
dos es decir dos, multiplicar por dos. La
respuesta debe ser cuatro. Puedes ver aquí
la respuesta es cuatro. Si queremos hacer dos
al poder de tres, deberían
ser ocho. Se puede ver a dónde va esto, 163264128. Ahí vas. Así es como hacer el poder de, pero no sólo el poder de. De hecho, puedes
utilizar muchas
cosas en esta clase de matemáticas aquí, todas las cosas diferentes aquí. Pero ese es un ejemplo de
cómo usar el poder de, y trabajar con
los números en tienda.
10. 1-7. Obtener información del usuario: Echemos un vistazo a la
interacción con nuestro software. En su mayor parte, cuando
ejecutamos nuestra aplicación, hasta el momento solo podemos ver
los resultados en la pantalla. Pero ahora quiero que
interactúes con tu software. Se le puede dar
alguna información. Por ejemplo, echemos
un vistazo a cómo hacer esto
con una aplicación de consola. En este momento tenemos una aplicación de
muestra, es solo imprimir cuál es
tu nombre a la pantalla. Cuando ejecuto eso, es sólo
decir, ¿cuál es tu nombre? Quiero poder escribir mi nombre aquí, por
ejemplo, Robert. Y luego cuando le pegué a Enter, quiero que diga hola Robert, por ejemplo.
Algo así. Podemos utilizar la
línea de lectura aquí mismo. Hasta el momento, solo hemos
usado esta línea solo para detener la aplicación, por lo que nuestra ventana
no se cierra sobre nosotros. Porque recuerda, sin esto, la ventana simplemente desaparece
instantáneamente. Sin embargo, sí
tiene una función, lo que hace la línea de lectura. De hecho, captura
algunos aportes de nosotros. ¿Qué pasa si pasamos el
cursor sobre esto? En realidad te dice que
lee la siguiente línea de caracteres del flujo de entrada
estándar. Bastante complicado no es
Lo que esto básicamente hace es capturar nuestra entrada cuando
presionamos la tecla Enter
en el teclado. El resultado de eso
podemos almacenar en una cadena. Si pasamos por encima de esto,
puedes ver cadena aquí. Esto es lo que nos vuelve. Podemos definir una nueva variable. Lo llamaremos resultado.
Podríamos llamarlo entrada de usuario. Podemos llamarlo como
queramos. Lo que estamos haciendo
ahora, estamos obteniendo el resultado de esta operación
que es línea de lectura que agarra todo lo que
tecleemos ahí después de que
golpeamos enter y
lo almacena en esta variable aquí Entonces lo que quiero hacer es
saludar a cualquier
nombre que pongas aquí. Recuerda cómo
concateinar cuerdas. Tenemos nuestra primera
cadena aquí, hola. Las cadenas están encerradas
por comillas dobles. Entonces queremos
unir una cadena con el resultado de esta operación, que también es una cadena.
Vamos a hacer eso ahí. Queremos sonar
muy entusiastas. También vamos a hacer un signo de
exclamación. Estamos uniendo tres
cuerdas juntas. Hola, el signo de
exclamación, y el resultado, que es una variable
de cadena del resultado de la entrada
del usuario Ejecutemos esta aplicación. Ahora está diciendo
¿cuál es tu nombre? Voy a poner a Robert. Cuando golpeé Enter, no
tenemos nada que sea porque no le
hemos dicho que mantenga abierta la ventana de la consola. Volvamos a poner eso ahí
abajo otra vez. Pulsa el botón de reproducción,
escribe nuestro nombre, Hit, y ahora está
diciendo hola Robert. Es bastante fácil, ¿no? Y así es como capturar la entrada
del usuario en una aplicación de
consola.
11. 1-8. EJERCICIO - el juego del multiplicador de números: Bien, veamos ahora
un ejemplo rápido. Un poco de
aplicación práctica para poner a prueba tus conocimientos de trabajar
con números en C Sharp. También voy a poner a prueba algunos de los conocimientos
que has aprendido hasta ahora. Y voy a introducir el concepto de
convertir tipos de datos, convertir una cadena
a un entero. Echemos un vistazo a esto ahora. Entonces, lo que vamos
a hacer, vamos a construir una calculadora de muestra, pero nuestra calculadora sólo va a multiplicar dos
números juntos. No es una
calculadora muy elegante. Empecemos por aquí. Vamos a dar la bienvenida
a nuestro alicate de números. Queremos decirle al
usuario qué es esto. Vamos a decir, oh, oye, bienvenidos a nuestro multiplicador
de números. Entonces vamos a
pedir su primer número. Este es el primer
número, van a multiplicarse por otro número. ¿Cuál es tu primer número? Estamos preguntando al usuario cuál es
su primer número. Para captar la entrada del usuario, utilizamos la línea de lectura de consola. Entonces el resultado de esto
necesitamos almacenar en una variable, llamaremos a ese primer número. Ahora el primer número contendrá
el primer número del usuario. Ahora inmediatamente ves esta línea roja debajo de la línea de lectura de
consola. Si pasamos el mouse sobre
eso podemos ver aquí no podemos convertir
implícitamente
type string Lo que está diciendo es, bueno, mira leer la línea te da una cadena porque estamos
pidiendo la entrada del usuario. Y podrían poner una frase, podrían poner muchas letras. No sabemos qué
va a poner el usuario aquí,
básicamente, pero en realidad
queremos un entero de esto. El usuario podría escribir hola y estamos tratando de poner
hola en un entero, así que ahí va a
haber un problema. Lo que queremos hacer es
usar la biblioteca de conversión. Lo que es, si escribe
convertir a una C mayúscula, presiona periodo ahí, obtenemos muchas opciones
que podemos hacer aquí. ¿Qué hace convert?
Nos da muchos métodos
diferentes para
convertir tipos de datos. Lo que queremos hacer es convertir una cadena porque esa es
la entrada del usuario. Queremos el resultado
como un entero, que será nuestro primer número. Cuando presiono aquí, lo que quiero son dos int int 32. Quizás aún no lo he
explicado, pero un INT estándar
también se considera int 32. Es un entero de 32 bits. Puede tener un
entero más largo que admita más dígitos o incluso
un entero más pequeño. Int 32 es un
entero estándar en C Sharp. Cuando abro paréntesis en esto, es pedir un valor de cadena Esta es la cadena
que va a convertir
a un entero y
nuestro valor de cadena, bueno ese es el resultado
de la entrada del usuario. Esa es la línea roja de la consola. Vamos a poner eso
ahí. Cerraremos nuestros corchetes y
pondremos un colon sami. Ahora se puede ver que la línea
roja se ha ido. Del mismo modo, podrías simplemente almacenar el resultado de esto
en una nueva variable, una variable de cadena,
y ponerla aquí. Realmente no importa, pero lo
estamos haciendo todo en una línea. Ahora lo que queremos hacer
a continuación es tomar el segundo número del
usuario, el segundo número. Esa será una nueva variable
llamada segundo número. Queremos preguntarle al usuario cuál es
su segundo número. Ahora tenemos el primer número del
usuario en esta variable entera aquí, y el
segundo número del usuario aquí. Ahora queremos el resultado de eso,
ese será el resultado del cálculo primer número,
recordemos que
la multiplicación es el punto y coma del segundo
número astérix Entonces queremos decirle
al usuario cuál
es el resultado. Hagámoslo. Vamos a decir que
el resultado es, entonces vamos a concatenar las cadenas juntas,
que es Entonces queremos esto para que la
ventana no se cierre. Ejecutemos la aplicación aquí. Mira, bienvenido a nuestro multiplicador
de números. ¿Cuál es tu primer número? ¿Por qué no número cuatro? ¿Cuál
es tu segundo número? ¿Qué tal el número cinco?
Y eso debería ser igual a 20. Dice que el resultado es 20. Bastante genial, ¿no? Nuevamente, podemos usar diferentes
números ahí dentro, pero esa es una visión muy
simplista de cómo podemos obtener la entrada del usuario
usando la línea de lectura de consola, cómo podemos convertir tipos de datos Así que estamos convirtiendo una cadena
que es la entrada del usuario, un entero que es
nuestra variable aquí. Entonces cuando multiplicamos
nuestros enteros juntos, obtenemos el resultado y solo le
estamos diciendo
al usuario el resultado Esa es una forma muy simplista de trabajar con
números en C. Sharp.
12. 2-1. Métodos: Ahora quiero
hablar de métodos en Sharp. De hecho, hemos usado
muchos métodos hasta ahora. Por ejemplo, la
línea derecha es un método, línea de
lectura es un método para el poder en el
ayudante matemático era un método. Ahora vamos a
crear nuestro propio método. Al crear
métodos en C Sharp, todos
tienen un propósito. Si tienes un trabajo
que suele hacerse más de una vez o
un trabajo complicado, puedes ponerlo en
un método separado. Cuando digo método, aquí hay
un ejemplo de un método aquí. Este es el método principal. Todo dentro de este método aquí está dentro de
estas llaves Aquí, el método principal es un método especial cuando nuestro software se
ejecuta por defecto. El.NET Framework, que es todo lo que
se construye alrededor de C Sharp, esto busca un
método especial llamado main, y tiene que tener este nombre Y todos los nombres de métodos son únicos, por lo que no pueden tener el mismo
nombre, al igual que las variables. Una vez que se encuentra el método principal, ejecuta
todo el código dentro de
estas dos llaves curley Aquí, el único código que tenemos
son dos líneas aquí mismo. Cuando ejecutamos la aplicación, podemos ver Hello World. Y la siguiente línea nos mantiene abierta
esta ventana. Ahora veamos la creación un método completamente nuevo
donde diga vacío estático. Voy a cubrir eso en
un tutorial posterior. Por ahora, vamos a
mantenerlo muy sencillo. Después escribimos vacío estático. En este caso, queremos
darle un nombre al método. Ahora recuerden que dije que los métodos deben tener un propósito para mantener
las cosas organizadas. Generalmente, deben
tener un propósito. Nuestro nuevo método, lo que
quiero que haga, su propósito, su trabajo es
saludar mundo al usuario. Eso es lo único
que va a hacer. Ahora sé que es función, lo que pretende hacer. Puedo llamar a mi método con un nombre que
tenga sentido a las palabras. Voy a
llamarlo, di hola mundo. Ese va a ser el nombre de
nuestro método. Ahora la siguiente sección son
lo que se llama parámetros. Voy a
hablar de esos más tarde. Voy a
mantenerlo sencillo por ahora. Haga un paréntesis abierto
y un paréntesis cerrado. A continuación, abra el curcorsé
y cierre el curcorsé. Así como así, se puede
ver que puede imitar esto. Todo nuestro código para nuestro
método vivirá aquí en esta sección resaltada
entre este y este. Toda nuestra funcionalidad para
este método vive aquí. Queremos saludar
mundo al usuario. Bueno, ya sabemos cómo hacerlo, lo
hemos cubierto antes. Esa es esta línea
de código de aquí mismo. Nuestro método decir hola mundo. Su trabajo es decir hola mundo. Entonces eso va a imprimir esto
a la ventana negra fácil. Ahora mismo cuando
ejecutamos nuestro software, bueno, en realidad no
va a hacer nada. ¿Por qué es eso? Eso se debe a el método principal se
ejecuta por defecto. Entonces esta sección aquí, y esto es
lo único que se va
a ejecutar desde nuestro método principal. No sabemos nada de esto. Lo que tenemos que hacer
aquí es decir, oh, oye, ¿
puedes ejecutar nuestro método para
poder ejecutar nuestro método?
Nosotros solo hacemos eso. Cuando lanzamos la aplicación, se ejecuta el método principal. Se baja, se ejecuta esta
línea. Cuando se ejecuta esta línea, el código entra aquí. Esta línea se ejecuta. El método
ha terminado su trabajo. Vuelve a salir hasta aquí, y luego remata
con esta sección de aquí. Cuando se tiene un
método, se apaga, luego vuelve a entrar,
y continúa. Si ejecutamos la aplicación, ahora podemos ver Hello world. Eso es porque
ahora estamos llamando a nuestro método. Solo para recapitular si
fui demasiado rápido o es complicado
sin esta línea, nuestro método
nunca se ejecutará Cuando ejecutamos nuestro software, podemos crear muchos de ellos. 3,000 5,000 1,000 Nuevamente, todos
deben tener
un nombre único. Pero cuando ejecutemos el software, nada de esto va a ser ejecutado. Y eso es porque en realidad
no le estamos diciendo a
la computadora que realmente los
ejecute para ejecutar un método. Nuevamente, hacemos esto de nuevo si
queremos ejecutar este método, muy similar, etcétera Así es como ejecutar el método, así es como
definir el método. Y esa es una
visión muy simplista de cómo podemos configurar un
método muy sencillo en C sharp
13. 2-2. Parámetros de métodos: Ahora quiero hablar de los parámetros del
método. Un parámetro es solo
una forma elegante de darle cierta
información a un método. Aquí tienes. Aquí hay alguna información.
Trabajar con él. Vamos a usar un ejemplo. He aquí un ejemplo. Sólo le estamos diciendo hola mundo
al usuario. Muy sencillo. Pero, ¿y si queremos que este
método diga hola John, hola Harry, o hola Roberto? Estos nombres son algo que
el usuario nos puede proporcionar. He aquí un ejemplo. Vamos a hacerle una pregunta al usuario. Vamos a decir,
¿cuál es tu nombre? Cuál es tu nombre. Y luego queremos
obtener la entrada del usuario
que es la línea de lectura de puntos de consola. Así es como obtenemos
la entrada del usuario. Y almacenamos esto en una cadena. Sólo voy a llamarlo nombre, preguntando por el nombre del usuario. El usuario escribe alguna
información y estamos metiendo en
una variable llamada name Ahora bien, nuestro método aquí, quiero saludar, y luego quiero que diga
el resultado de esta variable, que va a
ser el nombre del usuario. No sabemos qué es eso. El usuario puede escribir
lo que quiera. Ahora, se cambia el trabajo de este
método. No quiero que
diga hola mundo. Quiero que le diga
hola al usuario. Ahora voy a decir hola usuario. Su trabajo ha cambiado cuando
llamé al método. Nuevamente, tenemos que asegurarnos de
que coincida aquí. Ya no es
decir hola mundo. Quiero que le diga hola
al nombre del usuario. Esa es nuestra variable llamada name. Sin embargo, mira puedes ver que
hay una línea roja debajo aquí. Y eso es porque nuestro método aquí está aislado
de este método. No
sabe de esta variable porque esta se ha
definido dentro de este método, este método,
en realidad no lo sabe. Así es como podemos usar parámetros
para resolver este problema. Qué parámetro es, podemos definirlos
dentro de estos paréntesis. Aquí mismo, vamos
a escribir el nombre de cadena. Ahora se puede ver que esta línea
roja se ha ido. Cada parámetro que
pones en un método aquí va dentro de
estos corchetes abiertos, puedes ver este método principal. Ahora esta sección de aquí mismo, bueno que tiene un parámetro, ha tenido un
parámetro todo el tiempo. Nuevamente, cuando definimos
un método aquí, podemos agregar nuestros propios parámetros. He agregado lo que se llama un parámetro y
se llama name, es una cadena de tipo. Ahora, dentro de este método, estamos usando esta variable, este parámetro, cuando
llamamos a nuestro método desde
el método main. Ya puedes ver que aquí hay
una línea roja. Cuando pasamos el cursor sobre
eso con nuestro ratón, se
puede ver que no
hay argumento Ahora, argumento es
sinónimo de parámetro. Es
lo mismo. No hay ningún parámetro dado que corresponda al nombre del parámetro
requerido. Básicamente es decir, ahora
este método necesita una cadena. Ya no podemos llamarlo
así. Lo que hacemos, tomamos
nuestra variable de nombre, que es el resultado
de la entrada del usuario, y la ponemos ahí. Y ahora puedes ver que estamos recopilando la información del
usuario. Estamos dando la información de este
usuario a nuestro nuevo método llamado
say, hello user. Entonces le estamos dando
el nombre del usuario. Entonces el código entra aquí. Nombre ahora es igual al valor
que se le está pasando. Y ese es nuestro parámetro. Ahora estamos usando nuestro parámetro sacándolo a
la ventana negra Entonces
vuelve a salir la ejecución del código. Y luego estamos manteniendo
la ventana abierta otra vez, solo para que esto no sea confuso. Podríamos llamar a esto como
queramos. Podríamos decir nombre del usuario. Podríamos llamarlo sándwich de jamón. No importa. Aquí se puede
ver la línea roja, porque tiene que ser la misma. Pero puedes ver aquí, esto
no tiene una línea roja. Y eso es porque
en realidad lo estamos definiendo aquí mismo. A pesar de que el valor
entra en el método aquí, cuando lleguemos aquí, podemos llamarlo como
queramos. Seguirá teniendo este valor, pero no necesita ser
el mismo nombre, así. No necesita ser así con
el mismo nombre exacto. Puede ser, pero
no tiene por qué serlo. Eso es algo que
debes tener en cuenta. Cuando se pasa el parámetro, el valor se pasa adentro,
está redefiniendo una variable completamente
nueva aquí Pero con este valor, espero que tenga sentido cuando
ejecutemos la aplicación. Ahora estamos diciendo,
¿cuál es tu nombre? Roberto. Ahora puedes ver
que dice hola Roberto. Podemos ejecutar esto de nuevo. Podemos saludar Henry. Así funcionan los parámetros
en una vista muy sencilla. Una última cosa, no tenemos que
tener un parámetro.
Podemos tener mucho. Podríamos tener otro de
un tipo diferente como la
edad, que es un entero. Ahora quiero preguntar
la edad del usuario. ¿Cuál es tu edad? Recuerda, la edad es un número entero
porque es un número. Yo sólo lo llamaré edad. Ahora tenemos la
línea roja porque esto da una cadena y queremos
ponerla en un entero, que no va a funcionar, pero ya lo cubrimos antes. Vamos a usar,
queremos convertirlo
a un entero que es de 32 bits y luego poner los paréntesis
alrededor de todo Ahora hemos convertido la cadena del usuario a un entero. Lo estamos poniendo en una variable
entera llamada age. Ahora tenemos de nuevo nuestra línea roja, eso es porque tenemos dos
parámetros en nuestro método. Ahora, nombra una edad. Cuando pasamos el cursor sobre
esta línea roja, se
puede ver que ahora requiere
una cadena y un entero Cuando llamamos a este método, necesitamos agregar esta
información aquí, y podemos usar una coma Ahora incluso es preguntar, incluso
nos está diciendo lo que necesitamos. Edad, tomamos nuestra
edad, ponla aquí. Ahora tenemos un método
con dos parámetros. Y le estamos pasando dos
parámetros. Ahora no estamos haciendo
nada con él. Hagamos algo con él. Vamos a decir que la edad es la edad ahora cuando
ejecutamos el software. Hagámoslo.
¿Cuál es tu nombre? Harry. ¿Cuál es tu edad? Tengo 67 años. Hola Harry. Tu edad es de 67 años. Nuevamente, podemos tener diez
parámetros si queremos. Podríamos tener diferentes tipos de
datos en B, todo tipo de cosas diferentes. Nuevamente, si quieres agregar más, es solo otra y
cómo las pasas. Nuevamente, usa A aquí. Así es como los parámetros funcionan generalmente con
métodos en C. Sharp.
14. 2-3. Devoluciones de métodos: Hablemos de recuperar información
de un método. Para ello,
utilizamos la palabra clave return. Veamos cómo devolver
la información de un método. Tenemos una
aplicación de muestra aquí. Es pedir el nombre del usuario. Es almacenar el
nombre del usuario en una variable, luego es
saludar al usuario. Lo que quiero hacer ahora es
crear un método cuyo trabajo
sea pedir el nombre del usuario y obtener
el nombre del usuario y
devolvérnoslo. Eso es lo que queremos hacer.
Ahora, para hacer eso, vamos a
crear un nuevo método. La forma más
fácil es copiar este, eliminar todo lo que hay fuera de él y darle un nombre único. Su trabajo es
pedir el nombre de un usuario. Sabemos cómo hacerlo.
Lo tenemos justo aquí. Estamos pidiendo
el nombre del usuario y lo
estamos almacenando en
una variable aquí. Cuando antes hablábamos de
parámetros, así es como obtener
información en un método. Los definimos aquí y
pasamos información de principal. Sin embargo,
recuperar la información de main, eso es lo que estamos
viendo en este momento, y eso se llama
la palabra clave return. Estamos
devolviendo información de un método, así que podemos usarla aquí. Cuando lanzamos nuestra aplicación, vamos a
pedir el nombre de un usuario. Obtenemos el nombre del usuario, lo
ponemos en la variable. Ahora tenemos que volver a tirar el nombre del
usuario de aquí y luego
saludarles. Ahora mismo, no podemos
hacer eso porque no entiende lo que significa
esta variable, porque está definida
en nuestro método. Entonces tenemos que sacar esto
de aquí y definirlo aquí. Para hacer eso,
configuramos lo que
se llama un
tipo de datos de retorno por defecto. Aquí puedes ver que hay uno
en par principal y uno aquí. Se llama vacío.
El vacío es como un agujero negro. Es como la nada. No es nada. Pero
lo que queremos hacer es devolver nuestra variable de
cadena aquí, nuevo fuera del método. Reemplazamos nuestro
vacío de la nada con una cuerda. Ahora hemos configurado un
tipo de datos de retorno aquí para este método, una cadena, y queremos
devolver esta variable aquí. Lo que hacemos,
tomamos nuestra variable, usamos la palabra clave return. Entramos en un espacio en blanco, ponemos nuestra variable, y luego
todas las líneas con punto y coma. ¿Qué está pasando aquí? Estamos
pidiendo el nombre del usuario, lo
estamos metiendo
en una variable, y luego estamos devolviendo la
variable de este método Puedes ver cuando
devolvemos la variable aquí, esta variable es de tipo de datos string que necesita
para que coincida con nuestro método header, que es toda esta
línea aquí mismo. Entonces puedes ver que estamos
devolviendo una cadena de tipo de datos, que es nuestra variable aquí. Ahora de vuelta aquí, vamos a
volver a nuestro método principal. Estamos llamando a esto,
pero
en realidad no estamos sacando ninguna
información de ello. De hecho ya hemos hecho esto antes. Se puede ver la línea de lectura de
puntos de consola. Este es un método y
en realidad estamos sacando
información de él. Y así es exactamente
como hacemos esto. Simplemente podemos hacer eso y
todo vuelve a funcionar. Recuerda antes cuando dije que esto no necesita
ser lo mismo que esto, podríamos simplemente decir
nombre por ejemplo. Se puede ver que
sigue funcionando porque principal sólo sabe de
cualquier cosa definida en Maine. Pide el nombre de un usuario, solo conoce cosas
definidas aquí a menos que
pases un parámetro o
devuelvas algo fuera. Repasemos esto
una vez más. En realidad, vamos a ejecutar
la aplicación. Así podemos ver que estamos
ejecutando la aplicación. ¿Cuál es tu nombre? Bob.
Y hola Bob. ¿Bastante fácil? Bueno, parece fácil hasta que sí. Veamos lo que
está sucediendo una
vez más para que tenga perfecto sentido. Estamos ejecutando la aplicación, estamos preguntando por
el nombre del usuario. Entonces la ejecución del código va aquí, no
hay parámetro, así que
seguimos adelante. ¿Cuál es tu nombre? El usuario escribe su nombre, aquí, lo
estamos almacenando en una variable
llamada nombre del usuario. Estamos devolviendo esta información
del método, que luego se almacena en nombre. Ese es el resultado
de este método. Nombre del usuario, lo
estamos devolviendo, es el resultado de este método ahora que se almacena en esta
variable llamada nombre. Entonces solo estamos
sacando el nombre a la ventana negra y luego
manteniendo abierta la ventana negra Así es como funcionan los retornos
con métodos en C Sharp, recuerda los parámetros
obtienen información y la devolución vuelve a sacar la
información.
15. 2-4. Sobrecarga de métodos: Ahora vamos a echar un vistazo
a algo llamado sobrecarga del
método ¿Qué significa eso? Echemos un
vistazo a este ejemplo. Aquí estamos definiendo
dos variables, ambas de tipo de datos entero llamado número uno
y número dos. Lo que estamos haciendo, estamos
llamando a un método llamado ad, que hemos creado aquí. Toma en dos parámetros
enteros, y es sólo sumar
los números juntos. Está devolviendo el resultado, que es un entero aquí
atrás. Y luego estamos sacando
el resultado a la pantalla. Muy sencillo. La respuesta
debe ser 20 2022. Tenemos la respuesta correcta. Lo que quiero decir ahora es ¿y si quiero sumar
dos dobles juntos? Convirtamos estos
enteros en dobles. Ahora tengo dos dobles aquí. Esto podría ser 6.4 y esto
podría ser 16.2 por ejemplo. Ya puedes ver que tenemos
una línea roja debajo aquí. Porque nuestros parámetros
son enteros. Está esperando enteros aquí. Pero todavía queremos este método, todavía
queremos poder
sumar enteros juntos Supongo que lo que podríamos hacer es
tener un método llamado in, y luego tal vez otro método llamado doble, por ejemplo. Y entonces esto
tomaría dos dobles. Entonces el otro tomaría
dos enteros, por ejemplo. Así es como podríamos
sortear ese problema. Entonces obviamente, eso
tendría un tipo de retorno como doble. Se puede ver a dónde va esto, pero ¿y si queremos sumar, por
ejemplo, dos decimales juntos o dos flotadores Entonces puedes ver que
vamos a tener que tener un método para cada uno de estos. Eso es bastante tedioso y realmente
puede hinchar nuestro programa
. Pero lo que podemos hacer es usar algo llamado
método de sobrecarga Lo que hace eso nos
permite tener un método pero darle diferentes parámetros
pero con el mismo nombre. Ahora, un método puede tener
el mismo nombre sólo si los tipos de datos de parámetros
o el número de parámetros, por ejemplo, son diferentes. Volvamos a nuestro ejemplo
anterior donde
estábamos sumando dos enteros
juntos aquí mismo Lo que podemos hacer entonces
es copiar este método. Conservamos el mismo
nombre, por ejemplo, pero aquí en
realidad estamos sumando dos dobles juntos
en lugar de dos enteros. Puedes ver lo que
tengo aquí ahora son dos métodos con
exactamente el mismo nombre, excepto que este toma dos
enteros y devuelve un int Y éste toma dos
dobles y devuelve un doble. Ahora cuando realmente
llamamos a nuestro método aquí, si solo abro estos
paréntesis aquí, ahora tenemos estas
pequeñas flechas negras No teníamos esto
antes porque solo
teníamos un método con
un conjunto de parámetros. Y te lo voy a mostrar ahora. Si abro los paréntesis aquí, se
puede ver que
no hay ninguna flecha negra Solo tenemos una definición
para el método add. Pero en cuanto agrego el
segundo aquí mismo, ahora tenemos más
opciones disponibles. Ahora podemos sumar dos enteros juntos y también podemos
sumar dos dobles juntos Este es un ejemplo de
sobrecarga de método en C Sharp. Simplemente te permite tener diferentes opciones para un
método con el mismo nombre. Se puede ver que C Sharp ha construido en métodos que
aprovechan esto ya. Por ejemplo, cuando escribimos
algo en la consola, puedes ver si hago
exactamente lo mismo, este método en realidad ya está
sobrecargado 18 veces Entonces puedes ver que es
un principio bastante popular en la programación de la tienda, así que espero que esto te haya ayudado, y este es un ejemplo de sobrecarga de
método en tienda C.
16. 3. Comentarios y etiquetas de resumen en XML: Ahora quiero hablar de
algo muy importante. Si quieres
hacerte la vida mucho más fácil o quieres tomarte la
programación más en serio, entonces necesitas
estar usando comentarios. Entonces, ¿qué son los comentarios? Si tienes una aplicación muy
compleja o una línea de código muy compleja, es realmente larga y tal vez sabías
lo que significaba en ese momento. Pero si vuelves a
esto uno o dos años después, posible
que hayas
olvidado por completo lo que significaba o la locura que
estabas escribiendo en ese momento Entonces es por eso que los comentarios
son muy útiles. Es un recordatorio
principalmente para ti mismo, pero si estás trabajando
con un equipo de personas, también les dice qué hace
el código sin que tengan que leer y
entender toda la complejidad. Podemos hacer comentarios de
tres maneras en C Sharp. El primero es un
comentario de una línea. Podríamos hacer eso. Por ejemplo, puedes ver cuando te dejo un
comentario, es verde. Ahora bien, este comentario aquí, no
se ejecuta por el software cuando se
produce su software, como un EXC para Windows No se compila en él, así que no desperdicias espacio ni
megabytes con los comentarios Estos son realmente útiles. Nuevamente, si tienes
algo realmente complejo, solo te dice lo que hace
la siguiente línea. Entonces podemos poner comentarios en
prácticamente cualquier línea que queramos. Podemos ponerlos después de una línea. Nuevamente, no se les corre, así que no hay una
línea roja debajo. Y simplemente realmente te dice
lo que hace la siguiente línea. Generalmente, la gente
pone el comentario encima del código y
no junto a él, pero puedes ponerlo junto
a él si lo deseas. Solo pongamos algunos
comentarios aquí. Se puede ver más o menos
cómo funciona aquí. Voy a decir,
sabemos que esta línea mantiene abierta
esa ventana negra. Entonces puedo poner un comentario que
diga que mantiene la ventana abierta. Éste le dice
hola al usuario. Podría poner un comentario
que diga hola. Cuando vuelvo a
esto un año después, y me he olvidado de
todo sobre la tienda, porque eso siempre
pasa con los idiomas. Puedes abrir esto y al instante saber qué hace cada una de
estas líneas. No quieres volverte
loco con los comentarios. No quieres que cada
línea tenga un comentario. Pero definitivamente si no
entiendes algo, entonces definitivamente pon un comentario
ahí porque te lo
recordará de nuevo y
podrás volver a
hacerlo mucho más rápido. Ese es un comentario de una sola línea. Lo siguiente que puedes hacer
es un comentario de varias líneas que es un slash hacia delante
seguido de un Asterix Entonces si presiono Enter, puedes ver que crea
Asterix está en cada línea
hasta que la termino con una slash
más hacia adelante Ahora todo lo que escriba aquí
está todo dentro del comentario. Esto es útil cuando se quiere introducir tal vez un método
o lo que se llama una clase. Esto es todo con lo que estamos
trabajando ahora mismo. Digamos que estás trabajando en un equipo de diez personas en la
parte superior del archivo. Quieres decir quién lo hizo, porque si hay un problema, entonces ellos pueden decir, bien, Bob escribió toda esta
sección del software. Sabemos porque el
autor es Bob, entonces Bob, cuando hace esta
parte del programa, puede decir, yo hice
esto, no me odies. Entonces puede resumir
lo que es. Es un reproductor de música, es genial, cualquier cosa
que quiera ahí dentro. Entonces, realmente depende de ti. Pero así es como hacer
un comentario de varias líneas. Son útiles para ordenar
identificar tal vez quién escribió el archivo y tal vez
más o menos lo que hace. De esa manera la gente
no tiene que leer todos los métodos e intentar
averiguar qué hace este archivo. Generalmente, los comentarios de varias líneas van en la parte superior de
los archivos, pueden estar aquí arriba, así que lo primero que la
gente puede ver o puede ir por encima de
algo muy complicado, como un método o
algo así, ahí es generalmente donde la gente usaría un comentario de varias líneas. Cuando se quiere escribir un montón de líneas individuales, por ejemplo, el último comentario del que quiero
hablar es lo que se llama
una etiqueta de resumen XML. Ahora no es realmente como un
comentario como este per se, pero te da una retroalimentación
importante. Te da comentarios en
inglés sencillo sobre lo que quizás haga la siguiente
línea de código. Pero podemos usar estos para tal vez métodos o
cosas así. Si tienes un método
complicado, tal vez tenga como 100 líneas de largo, hace todas estas cosas elegantes. A lo mejor el nombre del método realmente
no le hace justicia. Podría decir
pedir el nombre de usuario, pero hace muchas
otras cosas ahí dentro. A lo mejor devuelve algo que puede ser un poco complicado o tiene muchos parámetros y tal vez no sepas necesariamente
lo que significan. Podemos usar lo que se llama
una etiqueta de resumen XML para ampliar esto, donde llamo a mi método. Aquí pongo el cursor sobre
él con mi ratón, se
puede ver que en realidad no
dice mucho. Dice cadena. Programa, pregunta por el nombre de usuario. Sin embargo, si me har por encima
de esta consola punto leer línea, mira toda esa
información ahí. Está diciendo que lee la
siguiente línea de personajes, me está diciendo lo que devuelve. Es mucha
información diferente. Estoy pensando, oh, bueno,
¿dónde está eso en el mío? ¿Cómo configuro eso? Y eso es lo que se llama
una etiqueta de resumen XML. Por encima de nuestro método aquí, hacer tres barras hacia adelante 12 Y cuando haces la tercera, crea esta
pequeña plantilla agradable para nosotros. Está en formato XML. Aquí está la etiqueta de resumen abierto, aquí está la de cierre que representa la información
aquí que dice, lee la siguiente línea de caracteres de la entrada
estándar. Aquí defino aproximadamente
lo que hace este método. Si alguien pasa el
mouse por aquí, puede ver rápidamente
lo que hace sin tener que leer 100 líneas
de código. Por ejemplo. Se trata de dar a los otros desarrolladores información sobre lo que hace
este método. Por ejemplo, quieres darle algo muy descriptivo. Ahora cuando pase el cursor
sobre esto, oh, bien. Pide el nombre de un usuario. Oh si, olvidé que construí un minero
secreto de Bitcoin aquí. Entonces, por ejemplo, puedes poner
lo que quieras aquí, pero es para tu beneficio. Imagina que
guardas tu software por diez años. Regresas diez años después. Te has olvidado de todo. Pero ahora puedes
simplemente tener tu ratón por aquí y oh, eso, sí, claro,
me olvidé de eso. Entonces es bueno para tu beneficio, pero también es bueno para otros desarrolladores,
tal vez en tu equipo. Por ejemplo, dentro de aquí
tenemos dos etiquetas de devoluciones. Y eso es justamente
lo que se está devolviendo. Entonces estamos devolviendo
el nombre del usuario. Recuerda que es, puedes poner una pequeña pista aquí cuando obtengamos
el nombre del usuario, estamos diciendo, oh, recuerda
que es solo su nombre de pila. Cuando pasamos el cursor por aquí, podemos ver que devuelve
el nombre del usuario, pero nos estamos recordando a nosotros mismos, es solo su nombre de pila Es por esto que estas etiquetas de
resumen XML son útiles, ya que cuando pasas el
mouse sobre aquí en un instante, sabes exactamente lo que
hace en inglés sencillo Entonces estos son realmente útiles. Y se puede ver que este método
tiene un parámetro uno aquí. Cuando hago lo mismo aquí, tenemos una cosa extra aquí. Nuevamente, podemos usar nuestro resumen. Dice hola,
saluda al usuario. El parámetro define lo que hace
nuestro parámetro, como qué información le
damos, será el nombre del
usuario. Esto es saludarnos. Cuando tenga por encima de
esto podemos ver aquí, saludar al usuario Cuando abro el corchete aquí, me está diciendo lo que espera stre ¿cuál
es ese nombre completo? ¿Es nombre de pila? ¿Apellido? Apodo. Pero cuando
miro aquí abajo Oh, es el nombre
de pila, claro, Sí. Porque nos estamos
recordando a nosotros mismos, le
estamos diciendo a nuestro usuario, cuando llamamos a nuestro método, exactamente
qué hace nuestro método, qué espera como parámetro, y también qué devuelve Entonces son los
tres tipos diferentes de comentarios que puedes
usar en C sharp.
17. 4-1. Declaraciones de If y Else: Echemos un vistazo a algo
nuevas condiciones en C sharp. Vamos a echar un vistazo a la declaración if y
también a la declaración el. E L S E para L. Qué condición es algo que se
evalúa como verdadero o falso. Échale un vistazo a esto. ¿
Eres Bob? ¿Tu nombre es Bob? Bueno, la respuesta es
o sí o es no. Tienes un o tienes un perro o no tienes un perro. ¿Tienes seis pies de altura? O lo soy o no lo soy. Así que siempre tienen
una respuesta de sí o no. La condición en este caso es un Bob, esa es la condición. Se podría ampliar esta condición. Eres Bob, ¿tienes un perro? ¿En qué caso? Todo
esto es la condición. Si tu nombre es Bob pero no
tienes perro, entonces la respuesta es no. De lo contrario, es sí si
tienes ambos, por ejemplo, porque
aquí hay un final, esta es una condición. Esto es lo que es nuestra condición. Nos ocupamos de estos todos los
días, varias veces. Y podemos representar estos en C sharp usando lo que
se llama una declaración if. Echemos un vistazo.
Una muy sencilla. Vamos a crear
un poco de software llamado ¿Eres tú, Bob? Lo que hace,
pide el nombre del usuario. Tomamos el nombre del usuario. Si el nombre del usuario es Bob, nosotros,
vamos a darles un saludo increíble porque realmente
nos gusta Bob. Si su nombre no es Bob, entonces sólo
vamos a darles tal vez un Hello estándar, Roberto o algo así. Eche un vistazo al formato
de la declaración if. Comienza con If,
esa es la palabra clave, los paréntesis abiertos, tal
como lo hacemos en un método Por ejemplo, abrir paréntesis
dentro de los paréntesis. Aquí ponemos la condición. Nuestra condición es,
bueno, ¿tú, Bob? Sabemos que la variable name contiene lo que
el usuario ingresó, así que vamos a poner nombre. Entonces queremos el operador de
igualdad que esté representado
por dos signos iguales. Cuando asignas
algo en C sharp, usamos un signo igual. Pero cuando queremos comparar
algo, usamos dos. Estamos diciendo que si el
nombre del usuario es igual a Bob, entonces tenemos que hacer
algo en C Sharp. A Sharp le encantan estos tirantes rizados. Cuando tenemos un
método rizada,
cuando tenemos una ortesis if,
cuando abrimos una ortesis rizada, siempre
cerramos una ortesis rizada. Puedes ver estos aquí
coinciden con estos aquí. Así es como es el lenguaje. Esta es nuestra declaración if aquí. Este es el contenido
de nuestra declaración if. Todo entre
las llaves. Ahora, como dije, si el nombre del usuario es Bob, queremos darles
un saludo increíble. Intentemos escribir inglés. Sabemos que se llaman Bob. Bien podríamos poner a Bob. Hola, Bob. Estos, esos nombre es Bob les están dando
un saludo increíble. Mira. No obstante, si
su nombre no es Bob, quizá sea Roberto o Henry, entonces tenemos que darles
un mensaje diferente. Si ejecutamos este programa ahora puedes decir,
¿cuál es tu nombre? Vamos a escribir Henry. Nos está dando un
estándar Hola Henry. En realidad es ignorar esto por completo porque
el nombre no es Bob No obstante, si ejecuto la aplicación
ahora, ¿cuál es su nombre? Bueno, mi nombre es Bob. Y recuerda C sharp sensible a
mayúsculas y minúsculas. Entonces solo verificamos una púa en minúsculas en
nuestra declaración if, así que asegúrate de
que coincida con eso. Entonces haz clic en Responder. Ahora tenemos nuestro
increíble look de saludo, pero tenemos un problema Mira. También dice hola Bob también. Entonces está recibiendo dos saludos. Y eso es porque se está satisfaciendo la condición de declaración
if, que
es esta sección. Evalúa a verdad. Por lo tanto, esta línea de
código se está ejecutando. Una vez que termina la sentencia if, todavía
estamos ejecutando este bit. Pero tal vez queremos reservar este saludo para
Henry, por ejemplo. Por lo tanto, presentamos
lo que se llama una declaración L. E LSE, de nuevo, tirantes rizados. Esta sección está
reservada para Bob. Esta sección está reservada
para cualquier cosa que no sea Bob. Esto se evalúa como verdadero cuando
el nombre del usuario es Bob. Evalúa como falso
si es otra cosa. De lo contrario, todo
lo demás entra aquí. Queremos darle el saludo
estándar a cualquiera que no sea Bob. Y así es como funciona la declaración
else. Entonces si esto se evalúa
a verdad todo aquí, Si evalúa a
falso todo aquí, por
ejemplo, si
ejecuto el programa, ahora ¿cuál es tu nombre? Mi nombre es Bob. Ahora me sale
el saludo estándar, y esta sección es ignorada por completo porque
mi nombre es Bob. Pero cuando ejecuto el programa, ahora tecleo cualquier cosa, obtenemos el saludo estándar porque esta parte se ignora, cae a la sección
else aquí. No puede existir sin
un si no podemos hacer esto, eso no tendrá sentido. De lo contrario siempre se necesita un
si para ir con él. Cuando intentemos ejecutarlo,
habrá un error. No se puede tener otra cosa por sí sola. Siempre necesita un
acompañamiento si está por encima de él. Es una vista muy simplista
sobre una condición de ejemplo, que es la condición if
en C.
Solo quiero pasar por un ejemplo
rápido para que entiendas
completamente cómo funcionan
estas condiciones Ahora bien, cuando se tiene
una declaración if, ésta tiene una condición
y una acción. Si esto se evalúa como verdadero, se ejecuta esta sección aquí Si se evalúa como falso, esta sección se ejecuta aquí Cuando hablamos de variables, teníamos una variable bolen Las variables Bolen
se evalúan como verdaderas o falsas. Lo que podamos hacer, sólo
voy a usar paréntesis. Los paréntesis son opcionales, pero creo que
mejora la legibilidad Ahora estamos almacenando el resultado de esto en una variable
llamada es Bob. Entonces podemos poner es Bob
aquí mismo está el nombre dado
por el usuario Bob. Y cuando digo es, quiero decir, ¿es igual al operador de
igualdad, sí o no, verdadero o falso? Entonces verdadero o falso
va a ser almacenado en esta variable
llamada es Bob. Si entonces se ejecuta la declaración, va a decir que es verdadera
falsa. Si no es falso. Si ejecuto el software aquí, tecleé Bob, oye
Bob, eres increíble. Es exactamente lo mismo. Te da más claridad sobre lo que está pasando, si
eso tiene sentido. No he hablado tanto de los
booleanos, pero básicamente es decir, ¿esto equivale
a verdadero o falso Y esto o va
a ser cierto o falso porque así es como lo
representas como un booling Y entonces cuando ejecutemos
la declaración if es Bob será o
verdadera o será falsa. Y va a correr
el apropiado. Si no somos Bob, somos Henry. Entonces va a decir,
oye, persona al azar.
18. 4-2. Declaraciones en Else If: Ahora ampliemos nuestro ejemplo de condición
if en nuestro último tutorial y hablemos
sobre la cláusula el if. Aquí tenemos nuestro
saludo estándar para Bob. Pero, ¿y si quisiéramos un saludo
especial para Henry? Bob recibe su propio mensaje personalizado. Henry podría tener
su propia costumbre, entonces todos los demás
obtienen uno estándar. Por ejemplo, aquí presentamos
la sentencia else if. Vayamos aquí abajo.
Esto se denota por que queremos cambiar a Bob, porque ya
tenemos esa condición Estas condiciones realmente necesitan ser únicas. De lo contrario no tendrá sentido. Va a ser redundante de verdad. Entonces ahora estamos diciendo,
¿eres Bob o eres Henry? Recuerda, hagamos que nuestros
comentarios tengan sentido. Entonces, ¿tu nombre es Bob? Hola, Bob. ¿Tu nombre es Henry? Oh, hola Henry. Pero recibe más signos de
exclamación porque llama. Entonces si no eres Bob, no
eres Henry, entonces eres todos los
demás en el fondo. Entonces, vamos a escribir
Henry, por ejemplo. Ahora estamos consiguiendo el de
Henry porque nuestro nombre es Henry. Muy sencillo. Una vez que entiendas cómo funciona
el if y lo
demás, si no es solo otra cosa. De nuevo, incluso podemos ampliar esto y tener otro
nombre aquí, tal vez Scott o
algo así. Puedes modificarlo de manera apropiada
a lo que desees. Así es como funciona la
declaración elif. Otra vez, no necesitas
el, no necesitas más. Si muy felizmente tienen
esto por ejemplo, si tecleo algo más, no
van a
recibir ningún mensaje en absoluto porque no le hemos dicho
que haga nada. Ese es el poder de la declaración el if cuando se utiliza
la condición if. Ahora voy a mostrarte
un poco de consejo. Ahora, hemos cubierto la declaración
if el if. Es decir, cuando se
tiene una condición, por ejemplo, con solo una
línea de código debajo. Entonces tenemos esta condición,
una línea de código. Entonces esta condición,
una línea de código. Cuando tenemos una línea de código, entonces estas llaves
aquí, son opcionales Lo que eso hace al eliminar esos, aumenta la legibilidad Da menos hinchazón
a tu software. Esto es exactamente lo
mismo que teníamos antes. Sin embargo, por ejemplo, si
tenemos dos líneas de código o más bajo cada condición,
entonces hay un problema. Y eso es porque
necesita esos tirantes rizados. Aquí mismo se puede ver que ahí hay
una pequeña línea roja, y el error no es
muy descriptivo. Eso es porque está
tratando de leer todo esto en una línea y va a
arrojar un error misterioso. Cuando tienes una línea de
código bajo cada condición, entonces las
llaves son opcionales Pero no se puede hacer esto
con métodos, por ejemplo. Sólo cosas como si, más, si, más, y algunas otras cosas
que aún no hemos discutido. Pero eso es un pequeño
consejo donde puedes mejorar la
legibilidad de tu código en el futuro
19. 4-3. Operadores de igualdad y desigualdad: Igualdad y desigualdad.
¿Qué son esos? ¿Qué significa? Bueno, estas son cosas que quizás oigas ahora. Y nuevamente, ya hemos cubierto un poco
la igualdad cuando estaba
discutiendo la declaración if. Pero la igualdad es básicamente decir que es algo
igual a otra cosa. Y eso está representado
por dos signos iguales aquí. Pero, ¿cómo decimos desigualdad? Bien, ¿y si el
nombre no es Bob? ¿Cómo representamos eso? Lo que podemos hacer ahí es
usar el no igual a, que está representado por un signo de exclamación
seguido de un signo de igual Ahora bien, está prácticamente al revés, toda
esta afirmación. Si el nombre no es igual a Bob, entonces bueno, esto no va a tener
sentido ahora porque
su nombre no es Bob. Lo que podemos hacer ahora
es decir, oye Bob. Si ejecuto el software ahora, ¿cuál es tu nombre, Bob? No va
a pasar nada porque no le
hemos dicho
que haga nada. Pero si ejecuto el software
y pongo algo más, va a decir,
oye, tú no eres Bob. Pero si simplemente volteo a
este operador en un símbolo de igualdad ahí mismo, va a invertir
todo el significado de
toda la declaración. Ya ves que
no tiene sentido porque a pesar de que el nombre es Barb, sigue
corriendo esto Si quieres decir algo es igual a algo,
dos signos iguales. Si quieres decir que no
es igual a, entonces no necesitamos iguales, que es exclamación
y un signo igual
20. 4-4. Operadores de comparación: Bien, operadores de comparación. Tengo una
aplicación muy sencilla aquí. Pide al usuario un número 1-10 Toma la entrada del usuario, convierte en un entero, y la pone en una
variable llamada número. Eso es más o menos lo
único que hace esto. Lo que quiero hacer, si el usuario ingresa un número
inferior a un cinco, quiero decirle un mensaje
al usuario para
decirle que eligió un número bajo. De lo contrario, elegiste
un número alto. Muy sencillo.
Para ello, necesitamos una condición
que vamos a usar. La condición que vamos a decir es el número
menos de cinco? Cómo representamos menos que
es un corchete angular izquierdo, eso se ve así
, y luego cinco. Luego con el enunciado,
usamos nuestros corchetes. Entonces esto es lo que sucede cuando nuestro número es inferior a un cinco. Le vamos a decir al usuario, no lo
sé,
elegiste un número bajo. Algo así. No obstante, si el número no es
inferior a un cinco, bueno entonces podemos usar L simplemente
prácticamente revertir esto. Elegiste un número alto
si ejecutamos la aplicación. Ahora escoge un número 1-10 Recuerda, menor que un cinco es bajo,
así que voy a hacer cuatro. Escogí un número bajo,
y eso es todo. Gran pieza de
software, ¿no? Entonces si el número es cinco
o superior, hagamos un cinco. Debería decirme que
elegí un número alto, elegí un número alto. De igual manera, si pongo ahí
1 millón, va a decir que
elegí un número alto. Pero este es un ejemplo de un operador de comparación que se llama el operador menor que. Del mismo modo, podríamos usar
el operador more than, que está representado por
un corchete angular recto. Ahora bien, esto no
va a tener sentido. Tendremos que revertir estos. Eso va a hacer
exactamente lo mismo. Pero se puede ver que está al revés. Si el número es más de cinco, entonces escogimos un número alto. De lo contrario escogimos
un número bajo, va a hacer
exactamente lo mismo. Pero debido a que reviso a esto, tengo que revertir estos dos. Sólo tiene sentido que los otros dos sean
más o iguales a, e inferiores o iguales a. Más o igual a se
representa de esta manera. Más o igual a, menor o igual a, como habrás adivinado, un corchete angular izquierdo
y un signo igual al usar cosas como
no igual a, menor que, igual a, más que igual a, Intenta y recuerda que el signo igual siempre va del lado
derecho, siempre en C agudo Ahora bien, si el usuario escogió un número menor
o igual a cinco, entonces aparentemente escogió un número mayor,
lo cual no es cierto. Volvemos a revertir estos. ¿Bien? Menos
o igual a cinco, escogieron un número bajo, antes
teníamos menos de cinco. Si es algo
hasta el número cuatro, entonces es un número bajo. Si queremos decir
menos o igual a eso, tendríamos que
hacerlo en su lugar. Debido a que el número es
menor o igual a cuatro, entonces es un número bajo. Menos o igual
a cuatro es
lo mismo que decir menos de cinco. Nuevamente, podemos usar más o igual para revertir la lógica. Nuevamente, si el número es
más que igual a cinco, nuevamente, podemos revertir
estas declaraciones, obtenemos exactamente
lo mismo que son lo que se
llama operadores de comparación en C Sharp. Si ponemos siete,
elegiste un número alto.
21. 4-5. Operadores booleanos: Operadores de booling. Suena un poco complicado, pero te aseguro que no lo es. Un operador booling es
básicamente una forma de decir y bastante difícil de decir Lo que vamos a hacer
es crear una muestra, una aplicación básica de lotería. Le estamos pidiendo al
usuario un número, 1-10 Si el usuario ingresa
un tres o siete, entonces ganó, ha
ganado la lotería. Echemos un vistazo,
podemos implementar esto. Si dices la
frase en voz alta, es más o menos
decirte lo que debes hacer si el usuario implícito elige un
número que es tres, una cualidad para tres ahora. O está representado por dos tubos
verticales como este, 12. No sé por qué.
Así es como es. El número es igual a tres, el número es igual a
siete. Es muy sencillo. Cuando dices en voz alta, es más
o menos diciéndote
lo que necesitas para escribir. Entonces quiero decirle al usuario que han ganado la lotería,
han escogido el número de la suerte, Así que echemos un vistazo a esto. Escoge un número, 1-103 has ganado, probemos que no es una papelera lateral de
casualidad número dos, no pasa nada, es porque no le
hemos dicho que haga Ese es un ejemplo muy básico
de usar el operador. Puedes usar más de uno. Puedes usar cuatro
si lo deseas. Entonces, si el usuario elige 34 o nueve, por ejemplo, funciona perfectamente. Ahora tienes cuatro números de la suerte. Ese es el operador, lo que
se llama un operador de Bolen. El otro operador de Bolen
es lo contrario. Es el uno y
eso está representado por, a una persona que uno tiene más
sentido. Al menos eso significa, pero
necesitas dos de ellos. Con el operador final. Lo que podemos hacer, podemos
decir si el número
no es igual a dos y no
es igual a siete, por
ejemplo, entonces ellos han ganado. Qué podemos hacer si el
número no es igual a dos, el número no es
igual a siete, porque 2.7 son números malos. Si eliges 2.7
lo has perdido todo. Por ejemplo,
siempre y cuando el número no sea dos y el número no sea
siete, entonces tienes uno. Así es como puedes usar el
operador y puedes ver la lógica se invierte a
la que acabamos de usar
con el operador Or Ahora usando no igual a, pero la misma lógica se aplica
cuando ejecutamos la aplicación. Ahora mientras no
escojamos dos o siete con uno, escojamos cuatro. Se
puede ver con uno. No obstante, si
elegimos dos o siete, no
va a hacer nada porque no le hemos dicho
que haga nada. Ese es un ejemplo muy básico de usar operadores booling
como la R y el final Nuevamente, con estos puedes
expandirlo y hacer cuatro
números si lo deseas. Y lo que podemos hacer
con y los operadores, podemos combinarlos también. Veamos un ejemplo rápido
de cómo podemos combinar. Y vamos a preguntar por
el nombre del usuario. Vamos a preguntar
por el nombre del usuario y tomar el nombre del usuario. Ahora pretendamos que Bob solo tiene acceso a la
aplicación de lotería que
estamos haciendo aquí. Él es el único con la
autoridad para jugar a la lotería. Lo que queremos hacer es decir
es el nombre de usuario Bob, ¿tiene el
número dos o siete? Y ese es un ejemplo de cómo
podemos usar y juntos. Pero el punto es que
todo el asunto o
bien evaluará a verdadero o falso. Ese es el punto principal
de la condición aquí. ¿El nombre es igual a Bob y tiene el
número dos o siete? Entonces voy a poner dos o
siete entre paréntesis aquí. Así que en realidad es
mucho más legible y va a tener sentido. Y también va a calcular
correctamente. Entonces, ¿el nombre del usuario es Bob? Sí. ¿Bob tiene el
número dos o siete? Sí. Digamos que tiene
siete entonces es uno. Digamos que el
nombre de la persona es Henry. Bien. ¿Es el nombre Henry? ¿El nombre es Bob? No, es Henry. Bien. No, entonces sólo
va a saltar aquí abajo, Así que vamos a probar la teoría. Entonces, ¿cuál es tu nombre? Henry. Entonces pongamos un ahora
pongamos el número de la suerte. Creo que siete es uno de ellos. Entonces no pasa nada
porque no es Bob. Sólo Bob tiene permiso para potencialmente ganar
la lotería aquí, pongamos a Bob, vamos a darle un número de la suerte y él es uno. Así como así. Hagamos a
Bob con un número desafortunado, que definitivamente es 44 No pasa nada. Se puede ver
así es como evalúa toda
esta condición con un operador y booling
y también uno También es bueno usar paréntesis
, para asegurarse de que a,
calcula
correctamente, y dos,
también calcula
correctamente, y dos, mejora la legibilidad
22. 4-6. EJERCICIO - crea un juego de calculadora: Así que vamos a hacer un
poco de ejercicio ahora y poner a prueba tus conocimientos en algunas de las cosas que
hemos aprendido hasta ahora. Lo que vamos a hacer es crear una calculadora de muestra en C Sharp. Ahora mismo,
no está pasando mucho. Sólo le estamos diciendo al usuario, bienvenido a nuestra calculadora de llamadas. Y cuando ejecutamos el programa,
no pasa nada. Entonces necesitamos programar
esa habilidad, lo que va a hacer el usuario. Van a ingresar
su primer número, que podría ser un decimal, y luego van
a ingresar un operador más menos multiplicación
o división Y luego van a
ingresar su segundo número. Y luego se va a realizar el cálculo y mostrar en la pantalla algunas
cosas a considerar. Número uno, el usuario
puede introducir decimales. Tenemos que asegurarnos de convertir nuestros números a
dobles, por ejemplo. Lo siguiente es que tenemos que
tomar en el operador al que entra
el usuario y
averiguar si es un plus, un
menos, una división o una multiplicación Y luego actuar sobre eso
apropiadamente usando las condiciones. Pidamos al usuario su primer número.
Sabemos cómo hacer eso. Le estamos pidiendo al
usuario su primer número. Para recopilar esa información, utilizamos la línea de lectura de puntos de consola. Queremos poner esto
en un doble. He configurado una variable llamada primero y que
almacenará el primer número,
pero la línea de lectura de punto de consola devuelve una cadena. Necesitamos convertir esta
cadena en un doble. Podemos usar convert para hacer eso,
escribimos convert period y
queremos doblar los corchetes abiertos. Poner la salida de esto
dentro de los soportes. Y luego recuerda
cerrar los corchetes. Ahora hemos capturado el primer número del
usuario. Lo siguiente que queremos hacer es tomar en el operador del usuario, pero vamos a tomar primero el segundo número del
usuario. Eso es porque
sólo podemos copiar y pegar esto. Es mucho más fácil. Tenemos el
primer número del usuario y el segundo número del usuario fácil. Ahora queremos al operador.
Vamos a copiar esto. El operador será una cadena porque la consola punto leer línea
ya nos da una cadena. No necesitamos convertir
nada para que podamos eliminar esto. Vamos a crear una nueva
variable llamada operator. Pero mira lo que pasa
cuando hago eso. Ya ves que está resaltado en azul. Está lanzando un
error. ¿Por qué es eso? Eso es porque operador
es una palabra clave en C sharp. Ya se usa en realidad. Por ejemplo, no podemos crear una variable con el nombre
de double por ejemplo. Hace exactamente lo mismo. Eso es porque es
una palabra reservada. Tenemos que elegir un nombre
que no sea operador, porque operador ya se
usa en el lenguaje C sharp. Sólo voy a llamarlo OP. Quizá descubras que
pensé que te contaría
la información ahora. Ahora queremos
pedirles el operador. Quizá queramos
decirles lo que pueden hacer. Estamos diciendo que
se puede elegir más, menos, multiplicación
o división Estamos tomando el operador y almacenándolo en
una variable llamada p. Ahora tenemos toda la
información de nuestro usuario. Tenemos los números y
todo lo que necesitamos. Ahora lo que tenemos que
hacer es averiguar qué operador están usando y luego realizar
el cálculo. ¿Cómo averiguamos al operador? Bueno, podemos usar
declaraciones if para hacer esto. Decimos si. Ahora usamos
el operador de igualdad. Es el operador. Debido a que
el operador es una cadena, utilizamos comillas dobles.
¿Es un plus? El código dentro de esto, si ponemos las llaves, si la operación es un plus, decimos f más segundo Pero queremos poner el resultado
de esto en una variable. Definamos una variable
que almacene nuestro resultado. Sólo voy a
inicializarlo a cero. Recuerde que el resultado de punto y coma es igual al resultado de
primero más segundo, porque estamos trabajando
con el operador más. No obstante, y si quieren
multiplicar dos números, por
ejemplo, entonces necesitamos un si el usuario entra en
multiplicación por ejemplo, entonces esto no es cierto,
se evalúa como falso, entonces la ejecución del código
saltará hacia abajo Tenemos que coger eso
aquí en otra cosa. Si, si el usuario quiere hacer una multiplicación, entonces
verificamos eso Y luego simplemente multiplicar
los números juntos. Es muy fácil, ¿no? Ya se puede ver a dónde va
esto. Mi comida para llevar y división, la división aquí, y
la comida para llevar aquí. Así es como realmente
detectamos al operador aquí. En todos los casos, estamos haciendo el cálculo apropiado
dependiendo de la condición, luego siempre poniendo el resultado en la variable de resultado aquí. Lo último que queremos hacer es decirle al usuario cuál es
el resultado. Puedes ver aquí un
estudio visual me está ofreciendo esto. Yo lo llevaré, Pulsa
Tab en el teclado, y ahora está escrito para mí. Ahora quiero decirle al
usuario cuál es el resultado. Resultado, algo así. Ejecutemos el programa
y veamos si funciona. Bienvenido a nuestra calculadora genial. ¿Cuál es tu primer número? Tres, ¿Cuál es su operador? Puedes elegir más, menos,
multiplicar o dividir. Yo elegiré la multiplicación. ¿Cuál es tu segundo número? Porque sabemos tres
por cuatro es 12. No necesito pensarlo. El resultado es 12. Bueno, eso
funciona. Probemos uno más. Probemos 200/3 porque sabemos que tres no entra
perfectamente Para que podamos probar eso. Nuestro resultado en realidad nos está
dando un decimal. Puedes ver el
resultado es 66.6 6667. Entonces tenemos un buen grado
de precisión aquí. Al usar dobles
en lugar de enteros, podemos tratar con
valores decimales y números que no son números enteros
que no son números enteros Este es un
ejemplo muy rápido de cómo hacer una calculadora precual en C Sharp usando todo lo que
hemos aprendido hasta ahora
23. 4-7. Declaraciones de cambio: Entonces voy a
introducir algo que ahora se llama una declaración switch. Es un nuevo tipo de declaración que vamos a conocer. Y es muy similar
a la sentencia if y
else if en la forma en que
cuando se ejecuta la sentencia if, evalúa una condición Si es cierto, entonces
ejecutará la acción a continuación. Si es falso, pasará a la siguiente declaración de Els if
e intentará eso de nuevo. Si esto es cierto, ejecutará
esta acción, etcétera. Switch es muy similar a esto. Es sólo otra forma de representar la
misma información. Lo que voy a hacer,
voy a reescribir esto como una declaración switch para poder
mostrarte exactamente cómo funciona eso Con una sentencia switch, usamos la palabra clave switch. Tiene una entrada, que es lo que el usuario
escribe en el programa. Por cierto, antes de comenzar, te
mostraré lo que hace
esta aplicación. Le pide al usuario que
ingrese un día de la semana, y luego le da un mensaje
personalizado sobre qué día ha ingresado. Si ejecuto este programa, por favor ingrese un día de la semana. Escribo lunes, no me gusta el lunes. Es una aplicación muy sencilla. Lo que voy a hacer es reescribir esto como una sentencia switch Toma la entrada del usuario, que hemos puesto en una
variable llamada input. Al igual que la mayoría de
las cosas en C Sharp, abrimos y cerramos llaves y ponemos todo el
código en el medio Ahora una sentencia switch,
por ejemplo, sentencia
if, para verificar
diferentes condiciones. Sin embargo, con la
sentencia switch tiene casos. Estos representan, por ejemplo, una sentencia L if. Nuestro primer caso puede ser
es la entrada el lunes. Nosotros representamos esto así. Entonces ponemos el código en
el medio aquí mismo. En una sentencia switch. Estas tres líneas
aquí son más o menos las mismas que estas tres
líneas aquí mismo. Simplemente está redactado de manera diferente porque la entrada es una cadena de tipo de
datos, nuestro caso necesita ser una cadena Si, por ejemplo, la
entrada es un número, entonces este tiene que ser un
número. Así es como funciona eso. Una sentencia switch puede
tener uno o muchos casos. Vamos a hacer uno
por cada uno de estos. Cada caso dentro de una
sentencia switch debe terminar con dos puntos y debe terminar
con la palabra clave break. Y todas las líneas terminan
con punto y coma. Cada cabecera de caso termina
con dos puntos y termina con un descanso. Así es como es
dentro de las declaraciones switch. Las llaves rizadas son opcionales. Puedes ponerlos,
no tienes que ponerlos. Se puede poner el descanso
dentro de los tirantes. Es muy flexible
sobre cómo funciona. Solo tiendo a dejarlos fuera siempre y cuando toda
tu lógica aquí, y puedes tener múltiples
líneas de código dentro de un descanso. Y los dos puntos de la cabecera,
están todos bien ahí. Ese es nuestro primer caso, el lunes. mí no me gustan los lunes
otra vez para el martes, el siguiente caso sería Nuevamente, no podemos tener
exactamente el mismo caso porque
es redundante. El siguiente caso sería el martes, y tomamos esta línea
para el martes, etcétera Se puede ver un patrón
emergiendo aquí. La declaración switch tiene muchas
condiciones dentro de ella. A través del poder de edición, he reescrito todas esas declaraciones
y l if en una declaración switch
y hará exactamente lo mismo.
Déjenme demostrarlo. Ahora vamos a
cortar temporalmente esta lógica. Ahora voy a ejecutar la
aplicación que escribo el lunes. Ya ves que estoy obteniendo
exactamente el mismo resultado. Esta declaración switch
aquí es exactamente la misma que todas estas
declaraciones ifs y L if aquí Una cosa que notas
es la legibilidad. Se lee mucho mejor. Se puede ver que en realidad es
mucho más mínimo. Se puede ver claramente lo que está
pasando y se ve mucho más
arreglado que esto Esa es una ventaja de
usar una declaración switch. Una desventaja son los operadores de
booling. Por ejemplo, si el insumo es lunes o martes
pero no miércoles, tenemos
algo complicado aquí mismo. Estos son bastante difíciles de
lograr con declaraciones
switch y se
vuelve mucho desordenado muy rápido En ese ejemplo,
preferiría una declaración F, en ese caso para trabajar con operadores de bolen
complejos Otra ventaja de usar declaraciones
switch es que cuando realmente obtienes
muchas condiciones, aquí tenemos siete,
es bastante. Cuando lleguemos a cinco o más, entonces una sentencia switch en realidad
se ejecutará mucho más rápido
por el sistema. Esto solo se debe al diseño. Lo que está pasando en
el fondo. Cuando obtienes cinco casos, por
ejemplo, o más, entonces preferiría
una sentencia switch sobre esto solo porque
en realidad se ejecuta más rápido. Si representas siete casos en declaraciones if y else if, entonces la computadora tiene que
evaluar cada una de ellas. Va, oh,
éste, ¿es éste? ¿Es éste? Pero esto no funciona en declaraciones
switch. En realidad se ejecuta
un poco diferente. Es más eficaz a la
hora de decidir entre declaraciones switch
if y else if Entonces solo depende de ti. Tienes que tomar
tu ejemplo y averiguar cuál
funciona mejor para ti. Una cosa que voy a mencionar
con las declaraciones switch, una última cosa es, ¿qué pasa si ninguno
de estos casos ocurre? Y si hay un
octavo día mágico de la semana, o tal vez el usuario realmente
deletreó uno de estos incorrectamente, Entonces ninguno de estos casos realmente
sucederá Si hiciéramos este ejemplo con
si y de lo contrario si tendríamos una L final en la parte inferior que
leería algo así como, leería algo
así diciéndole al
usuario que ha ingresado un día no válido porque tal vez lo deletrearon
mal. Por ejemplo. ¿Cómo representamos esto
en una declaración switch? Bueno, usamos lo que se llama
la palabra clave predeterminada. Si escribo default, siempre lo termino con un break, al
igual que los casos anteriores, entonces puedo poner ese
mismo código aquí mismo. Si elimino esta lógica
y pruebo la aplicación, entonces a propósito deletreo uno
de los días incorrectamente, se puede ver
que le está
diciendo al usuario, que ha ingresado un día de la semana
no válido Entonces esto es bastante útil
cuando quieres que se
ejecute algún código donde ninguno de tus casos
realmente evaluó true. Entonces es como un
catchall, por ejemplo.
24. 4-8. Operadores condicionales: Hablemos de
operadores condicionales en C Sharp. Los operadores condicionales
no se limitan a C Sharp. De hecho puedes
experimentarlos en C plus plus y otros idiomas lo que es un operador
condicional. Es una forma rápida de reemplazar
una declaración F y una L. Considera este ejemplo. Aquí estamos preguntando al
usuario si le gusta el café, estamos tomando su entrada y
almacenándolo en una variable. Entonces si escriben
yes, por ejemplo, entonces solo estamos configurando
una variable llamada message, y almacenando esta
cadena dentro de ella. Sabía que podía
contar contigo. ¿Algo más? Estamos diciendo que ya no somos amigos y
lo estamos sacando a la pantalla Si acabo de ejecutar el
software ahora para que puedas
ver rápidamente cómo funciona eso. Sí, sabía que podía
contar contigo. Muy sencillo. Pero pueden ver que tenemos una declaración if aquí y
una declaración L también. Ocupa cuatro líneas de código con esta
lata extra de variable aquí. Hay cinco líneas en total. Cuando desarrollas grandes
piezas de software, a veces es bueno simplificar todo
esto en una sola línea. Previene la hinchazón, y nuevamente, podría mejorar la legibilidad Depende ¿cómo
puedo representar esto en
una línea de código? ¿Cómo minimizo esto? Bueno, podemos usar lo que se llama
el operador condicional. Lo que voy a
hacer, voy a reescribir toda esta sección aquí usando un nuevo concepto,
el operador condicional Ahora a veces se le llama
operador ternario, eso solo significa que consta
de tres partes Y ya verás por qué
se llama así también. Sólo voy a escribir esto como operador condicional, entonces voy a
explicarlo después. Como dije antes,
consta de tres partes. La primera parte es la condición, esta está separada por la segunda parte con un signo de
interrogación ahí. Entonces la segunda parte es si la condición
se evalúa como verdadera La tercera parte es si la
condición se evalúa como falsa. Ahora bien, esta línea de código aquí hace exactamente lo
mismo que todo esto aquí. Deja que te lo demuestre. Si hacemos esto, ejecutamos el programa. ¿Te gusta el café? Sí,
sabía que podía contar contigo. Y vamos a probar
el otro padecimiento. ¿Algo más? Ya
no somos amigos. Ya puedes ver que está mucho
más simplificado. Hemos puesto todo eso
en una línea de código. Pero, ¿cómo funciona esto? Lo que sucede es que estamos almacenando el resultado de esto en una
variable llamada message, similar a lo que
estamos haciendo aquí. La primera parte del operador
condicional es la condición es
la respuesta del usuario? Sí, estamos probando para una
cadena. Esta es la condición. La primera parte del operador
condicional vive entre un signo de
interrogación y un colon. Es decir, si la condición
se evalúa como verdadera. Si esto es cierto,
entonces este segmento
del operador condicional se ejecuta entonces esta sección aquí, si se puede imaginar
este queslonre, es
decir, de else, si es Y esta es la condición, esta variable sólo está
tomando el resultado de toda
esta condición aquí,
un operador condicional. Es solo una forma rápida de escribir una declaración F y una L
en una línea de código. La legibilidad, Sí, sí
depende si se pueden castrar operadores
condicionales Puede parecer un poco confuso, pero cuanto más los puedas usar, en
realidad condenr mucho el
código Considera si tienes
tal vez 50 o 100 de estos, es bueno
simplificarlo en una sola línea de
código por ejemplo. Pero así es como se
puede escribir palanca, operadores
condicionales
en C Sharp.
25. 5. Arrays: Entonces voy a introducir un nuevo tipo de objeto
en nuestro aprendizaje. Y eso es lo que se llama una
matriz. ¿Qué es una matriz? Bueno, en inglés sencillo, una matriz es una colección
de algo. Por ejemplo, digamos que
uno de tus amigos tiene una bonita colección
de videojuegos. Se podría decir, oh, esa es una buena variedad de
videojuegos que tienes. Simplemente significa una colección de algo, mucho de algo. En programación,
es muy similar. Echemos un vistazo a este ejemplo
muy básico aquí. Lo que tengo aquí son seis
variables de tipo entero. Entero es el tipo de datos. Sólo estoy sacando el
primero a la pantalla. Muy sencillo. Digamos que si emulamos una aplicación de
lotería, el usuario elige seis números
y luego ponemos cada uno de sus números en una variable y todas las variables
son únicas Pero, ¿y si el usuario
elige 1,000 números? Entonces voy a tener que
crear mil variables. Va a ser muy tedioso. Nuestra aplicación va
a usar más memoria, va a ser
más grande en tamaño de archivo, y va a tardar
mucho tiempo en desarrollarse también. Cómo podemos superar este problema de tener todas estas variables con diferentes nombres únicos es usar lo que se llama una matriz. Lo que la matriz puede
hacer es agrupar toda esta información
en una sola variable. Echemos un vistazo a cómo
podemos representar seis líneas de código aquí en una sola línea
simple usando matrices. Entonces lo que voy
a hacer, voy a definir e inicializar
una matriz aquí mismo Queremos que todos nuestros elementos dentro de la matriz sean
enteros, números Vamos a usar el tipo de
datos int para nuestra matriz aquí, luego voy a usar corchetes abiertos
y cerrados Eso es decirle al sistema, oye, quiero crear una matriz. Vamos a darle un nombre a
la matriz. Vamos a llamarlo números. Hemos declarado la
matriz ahí mismo. Y ahora queremos
inicializar la matriz, lo que significa que queremos
poner algunos datos dentro de ella. Y podemos hacerlo
en la misma línea. Para hacer eso
vamos a decir que no. Entonces voy a poner de nuevo
el tipo de datos, de nuevo los corchetes. Ahora quiero poner valores
dentro de esta matriz. Yo uso llaves abiertas, rizadas
cerradas, y luego un punto y coma. Ahora dentro de estos tirantes curley, voy a poner los
valores, así puedo poner dos Cuando pongo un siguiente valor
utilizo a y luego 12,
y ahora el siguiente valor, 264,556.71 Ahora bien, esta variable aquí llamada numbers es una
matriz de tipo integer Estos son todos los
valores que hay en su interior. Ahora bien, esta línea de código representa todas
estas seis líneas aquí. Ahora ya no necesitamos esto. Ahora, ¿cómo
accedemos realmente a los números
dentro de esta matriz? Bueno, tomamos el
nombre de la matriz, que es números, luego
usamos corchetes. Dentro de los corchetes, ponemos un índice para nuestros valores. Ahora bien, cuando antes
hablábamos de subcadenas, dije que el índice
generalmente está en C sostenido Comienza en cero, este
es el espacio cero del artículo. Se trata de la ranura de artículo número 12345, pesar de que tenemos seis ítems, este es el índice cinco porque
este es el índice cero, tenlo en cuenta al
trabajar con matrices y colecciones y cosas
así en C Sharp Si quiero acceder a este
primer ítem, el número dos, solo
pongo cero ahí, porque está en el índice cero. Si ejecuto el programa, ahora pueden
ver que aquí está dando salida al
número dos, que es nuestro primer ítem De igual manera, si queremos
acceder al número 12, solo
pongo uno y
puedo ejecutar el programa, y luego sale 12. Así que muy simple, así es como
realmente accedes a la
información en la matriz. Usas los corchetes, pero pones un
índice dentro de ellos. Si intentamos acceder a un
elemento fuera de nuestra matriz, por ejemplo el índice 45, bueno, solo tenemos seis
elementos en nuestra matriz. Si ejecutamos el programa,
va a arrojar un error. Y típicamente el error
dirá algo a lo largo la línea de que está fuera de
los límites de la matriz Eso es porque no
tenemos 46 artículos en nuestra matriz. Es sólo decirnos que la unidad no existe. No
sé qué hacer. Otra cosa que
podría querer hacer con una matriz es que podría
querer definir la matriz. Pero aún no sabemos
qué información queremos poner en él. A lo mejor queremos
definir la matriz aquí, y luego queremos hacer
algunas otras cosas interesantes. Y luego más adelante, más adelante
en la aplicación, tal vez finalmente sepamos qué números queremos
poner aquí. Por ejemplo, lo que
hacemos en este caso cuando
definimos el array aquí, queremos poner como
una capacidad aquí. Aquí dice, si realmente pasamos el
cursor sobre esta línea roja, creación de
matrices debe tener un tamaño de
matriz o identificador Básicamente, es decir, ¿
cuántos elementos tendrá en su matriz cuando
quiera usar su matriz? Sé que voy a tener seis
números porque es como un. por
ejemplo, podría ser una aplicación de lotería donde sólo
hay seis números. Lo definimos con un cinco aquí. Si el índice empieza en cero, entonces tenemos 012345 Al poner un cinco aquí, estamos diciendo que vamos a poner seis números en esta matriz. Espero que eso tenga sentido. Ahora hemos definido la matriz, ahora todavía necesitamos
inicializarla porque
no tenemos valores aquí por defecto, si intento acceder a
los valores en la matriz, aunque
no haya valores aquí, va a generar cero porque este es el comportamiento
predeterminado Lo que quiero hacer ahora es
poner un valor en la matriz. Entonces voy a poner un valor en la primera ranura que
es el índice cero. Y voy a poner aquí
el número 777. Ahora cuando ejecuto la
aplicación, puedes ver, podemos ver el valor 777 y
así es como
inicializas realmente un ítem en tu array Del mismo modo, si voy a la siguiente línea y trato de
poner un valor en la siguiente, Visual Studio en realidad está prediciendo lo
que podríamos querer hacer aquí Aquí se ven estos
personajes grises. Eso es básicamente
decir si presionas Tab en tu teclado.
Entonces hagámoslo. Va a entrar en eso para nosotros, lo que ahorra mucho tiempo a la
hora de programar. Entonces podemos poner eso
ahí, por ejemplo. Entonces podemos acceder al índice uno, que debería ser el
valor 456, que es. Así es como
poner valores en nuestra matriz, porque solo hemos definido una matriz que puede
contener seis elementos. Del mismo modo, si tratamos de
poner un valor en el slot 45, también
va a arrojar
un error, porque estamos fuera
de los límites Lo último de lo que voy
a hablar con rayos, lo primero antes, lo último, Rayos, es uno de los muchos
tipos de colección que puedes usar en C Sharp. Hay listas de matrices,
listas, diccionarios. Esto es algo para
comenzar con cómo administrar muchos
datos, por ejemplo. Lo último que
voy a repasar rápidamente es tus arreglos pueden tener
prácticamente cualquier tipo de datos. Podemos tener una matriz de
cadenas, por ejemplo. Esto podrían ser los nombres de la gente. Entonces tenemos que asegurarnos
cuando lo inicializamos, realidad coincide con
el tipo de datos Eliminemos eso ahora. Podemos poner algunos nombres aquí. Podemos poner a Henry. Podemos poner en nuestro
amigo Bob, etcétera. Ahora tenemos una matriz de cadenas. Bien, cuando accedemos a nuestra matriz, podemos hacerlo
exactamente como antes. Y ahí está el acceso Henry, que es el primer ítem ahí. Cuando ejecutamos la aplicación, se
puede ver que da salida a Henry. Recuerde, cuando define una matriz con un tipo de datos de
cadena, todos los valores deben
ser cadenas. Del mismo modo, si tienes
una matriz de enteros, tienes enteros aquí
26. 6-1. Bucles mientras: Ahora para algo
completamente diferente, voy a introducir
looping en C Sharp Para introducir el bucle,
voy a introducir
el bucle de alambre Considera este ejemplo. Aquí tengo un contador de números. Tan pronto como abrimos el software, se está diciendo al usuario,
bienvenido al contador de números. Por favor ingrese un número, 1-3 Vamos a ejecutar la aplicación. Cuando ingreso el número
tres, por ejemplo
, cuenta al
número, ingreso 123. Si entro el número dos, entonces contará hasta el número dos. Esto está representado
por estas series de declaraciones if y else if. Si el usuario ingresa dos, solo emite 123123 Cuenta hasta el número
que ingresa el usuario. No obstante, considere si queremos
modificar esta aplicación y pedir al usuario un número
1-1 mil, por ejemplo. Ahora como
representaríamos esto con declaraciones
if para cada número, tendríamos todo este bloque. Si tenemos el número cuatro, entonces vamos a
agregar otra
sentencia else if aquí, poner
en el número cuatro. Después agrega otra línea aquí
donde contamos hasta el número cuatro. Pero si vamos hasta mil entonces esto
va a ser enorme. El tamaño del archivo de nuestro
software será enorme, será muy lento de ejecutar. ¿Cómo resolvemos este problema? Bueno, podemos representar toda esta lógica aquí usando un bucle. Vamos a usar un bucle while. Déjame escribir
el formato de bucle y. Entonces se puede ver, al
igual que la declaración, se ve bastante similar. Consideremos la declaración if,
tenemos una condición. Si la condición
se evalúa como true, entonces esta línea de código
se ejecuta una vez Si la condición es falsa, pasa a la siguiente declaración if y comprueba esta condición. Si eso es cierto, ejecuta
este bloque de código una vez. Sin embargo, con un bucle de alambre, si esta condición es cierta, entonces seguirá repitiendo
el contenido aquí. Si pongo consola línea
derecha es uno. Si esto se evalúa como verdadero, entonces solo seguirá
repitiendo esto una y otra
y otra vez hasta que esto se
evalúe como Así es como
funciona un bucle de alambre en principio. Echemos un vistazo a nuestro
ejemplo y cómo podemos modificar nuestra aplicación
para hacer todo esto
si la lógica aquí en un
solo bucle de cable. Borremos todo eso. Lo que quiero hacer es que quiero que este bucle de cable
siga haciendo bucle, bucle, y dando salida número hasta
el
número Este es el número del usuario
que van a ingresar. Y queremos que el bucle
de alambre siga bucle hasta que se alcance este
número Bien, ¿cómo lo hacemos? Voy a introducir una nueva variable y
voy a llamarla contador. Y voy a
inicializarlo a uno. ¿Qué contador será? Este es el número que va
a seguir incrementando 123 hasta el
número que nos da el usuario Lo que quiero hacer es el
contador de salida a la pantalla. Cada vez que este bucle de alambre se enrolla, quiero dar salida al
valor del contador. Comienza en uno
y luego quiero
incrementar contador
por uno cada vez que lo que podría hacer es igual a sí mismo más un contador
tiene el valor de uno, pero ahora quiero que se iguale
a sí mismo, que es uno, y
luego agregarle uno Ahora después de esto, el contador
será igual a dos. Si vuelve a funcionar, el contador
será igual a 34, etcétera. Ahora, cada vez que añades
uno a una variable, puedes hacerlo de esta manera o
puedes hacerlo de esta manera. Así como así. Este plus plus agrega uno
al valor actual. Esa es solo una
forma taquigráfica de escribir esto. Es exactamente lo mismo. No funciona
con dos, sólo uno. Si quieres
decrementarlo en uno, usas negativo,
negativo y eso restará uno
de su Pero solo queremos agregar uno. Cada vez
que este bucle de alambre bucles, va al contador de
salida uno, va a agregarle uno y luego va a
volver al inicio, comprobar la condición,
Si sigue siendo cierto, va a ejecutar
estas dos líneas de código. Nuevamente, así es como funciona
el bucle de alambre. Va a seguir dando vueltas, pero ahora necesitamos una condición La condición debe
evaluarse como true
hasta llegar a lo que
el usuario ingresó, y luego necesita escapar del bucle de cable y continuar
con el resto del software. ¿Qué condición podemos poner
aquí para que esto sea cierto? Bueno, queremos contar
hasta el número del usuario. Incluyendo el número del usuario. Lo que queremos hacer es
decir mientras el mostrador. Es menor que el número del usuario, luego repita este código. Sin embargo, también queremos incluir
el número del usuario. Cuando termine de contar, será
menor o igual a. Vamos a ejecutar esta aplicación muy rápido para que podamos
echarle un vistazo a esto. Ahora, ingrese un número
1-1 mil. Escribamos el número siete, por ejemplo, y presionemos Intro. Puedes ver aquí cuenta
todo el camino hasta siete
desde el número uno. Así es esencialmente como funciona
un bucle de alambre. Si
volvemos a ejecutar la aplicación y tecleamos 1,000 cuenta hasta
1,000 y luego se detiene
en 1,000 Se puede ver con poco código en absoluto, podemos replicar todas esas declaraciones
if y else if En un
bucle de cable muy simple como éste, solo así estamos 100% claros, el software se ejecuta,
toma el número del contador de usuario
se inicializa a uno Este es ahora uno, mientras que uno es menor o igual a cualquier número que
el usuario ponga aquí. Digamos que el usuario ingresó 44, mientras que uno es
menor o igual a 44 Continuar este
contador de salida de
ejecución de código a la pantalla,
que será uno. Y luego aumentar el
contador en uno. Ahora esto va a igualar dos. Ahora contador equivale a dos. Sí, sigue siendo menor
o igual a 44 otra vez. Ahora contador equivale a tres, sigue siendo menos de 44. Sigue continuando con esto.
Una vez que el contador es igual a 45,
bien 45 no es
menor o igual a 44. Lo que pasa es que
estalla de aquí, salta hasta aquí, y continúa con el resto del programa. Así es esencialmente como funciona el bucle de
alambre en una tienda. Quiero hablar de
algo muy importante. Ahora estamos introduciendo loops. Con bucles de alambre y
cualquier otro bucle de los que hablaremos en el futuro. Existe un peligro real de
bucles en bucle para siempre. Solo son bucles interminables. Lo que sucede cuando obtienes
un bucle sin fin es que poco
a poco se va a comer la memoria en tu sistema hasta que o bien
no quede memoria o algo se desborda o algo
catastrófico pueda Esto es un verdadero peligro aquí. Echemos un vistazo a
un ejemplo muy pequeño. Recuerda con declaraciones if, aquí
hay una condición. Si eso se evalúa como verdadero, entonces va a
ejecutar este código
aquí mismo que puede que simplemente
escriba true aquí Lo que pasa es que esto
siempre
es cierto, siempre va a evaluar a verdad porque ahí he
escrito cierto, nada está cambiando
esto en este código. Incluso Visual Studios
califica esto porque sabe que solo
va a hacer un bucle en esto para siempre. Este es un ejemplo muy básico. Por supuesto, esto se puede
lograr mediante el uso de variables que nunca alcanzan
su valor esperado. Por ejemplo, esto simplemente
seguirá funcionando para siempre si
ejecuto el programa. Ahora puedes ver que
simplemente está contando sin cesar. Y lo que va a
pasar es que o este número va a crecer
demasiado grande para su contenedor, o nos vamos a quedar sin
memoria en nuestro sistema. Pero esencialmente este bucle
simplemente nunca terminará y algo hará que
este programa se bloquee. Entonces podría ser la memoria,
podría ser cualquier cosa. Y por lo general es algo
muy inesperado. Entonces este es un ejemplo de donde un bucle puede potencialmente
bucle para siempre. Esto es bastante común, y
es por eso que tenemos que
probar el software para
asegurarnos de que esto no suceda, pero ahora estamos introduciendo loops. Este es un peligro real
que puede suceder, y es algo que debes
tener en cuenta para seguir adelante.
27. 6-2. Haz bucles en while: Voy a introducir
una variante en el bucle Wile
llamada Il loop Hay una
diferencia muy sutil entre el bucle Wile y el bucle Il La diferencia es
que en un bucle Il, el código dentro del bucle se ejecuta al menos una vez.
¿Qué significa eso? Consideremos esta aplicación
de muestra aquí. Bienvenido al contador de números. Obtenemos un número
del usuario, 1-1 mil. Luego de uno sacamos
en incrementos de uno, los números hasta
el valor del usuario Si el usuario ingresa siete, cuenta hasta siete y luego continúa con el
resto del programa. Podemos usar lo que
se llama un bucle Wile para lograr prácticamente lo
mismo aquí Cuando llegamos al bucle de alambre, aquí tenemos una condición. El código ejecuta esto,
esto, esto, luego
llega a este bucle de alambre Si esta condición es
falsa desde el principio, entonces este código
nunca se ejecutará. Todo el bucle
de cable se omitirá si esta condición es
falsa y el resto del software continuará
ejecutándose con un bucle i Ahora bien, este no es el caso, es
decir porque la condición
en un bucle ocurre una vez. El loop ya
se ha ejecutado al menos
una vez. Considera esto. Ahora bien, esto hace exactamente
lo
mismo que la otra pieza de código. El software ejecuta,
esta línea de código se ejecuta. Esto, obtenemos la entrada del usuario, inicializamos esta variable Ahora llegamos a esta
declaración, bueno, nada
nos impide entrar aquí. Esto es ex, esto
se ejecuta esto. Y entonces tenemos nuestra condición. Estas dos líneas de
código ya
se han ejecutado antes de que
obtengamos nuestra condición. Y la condición dice, ¿el contador es menor
o igual al número? Ahora bien, si esto es falso
desde el principio, incluso
podría escribir false aquí. Entonces estas dos líneas de código ya
ejecutaron, ya ejecutaron. Aunque la condición sea
falsa, éstas siguen funcionando. Y luego seguimos con
el resto del software. Considera este ejemplo. No importa
lo que ponga aquí. Ahora se puede ver como salida
una al menos una vez. Eso es porque estas dos líneas
de código ya se han ejecutado. A pesar de que la
condición era falsa. Un bucle wile es
útil cuando desea que el código de su bucle
se ejecute al menos una vez Si no lo haces, entonces considera
usar un bucle Wile en su lugar. Pero ambos pueden lograr
prácticamente el mismo resultado. Pero esa es la
diferencia entre el bucle Wile y el Wile
28. 6-3. Para bucles: Voy a introducir
un bucle diferente ahora llamado bucle cuatro. Un bucle de cuatro es sólo otra
forma de lograr un resultado. Tiene ventajas y desventajas
dependiendo de su aplicación. Considere este ejemplo aquí, donde le pedimos al
usuario un número y simplemente cuenta a ese
número usando un bucle Wile y emite cada número a lo largo nuestro camino Con un bajo cuatro bucles
son ligeramente diferentes Ves este bucle Y aquí, definimos una variable
justo encima de él, y luego incrementamos
esta variable uno cada vez que
este bucle wile itera Cuando la condición es
falsa, se desprende de ella. Puedes ver aquí que hemos
agregado algunas cosas extra
al bucle de alambre para el bucle de alambre
logre su objetivo. Ahora un bucle de cuatro, tiene un mecanismo incorporado que incluye un
contador así. Va a simplificar todo este código en 14 declaración. Ahora bien, ¿qué significa todo eso? Déjame explicarte. Comenzamos un bucle de cuatro con la
palabra clave cuatro así como así. Entonces el encabezado está entre paréntesis, al
igual que el bucle de alambre. Y luego tenemos
las llaves rizadas. El encabezado para un bucle de cuatro, en
realidad tiene un
poco de información extra. El bucle de alambre aquí
tenemos la condición, eso es lo único que
tenemos aquí. Pero el bucle cuatro, en
realidad requiere la definición del contador y el incremento
del contador El encabezado requiere de
tres cosas. Eso es porque el bucle
cuatro maneja nuestro contador porque necesita
conocer esta información, pero también necesita
conocer la condición. Y así es como entramos
y salimos del bucle cuatro. Por ejemplo, al
igual que un bucle while, necesita tres piezas
de información. Voy a usar exactamente
los mismos nombres aquí, tal vez con un número
uno después No puedo usar variables
con el mismo nombre. Voy a copiar donde
inicializamos nuestro contador aquí. No puedo tener el mismo nombre. Voy a poner un
número uno después de él. Lo siguiente que necesito
es la condición. Separamos estos tres
elementos usando un punto y coma. Entonces vuelvo a poner la condición, no
puedo tener el mismo nombre. Entonces el último,
necesito el incremental,
otra vez, no puedo tener el mismo
nombre que el bucle de alambre de arriba. Ahora bien, esto es básicamente exactamente
lo mismo que arriba, aparte de esta línea de aquí,
que voy a poner aquí. Ahora bien, este bloque de aquí hace exactamente
lo mismo que todo esto. Aquí puedes ver
la ventaja en este caso de un
bucle de cuatro sobre un bucle de alambre. Eso es porque realiza un seguimiento de nuestro contador cuatro automáticamente
detrás de escena Cada vez que los cuatro
bucles iteran, este contador se
incrementa en uno cada vez Si queremos, podríamos
incrementarlo en dos cada vez que vayamos contador es igual al
contador uno más dos Y eso incrementará el
contador en dos cada vez, por ejemplo, podríamos
incrementarlo en ocho cada vez Realmente depende de nosotros lo que queremos hacer con
el incremental. Pero normalmente verás que gente lo
incrementa en uno cada vez Hay ciertos
casos en los que es posible que
desee disminuir el valor
en uno cada vez. De veras depende de ti,
ese es nuestro incremento. El tercer artículo, el
artículo del medio es nuestra condición. Entonces es exactamente lo mismo que
un bucle de alambre en ese caso. El primer ítem es donde
definimos nuestro contador. Entonces tenemos que decir, oye, estamos configurando una nueva variable y la inicializamos a una En este caso, podemos
inicializarlo a cero si queremos, pero sí tenemos que inicializarlo No podemos dejarlo en blanco, lo
inicializamos a uno En este caso, esto hará exactamente lo
mismo que esta pieza de código. Aquí, permítanme
demostrarlo. Ahora aquí está nuestro bucle. Vamos a ingresar
el número siete. ¿Por qué no? Se puede ver
que cuenta hasta siete. Ahora voy a quitar nuestro bucle
while por completo y poner en nuestro bucle cuatro
descompuesto, mucho menos líneas de código. Voy a ejecutar
la aplicación, voy a poner
el número siete, y hace exactamente
lo mismo que el bucle de cable. Es genial, ¿no?
29. 6-4. Para bucles en contra de los while: Tienes que hacerte
la siguiente pregunta. Si un bucle de cuatro tiene toda
esta simplificación, tiene incorporado,
incremental aquí ¿Por qué no siempre usamos esto? ¿Por qué siquiera molestarse con un bucle
de alambre, por ejemplo? Bueno, en general, se utilizan cuatro
bucles cuando sabemos cuántas veces va a iterar
el bucle Por ejemplo, cuando el
usuario ingresó ese número, estamos contando desde uno, estamos incrementando en uno, y estamos escapando del bucle cuando
el contador es
menor que una cierta Esta sección aquí
dará salida a los números 1-10 cada vez que
incremente en uno Y cuando
finalmente ya no sea menor o igual a diez,
se va a escapar. Sin embargo, con un
bucle de alambre podemos hacer eso, pero los bucles de alambre son
mejores cuando no
sabemos el número de
iteraciones de antemano Por ejemplo, ¿tengo hambre? Inicialicemos una
variable booling llamada am I hambre, y pongámosla en true
porque tengo Ahora cuando entramos en el bucle de alambre, no necesitamos saber cuántas
veces va a hacer un bucle. No necesitamos hacer un seguimiento de un contador o de todas estas
cosas, realmente no necesitamos. La única condición que tenemos aquí, por ejemplo, ¿tengo hambre? Bueno, sí, cierto.
Bien, es verdad. Entonces dentro del bucle wow, podemos llamar a un método
llamado comer comida. Y luego podremos comprobar
si volvemos a tener hambre. Y entonces podemos seguir dando vueltas. Por último, una vez que hemos
comido suficiente comida, ya no
tengo hambre, entonces puedo escapar de esto. Pero no sé cuántas veces este bucle va a
recorrer hasta que esté lleno. Entonces es un desconocido. Entonces esta es la razón por la
que los bucles de alambre son buenos para esto porque
no sabemos cuántas iteraciones
va a suceder Pero lo averiguamos
dentro del bucle mismo. Es por ello que los bucles de alambre son buenos. desconoce el número de
iteraciones, y es por ello que cuatro
bucles son buenos Cuando realmente conocemos el
número de iteraciones, podemos simplificar esto mucho
más fácilmente con un bucle de cuatro
30. 6-5. Bucles de Foreach: Voy a introducir
un nuevo bucle ahora, y se llama un
cuatro cada bucle. Ahora bien, la ventaja de un bucle de
cuatro cada uno sobre, digamos, un bucle de cuatro, es que
mejora la legibilidad Y funciona con colecciones
mucho más fácil. Ahora bien,
¿qué significa todo eso? Bueno, vamos a echar un vistazo. una aplicación de muestra aquí. Estoy configurando una matriz. Es una matriz entera, y la matriz se llama números. Estoy inicializando la matriz con todos estos números aquí Todos estos números
van a estar dentro de esta variable
llamada números. Ahora estoy usando un bucle de cuatro, que va a
recorrer cada número en la matriz a su vez y luego
sacarlo a la pantalla. Ejecutemos la aplicación aquí. Puedes ver aquí la aplicación contiene cada uno de los
números de nuestra matriz. Solo estamos
recorriendo nuestra matriz y dando salida a cada
número en el camino Usamos la propiedad length de la matriz para establecer una
condición para eso. Lo que voy a hacer ahora es
introducir los cuatro cada bucle. Lo primero que dije fueron los cuatro que cada bucle
ofrece legibilidad Echemos un vistazo a eso ahora, al configurar un cuatro cada
bucle, usamos la palabra clave. Para cada uno, tenemos
los paréntesis, igual que una sentencia if normal Cuatro enunciados y
loop, por ejemplo. Entonces tenemos los
rizados familiares. Echemos un vistazo a cómo se ve
un cuatro cada bucle. Voy a hacer exactamente lo mismo que
el bucle de cuatro. Por lo que se puede ver representado
como un cuatro cada bucle. En la cabeza de los
cuatro cada bucle, configuré una variable, digo en números. Entonces para cada iteración
de los cuatro cada bucle, quiero dar salida a
la variable num Ahora bien, ¿qué significa todo esto? Bueno, para empezar, se puede ver la legibilidad es mucho mejor Aquí hay mucho menos código. Se ve mucho más ordenado, más pequeño, y es menos hinchazón Pero, ¿cómo funciona? ¿Qué
pasa aquí en un bucle cuatro? Puedes ver que
configuramos una variable aquí. Cada iteración podemos hacer uso de esta variable aquí mismo Esto es lo mismo en
un bucle de cuatro cada uno. Por cada vez que esta iteración, esta variable será igual al
siguiente valor en nuestra matriz La primera vez que esto ejecuta
la primera iteración, num va a ser igual a uno La segunda vez que este bucle, num será igual a cuatro. La tercera vez nueve. Por ejemplo, en un bucle de cuatro, esto es igualar el índice Debido a que solo estamos
contando desde cero, estamos incrementando cero uno y lo estamos
terminando cuando num es igual o
mayor que la longitud de los
números en la matriz Sin embargo, en un bucle de cuatro cada, esta variable aquí en realidad
es igualar los valores en la
matriz, no el índice El índice es 0123. Pero en un bucle de cuatro cada uno, Numb será igual al
valor real, 14912, etcétera. Sólo estamos sacando
eso a la pantalla. Verás aquí estamos usando
un índice en el bucle cuatro para acceder al número
detrás del índice 149. Pero en un bucle de cuatro, en realidad
se establece como el valor
num es el valor. Sólo estamos sacando
el valor a la pantalla. Déjame probarte eso
si ejecuto la aplicación. Ahora puedes ver que está dando salida a todos los
números de la matriz aquí Lo segundo que dije fue que funciona
mucho mejor con colecciones. Ahora hemos usado una
matriz estándar como esta matriz entera, pero hay muchos
más tipos de matriz y colecciones en C
Sharp por ejemplo, como listas y varias cosas
así para cada
una ofrece una mejor legibilidad
con esas y te da más opciones
para trabajar con ellas también Ese es el beneficio
de un para cada bucle. Se puede ver como es
mucho más legible. No necesitamos definir esta variable aquí y hacer un
seguimiento de un contador. Es muy sencillo
en ese sentido. Es decir, otro bucle en agudo, y es el para cada bucle.
31. 6-6. EJERCICIO - Dibuja un cubo: Ahora voy a poner a prueba
tus conocimientos. Ahora hemos cubierto algunos bucles. Y vamos a dibujar un
cubo. ¿Qué significa eso? Bueno, por ejemplo, si el
usuario ingresa el número cinco y presionamos Enter,
dibuja el cubo. Se puede ver que hay cinco Asterix
está al otro lado y cinco abajo. Si el usuario ingresa seis, entonces será seis de
ancho y seis abajo. ¿Cómo logramos eso? Echemos un
vistazo al código aquí. Ahora, no está haciendo
mucho ahora mismo. Estamos pidiendo
al usuario que ingrese un número, y luego estamos
almacenando su respuesta en una variable llamada num. No estamos haciendo nada. ¿Cómo abordamos este problema? ¿Cómo dibujamos estos cubos? Bueno, necesitamos un mecanismo para
seguir dibujando Asterixes en la pantalla hasta
llegar al número del usuario Cuando algo sigue
haciendo algo, pensamos bucle en nuestra cabeza. Necesitamos algo para
seguir haciendo algo, necesitamos algo para seguir dando
vueltas en nuestra cabeza Deberíamos pensar, bien,
necesitamos un bucle aquí. No estoy seguro de cuántos bucles
o qué tipo de bucle, pero sé que necesito un loop, Así que ese es un buen comienzo. Ahora, cuando hablé de cuatro
bucles versus bucles de alambre, dije que un bucle de cuatro es bueno cuando sabes cuántas iteraciones
va a hacer Se puede usar un bucle de alambre, pero sólo estoy diciendo que un
bucle de cuatro sería mejor. En este caso, sí sabemos cuántas iteraciones porque
tenemos el número que ingresó
el usuario, que será del
tamaño del cubo Un bucle de cuatro
sería un buen comienzo para no abordar este problema, comencemos a crear un bucle cuatro usando la palabra clave de cuatro aquí. Ahora el formato de los cuatro
bucles. Se necesitan tres cosas. Necesitamos inicializar
una variable. Voy a llamarlo y, voy a
inicializarlo a cero Ahora necesitamos nuestra condición. Quiero que siga en
bucle hasta que sea
menor que lo que sea que haya ingresado
el usuario Entonces solo quiero
incrementarlo en uno cada vez. Ahora quiero sacar un
Asterix en la pantalla. Eliminemos eso y
pongamos un Asterix. Ejecutemos nuestro programa y
veamos qué tenemos hasta el momento. Ingresemos el número cinco. Se puede ver que tenemos al
Asterix bajando. Tenemos cinco Asterix. Todos van en vertical. Ya lo tenemos a mitad de camino
. Pero lo que tenemos que hacer es que los Astrixes
crucen también Cada vez que este bucle de
cuatro
itera, está dibujando un Asterix e
yendo a la siguiente línea,
dibujando un Asterix, pasando a Cada iteración
necesitamos algo de poner. Asterix también va por
este camino. Cada vez que el bucle itera, ¿cómo conseguimos algo para seguir haciendo algo?
Bueno, eso es un bucle. Lo que podríamos hacer es poner
un bucle dentro de un bucle. Echemos un vistazo a eso. No podemos tener el mismo nombre de
variable dos veces. Se puede ver y es
utilizado por este bucle. Vamos a necesitar
cambiar el nombre de éste. Llamemos a éste X sin ninguna
razón real. Puede ser lo que sea. Puede ser hamburguesa con queso si
realmente quieres. Ahora tenemos dos bucles. Tenemos lo que se llama
un bucle anidado. Un bucle dentro de un bucle. Cada vez que este bucle
itera, está haciendo todo
esto. Considera eso. Así que vamos a ejecutar el programa ahora y ver a qué
nos enfrentamos. Entro el número cinco y ahora, guau, ¿qué está pasando ahora? Tenemos 25 estrellas bajando. Eso está un poco mal, ¿no? ¿Por qué está haciendo
eso? Eso es porque cada vez que se ejecuta este bucle
, ejecuta este bucle. Y cada vez que se ejecuta este bucle, en realidad
estamos escribiendo
el Asterix aquí, pero también una nueva línea Y ahora eso es un problema para nosotros. No queremos escribir una nueva
línea cada vez que esto se ejecute. De lo contrario sólo vamos
a conseguir Astrixes verticales. Lo que podemos hacer, podemos introducir un nuevo método llamado, derecho. Lo que eso hace, escribe
todo en esta cadena aquí, todas estas cosas aquí. Pero no pone una
nueva línea después. Lo mantiene en la misma línea. Esa es la diferencia
entre la línea derecha que escribe esto y
luego pone una nueva línea. Sin embargo, justo solo escribe esto y no
pone una nueva línea. Echemos un vistazo a esto. Ahora entremos el número cinco. Ahora se puede ver,
oh, todos los Asterix van a través del eje X. Ahora todos van a través de
lo que está pasando aquí. Bueno, eso es porque en realidad no
estamos escribiendo ninguna línea en absoluto ahora. Es sólo que más o menos
escribir de una manera. Tengo que empezar a poner
esas nuevas líneas. Ahora mismo tenemos 25
Asterix está atravesando. Quiero una nueva línea
cada cinco de estos. Ahora sabemos si el usuario
ingresa el número cinco aquí, Este bucle interno
iterará cinco veces Una vez hecho su quinto, el código terminará este
bucle y continuará ejecutando el resto del código hasta que el primer bucle comience
de nuevo. Justo aquí, necesito
entrar en una nueva línea. ¿Cómo ingreso a una nueva línea? Hay muchas maneras, pero usando el conocimiento que ya
conocemos, podemos simplemente hacer eso. No estamos escribiendo nada. Pero luego agrega esa línea
después. Vamos a ejecutar esto. Ahora vamos al número seis, solo para demostrar que no
es una suerte, en realidad
va a crecer un cubo más grande para un número
diferente Ahora tenemos 123456 a
través de 123456 abajo. Nosotros prácticamente lo hemos hecho. Vamos a repasar
este código muy rápido. Podemos tomar el número del usuario. Ahora tenemos un bucle anidado. La primera vez que este
bucle
itera, ejecuta este código aquí, que también es otro bucle Ahora entra aquí y saca un Asterix
a la pantalla Por ejemplo, si el usuario
ingresa el número cinco, reemplacemos eso.
Es más legible. Esto va a correr
cinco veces. Ahora tenemos cinco
Asterix en la pantalla. Una vez terminado este bucle, ahora el bucle ha terminado. Ahora vamos a imprimir
una nueva línea en la pantalla. Hemos entrado en una nueva línea, va a quedar así. Ahora estamos iniciando nuestro bucle por segunda vez, el bucle principal. Una vez iniciado esto, vuelve a ejecutar este bucle cinco veces. Ahora se va a
quedar así. Una vez terminado el bucle, imprime una nueva línea. Ahora se ve así, luego vuelve a la cima. Así es como funciona, para que puedas visualizar
lo que está pasando aquí. La respuesta a nuestro problema. Si queremos cubo
y queremos dibujar Asterix está
bajando, entonces un bucle Pero si también queremos que bajen y crucen
, entonces consideremos algo así
como un bucle anidado Así es como podemos abordar este problema usando
bucles en sharp.
32. 7-1. Declaración de descanso: Entonces voy a
introducir un nuevo tipo de declaración llamada
la declaración break. Ahora cuando
hablamos de declaraciones de cambio aquí cubrimos brevemente
la declaración break, pero no realmente con ningún detalle
significativo. Pero ahora voy a explicar
exactamente qué hace esto y cómo funciona y cómo nos
puede beneficiar realmente. El descanso es clave. Al usar una sentencia switch, lo que sucede es que el usuario, por ejemplo, ingresa
un día de la semana. Almacenamos la respuesta
en una variable. Y entonces si ellos, por ejemplo, ingresan el miércoles, entonces esta
línea de código se ejecuta aquí. Una vez que se
ejecuta esta línea de código, esta sentencia break, se escapa de
esta sentencia switch y el flujo de control de
la aplicación continúa ¿Qué quiero decir con flujo de control? Bueno, cuando lanzamos
nuestro software, el método principal se
ejecuta automáticamente. Y luego se ejecuta la primera línea de
código, la segunda línea, y es secuencial,
corre todo el camino hacia abajo. Ese es el flujo de control, así es como se ejecuta tu
aplicación. Pero lo que pasa con la sentencia
switch es cuando el flujo de control alcanza
una palabra clave break aquí, en
lugar de ejecutar
la siguiente línea , la siguiente, la siguiente hasta abajo, golpea la palabra clave break, luego inmediatamente salta todo después de
que luego continúa Ese es el poder de
la declaración break cuando se usa en una declaración switch. Echemos un vistazo a cómo se
puede usar
la sentencia break en algo así
como un bucle de alambre. Echemos un
vistazo a un ejemplo sencillo aquí de lo que estamos haciendo, le
estamos pidiendo
al usuario que introduzca un número. Lo que hace este programa, el programa simple,
sólo estamos contando hasta ese número. Si ejecuto el programa aquí y el usuario ingresa
el número ocho, solo
estamos contando
hasta el número ocho. Muy sencillo. Estamos usando
un bucle Wile para hacer esto Tenemos una condición aquí. Estamos diciendo que si nuestro
contador es
menor o igual a la salida del número del
usuario, el contador entonces incrementa el contador en uno y solo
estamos haciendo un bucle Es muy sencillo cómo funciona. A veces, al crear un bucle, como un bucle de alambre por ejemplo, o incluso un bucle de cuatro, es
posible que no tenga una condición. En este caso,
configuramos una condición porque sabemos lo que va a ingresar el
usuario, y estamos contando hasta eso. Pero en algunos casos
no tenemos un padecimiento. No podemos tener una condición. Puede que no sepamos cuál es
el objetivo final y en realidad
podríamos resolver el objetivo final dentro de nuestro bucle de alambre. Ya sabes, algo podría
resolverse en una fecha posterior. Por ejemplo, si
descargamos un archivo
de Internet y lo
descargamos en
pedazos a la vez y
es posible que no sepamos el tamaño
del archivo que estamos descargando. Entonces en ese caso, podemos
configurar un bucle de cable y simplemente seguir bucle para siempre y para
siempre hasta que
se descargue el archivo En casos como ese,
no tenemos un padecimiento. Entonces lo que podemos hacer aquí es establecer una condición que siempre
sea cierta. Lo que esto va a hacer es loop indefinidamente hasta que, por ejemplo, hayamos descargado todo
el archivo y luego
podamos escapar
del loop manualmente Esto
también puede ser bastante común en el
caso en el que no tenemos una condición y solo tenemos este bucle de bucle
de alambre indefinidamente, lo que podemos hacer es salir de
este bucle de alambre para evitar
que se enrolle para siempre Esta es una buena manera de
usar la palabra clave break. Podemos usarlo en declaraciones
switch, pero también podemos usarlo
donde tengamos una condición
indefinida, que siempre es cierta Por ejemplo, echemos
un vistazo a este ejemplo. Y lo que voy
a hacer, voy a reescribirlo usando una palabra clave
break en su lugar, y va a hacer
exactamente lo mismo Digamos que no tenemos una
condición para este bucle de alambre. Va a circular indefinidamente. Necesitamos una manera de
salir de aquí, así no estamos atrapados
en un bucle sin fin. Lo que vamos a decir
es si el contador en algún punto es mayor que
el número que ingresó el usuario, luego se rompe del bucle. Puedes ver tan pronto como
escribí esa palabra clave break, esta palabra clave wire
también resaltada, y eso es Visual
Studio ayudándonos. Por ejemplo, podríamos tener un bucle de alambre dentro de
otro bucle de alambre. Dentro de un bucle de cuatro, podemos tener bucles en cascada. Y puede resultar bastante confuso a la
hora de usar una palabra clave. Break Visual Studio solo
está diciendo, bien, has escrito la palabra clave break, este es el bucle al
que está vinculada Y este es el bucle del que
vas a salir, igual que la declaración switch. Por ejemplo, esta palabra clave
break
evitará que este bucle
de cable se repita para siempre. Literalmente está diciendo, bien, esta condición
se evalúa como verdadera, salgamos de este bucle y continuemos con el
resto del programa La palabra clave brake está controlando el flujo
de ejecución del código. Básicamente es decir,
salgamos de aquí y continuemos con
el resto del programa. Eso es lo que esencialmente hace la
palabra clave brake. Ejecutemos el software y solo confirmemos que hace exactamente
lo mismo. Ingresemos el número
ocho por ejemplo. Se puede ver que está contando
hasta el número ocho. Usar la palabra clave brake es otra forma de lograr
el objetivo anterior, pero
se usa comúnmente, por ejemplo, cuando realmente no
tienes una condición y quieres
escapar de un bucle Esa es la potencia de la declaración de
frenos en C sharp.
33. 7-2. La declaración de continuidad: El
enunciado continuado, ¿qué es? ¿Qué hace? Ahora ya he
explicado la declaración break. Y una declaración break al
igual que un repaso te rompe de un bucle por completo y continúa con el
resto del programa Las sentencias break
se pueden usar en cuatro bucles. Bucles while, cuatro
bucles cada uno, todo tipo de bucles. Sólo para escapar fuera del bucle, No
es bucle indefinidamente Sin embargo, la sentencia
continuada, lo que hace es simplemente salta
una iteración de un bucle Lo que voy a hacer, les
voy a mostrar cómo funciona
la declaración continuada en un bucle de cuatro. Considera este ejemplo. Aquí, le estoy pidiendo
al usuario que ingrese un número sobre lo que
voy a hacer, voy a contar
hasta el número diez, pero voy a omitir cualquier
número que ingrese el usuario. Echemos un
vistazo a este ejemplo. Entonces voy a ingresar
el número seis, y puedes ver el resultado aquí. Estoy contando desde cero, voy hasta diez, pero me estoy saltando
el número del usuario El número seis. Va
5-76 se está saltando Estoy usando un bucle cuatro
para lograr esto. Estoy contando 0-10 estoy
usando una variable llamada. Estoy diciendo que si el contador
no es igual al número del usuario, entonces solo saca el
contador a la ventana. Un poco de trivia para ti, si has oído hablar del lenguaje de programación
C. Y además, más, ya hemos
hablado del incremento antes, donde se agrega uno a una
variable, le pones más, más. Ya puedes ver así es como, donde surgió plus plus, el
lenguaje de programación C plus, además, es solo uno
más que su predecesor. Eso es genial, ¿no? Si alguna vez te has
preguntado sobre eso. En fin, ¿cómo podemos lograr esto usando una declaración
continua? Echemos un vistazo a esto. Voy a reescribir esto
usando una declaración continua. Voy a decir si el contador actual es igual al número del usuario,
entonces continúe. Esto va a hacer
exactamente lo mismo. Esto de aquí,
déjame probarlo. Ingresemos el número seis. De nuevo, se puede ver
que en realidad se le saltó el número seis. ¿Cómo
funciona esto? Una cosa que notarás al escribir continue o al pasar el
cursor sobre él, al
igual que la declaración del freno, es decirte a qué
bucle está atado Hemos escrito
continuar. Es decir, bien, estamos atados a
este bucle de cuatro aquí. Por ejemplo, si el contador
actual es igual al número del usuario, entonces continúe. ¿Qué hace
continue? Evita que se ejecute
el resto del contenido dentro del
bucle. En cuanto se ejecute
esto continúe aquí, se va volviendo al inicio
del bucle cuatro y
continuando hacia abajo. Este código aquí nunca se ejecuta. Incluso si tengo mucho código
aquí, todo esto aquí, si alguna vez
se ejecuta esta sentencia continue, todo esto se ignora y
el flujo de control vuelve
al inicio del bucle. Seguimos abajo.
Nuevamente, está modificando el flujo de ejecución al
igual que lo hace la sentencia break. Pero cómo la
sentencia break se rompe completamente
del bucle
y continúa la sentencia continue
solo evita que se ejecute el resto de la iteración actual
del bucle Y luego
vuelve al inicio y luego continúa haciendo un
bucle como de costumbre Esa es la diferencia entre
la declaración continuada y la declaración break
que puedo mostrarles. Ahora bien, si elimino esa
condición por completo, este bucle de cuatro simplemente
prácticamente no hará nada. Porque este código
aquí es inalcanzable. Incluso el estudio visual
se
gradúa, diciéndote que esto nunca
se va a ejecutar porque aquí no
tenemos una condición. Cada iteración de
este bucle de cuatro, solo
estamos golpeando esta declaración
continua Y sólo va
a seguir volviendo
al inicio en este
pequeño bucle aquí. Entonces ese es el poder
de la
declaración continuada en C sharp.
34. 8-1. Manejo de excepciones (prueba, atrapa, finalmente): Ahora quiero hablar sobre manejo de errores o manejo de
excepciones. Son sinónimos
en el mundo de C sharp cuando se trata
de excepciones, estos son resultados
que no esperas Si miras la excepción
en el diccionario, es una persona o cosa
que está excluida de una declaración general y más significativamente
no sigue una regla. Echa un vistazo a este
ejemplo aquí mismo. Le estamos pidiendo al
usuario dos números. Estamos poniendo su entrada, que es una cadena, en una variable
entera aquí mismo. Y estamos usando el
método para int 32. Para lograr ese objetivo, estamos tomando una cadena,
convirtiéndola en un entero. Lo segundo que estamos
haciendo aquí es dividir los dos números juntos y ponerlo en una
variable llamada result. Ahora bien este programa,
es bastante escamoso. Hay un par de errores que pueden ocurrir si no tenemos cuidado. Los errores generalmente pueden ocurrir
cuando estamos tratando con usuarios porque los usuarios hacen cosas
que simplemente no esperamos. En ocasiones si ejecuto
la aplicación, ingresa tu primer número. Ahora, ¿y si el usuario
solo escribe hola? ¿Y si lo leen incorrectamente y ponen su dirección de correo electrónico? Los usuarios pueden hacer cualquier cosa. ¿Y si accidentalmente
golpean a Enter y no
ponen ningún número? Hay muchas
cosas que un usuario puede hacer para potencialmente
romper su software. Estas se llaman cosas
inesperadas si
escribo muchas
letras y golpeo Enter. Ahora puedes ver aquí tenemos este pequeño mensaje de
error agradable aquí. Dice excepción inmanejada. Eso básicamente significa, bien, se ha producido
un error, se ha producido
una excepción. Y es inmanejable, lo que
significa que no estamos haciendo
nada al respecto. La computadora no puede hacer
nada al respecto a este error porque está tratando de
convertir esto en un número. Simplemente no puede hacerlo.
No sabe qué hacer. Entonces necesitamos decirle al sistema cómo manejar este
tipo de error. Si miro este software aquí, este error ocurre cuando
tomamos la entrada del usuario, luego intentamos
convertirlo a un número. Si coloco el cursor sobre
este método aquí, que estamos usando este método, a 32, puedes ver que aparece
este diálogo Nos dice lo que hace
el método. Nos dice lo que nos
devuelve el método como retorno. Pero también hay
esta pieza extra de información en
la parte inferior aquí dice excepciones. Ahora bien estos son los dos posibles errores que
se pueden producir al usar
este método a 32. El primero es la excepción de
formato. Ese es el error que
acabamos de experimentar. Tecleamos una palabra por ejemplo, entonces está lanzando lo que
se llama una excepción de formato. Eso es porque el
formato no es correcto. Se espera un número, tenemos algunas letras,
el formato es incorrecto. El otro error es una excepción de
desbordamiento. Estoy adivinando que es cuando
ingresas un número realmente
grande y no
puede encajarlo físicamente dentro del tipo de datos
que es un entero Ahora el entero de 32 bits va
a alrededor de 2 mil millones. Si trato de poner 5 billones, entonces probablemente
tiraría ese otro error,
que es la excepción de desbordamiento Lo que podemos hacer al respecto es
manejar este tipo de errores. Cuando la computadora dice, oh, me has dado una palabra, yo quería un entero, no
puedo convertir estas
palabras en un entero. Podemos interceptar esto y decir,
bien, los usuarios
ingresaron algunas palabras Ahora
te voy a decir cómo manejar
esto, así es como
afrontas este problema. El segundo error que puede ocurrir
es al dividir por cero, tomamos los dos
números del usuario. Suponiendo que hayan ingresado
dos números válidos, intentamos
dividirlos juntos. No obstante, si el segundo
número es un cero, entonces
se va a producir otro error. Si pongo cero, ahora
tenemos otro error. Ahora vuelve a quedar sin control porque no estamos haciendo
nada al respecto. Y este tipo de error es una excepción de
división por cero. El mensaje que estamos
tratando de dividir por cero. La computadora no puede hacer eso
físicamente. No sabe cómo
matemáticamente, no
puede dividir por cero Pero no le estamos diciendo
cómo sortear este problema. Ese es el objetivo de este
tutorial ahora mismo te
voy a mostrar cómo
podemos manejar las excepciones. Ahora bien este tema
va bastante a fondo, pero aquí sólo vamos a
raspar la superficie Lo que usamos aquí es una
palabra clave llamada tri. Es bastante simple, SECO
como la mayoría de las palabras clave. Tenemos nuestras llaves para
rizar familiares. Aquí terminamos un rizo, lo que está haciendo Tri es decir, puedes intentar hacer
algo por mí por favor? Porque tengo la sensación de que va a ocurrir un
error. Lo sabemos porque cuando
pasamos el cursor sobre este método, hay dos posibles
errores que pueden ocurrir Debido a que estamos pidiendo
comentarios para el usuario, sabemos que viene una señal
de problemas. Básicamente estamos diciendo,
por favor, prueba esto. Así es como funciona la
palabra clave tri. Estamos intentando algo. Ahora, ¿qué pasa si esto falla? Un intento tendrá éxito y
el programa se ejecuta normalmente, o puede ocurrir un error. Esa parte la palabra clave catch. Nuevamente, llaves rizadas,
igual que antes. Ahora bien, un intento no puede
existir sin una trampa. Si elimino la palabra clave
catch aquí, entonces obtendremos una línea roja. Si me cierro sobre eso, dice captura esperada O finalmente, volvamos a poner eso. La línea roja se ha ido. Es feliz en esta sección de
captura aquí, este código se ejecutará si se produce
un error aquí. Esto es decirle al sistema
cómo manejar este error. Digamos que se ha producido un
error. Digamos al usuario que se ha producido un
error. Muy genérica. Creo que
si viera este error, me molestaría como usuario porque
no tengo idea de lo que significa Es muy genérico, pero
podemos ampliarlo más adelante. Vamos a ver si funciona. Ingresa tu primer número, pongamos algunas palabras o letras. Ahora puedes ver que
tenemos un error genérico. Se ha producido un error ahora. Nuestro software no se ha estrellado,
así que eso es algo bueno. Pero en realidad no es contar
tanta información. Acabamos de recibir este mensaje
genérico. No sabemos por qué ocurrió, no
sabemos qué salió mal. No nos es muy útil, pero al menos nuestro
software no se ha estrellado Entonces esa es una buena señal. Ahora echemos un
vistazo a cómo podemos dar mejores comentarios
al usuario. No queremos
decirles que
se ha producido un error porque no es
realmente información útil. El usuario no puede entonces
volver atrás y averiguar
qué hizo mal. Lo que podemos hacer aquí al
lado para atrapar es abrir y cerrar
paréntesis y escribir en excepción y
luego darle un nombre Esto puede ser cualquier cosa,
podría ser EX, puedes llamarlo como quieras. Básicamente es una
variable que estamos
configurando el tipo de datos es
de tipo excepción. Justo como tenemos
un tipo de datos int, Este es una excepción. Ahora vamos a cubrir lo que
se llama una clase más adelante, pero no te
preocupes por eso por ahora. Pero ahora hemos definido
esta variable llamada E, que es de excepción de tipo de datos. Podemos usar esto para obtener alguna
información sobre nuestro error. Lo que voy a hacer aquí es cuando unamos
cadenas juntas, usamos un plus aquí. Voy a decir mensaje mensaje es una propiedad de cadena de esta variable de
excepción aquí, va a
darnos algunos comentarios, El mensaje de error que explica el
motivo de la excepción. Ahora si ejecuto la aplicación ahora e ingreso el primer número, que es un montón de letras, ahora tenemos un poco más de
información, se ha producido un error. La cadena de entrada no estaba
en el formato crack. Ahora, cuando el usuario lee esto, puede pensar, oh, bien, sí, leí mal la pregunta, pensé que estaba pidiendo mi dirección de correo electrónico o
algo así. Así que ahora estamos brindando información
útil al usuario. Ahora bien, ¿y si
queremos personalizar? ¿Qué va a pasar? Dependiendo del tipo de error que haya ocurrido. Ahora recuerda que hay un par de problemas con
esta aplicación. Un par de cosas
que pueden ocurrir. Número uno, el usuario puede introducir algunas letras y no puede
convertirlo en un entero. Ya lo hemos mirado. El otro es que
intentamos dividir por cero. Pero lo que está pasando
aquí es que
solo estamos haciendo esta
línea de código. Pase lo que pase aquí,
el error está ocurriendo. ¿Cómo podemos personalizar esto? Tal vez decirle al usuario que han
hecho algo mal. Si accidentalmente
ingresan algunas letras, entonces tal vez hagan otra cosa. Si dividimos por cero, lo que podemos hacer aquí es atrapar diferentes
tipos de excepciones. Si copio y pego esto, lo voy a poner aquí dos veces, y voy a explicar por qué pronto. La primera excepción aquí que puede suceder es
la excepción de formato. Lo que puedo hacer aquí es coger la
excepción de formato aquí mismo. Lo que va a pasar aquí es si se produce
una excepción de formato, cualquier error que ver con el formato, podemos decir al
usuario, no lo sé. Podríamos darles un mensaje
realmente sarcástico. Podríamos decir, aprender
a leer correctamente porque descaradamente
no leyeron la pregunta Que era ingresar
un número y luego ingresan su
dirección de correo electrónico, por ejemplo. El otro se
dividió por cero, ¿de acuerdo? Así que divide por cero excepción y el mensaje que podría
querer darle al usuario, hey amigo, no puedes
dividir por cero. Lo que haces entonces si
no es posible error y no
es posible error, entonces este es genérico. Cuando teníamos esa
declaración si, teníamos, entonces finalmente tuvimos
un else al final, similar con la
declaración switch, Teníamos el caso. Entonces al final tuvimos default. Esto es lo que eso
pretende hacer aquí. Entonces, si ninguno de estos
errores ocurrió, siempre
tenemos nuestra pequeña red de
seguridad en la parte inferior que simplemente escupe un mensaje
aquí en el mundo real, probablemente no tengas
solo un mensaje aquí Probablemente
tendrías que el sistema registrara estos errores de manera diferente y
estos errores de manera diferente. Pero esto es sólo un ejemplo. Entonces puedes ver ahora si
ejecuto la aplicación, pongo en una palabra, Ahora me está diciendo que aprenda a leer correctamente.
Encantador, ¿no? Ahora bien, si entro dos números, trato de dividir por cero. Oye Pájaro, no puedes
dividir por cero. Entonces ahora puedes ver que son dos cosas diferentes
dependiendo de qué error ocurrió. lo último de lo que quiero
hablar es de la palabra clave finally. Ahora la palabra clave finally
va con una palabra clave tri. Es opcional,
no tienes que usar uno, Pero puede ser bastante útil. Echemos un
vistazo a cómo funciona. Por último, iremos después
o después de todas las
capturas después del intento. Si se produce un error, se ejecutará
todo el código de este
bloque finalmente,
aunque se haya producido un error. Si no se produjo un error, entonces esto
también se ejecutará. Es bastante útil
tal vez si trabajas con una base de datos o lo que
se llama hilos, y puedes
cerrar conexiones o finalizar cualquier cosa que sea
realmente para lo que sirve Pero en nuestro pequeño ejemplo aquí, solo
podemos agradecer al usuario
por usar el programa. Por ejemplo, estoy agradeciendo al
usuario por usar el programa. Echemos un
vistazo a esto muy rápido. Si uso el software,
ingrese algo no válido, le
estamos diciendo al usuario que
aprenda a leer correctamente, luego diciendo gracias
por usar nuestro programa. Eso es bastante
sarcástico, ¿no? Ahora, ingresemos
algunos números válidos. Ahora obtenemos un resultado real. Aquí puedes ver el bloque finally
sigue siendo ejecutado. Gracias por usar nuestro programa. Se puede ver que finalmente se ejecuta independientemente de si ocurrió un
error o no. Como digo, es opcional, no
necesitas esto, pero puede ser bastante
útil, es decir, cómo atrapar y manejar excepciones cuando se
trabaja con C sharp.
35. 8-2. Arrays 2D, 3D y multidimensionales: Quiero introducir
el concepto de matrices
bidimensionales en C Sharp. Lo que hemos visto hasta ahora es una matriz
unidimensional estándar. Por defecto, una matriz en tienda
se considera una dimensión. No obstante, y si queremos
simular tal vez un
tablero de ajedrez, por ejemplo,
donde tenemos ocho
cuadrados que simular tal vez un
tablero de ajedrez, por ejemplo, donde tenemos ocho
cuadrados cruzan pero ocho
cuadrados también subiendo. Entonces podemos referirnos a esos
cuadrados en el juego de ajedrez, como un sistema de cuadrícula con x
atravesando e y subiendo. Podemos simular
esto usando lo que
se llama una
matriz bidimensional en la tienda. Veamos este ejemplo aquí. Acabamos de definir algunos
números aquí y los estamos almacenando en una matriz
entera llamada Numb Y solo estamos emitiendo el primer número de nuestra
matriz a la pantalla Si ejecuto la aplicación, el primer número de
la matriz es uno, lo cual es correcto porque
este es el primer número. Te voy a mostrar un ejemplo de una matriz bidimensional. Ahora bien, esta es nuestra matriz
unidimensional. Sólo voy a
quitar algunos números. El ejemplo no es largo aliento. Para convertir esta
matriz unidimensional
aquí en una matriz bidimensional, uso una coma dentro de estos
corchetes aquí Ahora eso es decirle a
C sharp, oye, quiero crear una matriz
bidimensional ahora mismo. Así es como
visualizamos nuestra matriz. Se ve algo así. Pero lo que quiero hacer es crear una matriz de dos D que se
va a quedar así. Porque la naturaleza
de dos dimensiones, tienes una dimensión
atravesando y otra bajando. Y luego se llena en
como algún papel cuadriculado, un tablero de ajedrez,
algo así Esto es lo que
queremos emular aquí. Ahora he puesto comas aquí, inmediatamente
obtenemos una línea roja porque C sharp sabe que estamos
creando una matriz de dos D. Pero este formato es incorrecto. El formato para una
matriz de dos D se ve así. Los tirantes rizados exteriores aquí son el contenedor
para todo Entonces dentro de cada conjunto de
llaves rizadas está cada línea aquí. Si copio esto y lo pongo
ahí, copia eso. Pon eso ahí.
Y copia eso. Y ponlo ahí dentro.
Ahora bien, esta inicialización aquí de las dos matrices
más o menos se ve así Esto es lo mismo que eso. Así es como deberías
visualizar esto. Ahora bien, ¿cómo
accedemos realmente a estos números? Nuevamente, este formato es incorrecto. Si pasamos el cursor sobre él, podemos ver aquí,
número incorrecto de índices Eso es porque
ahora se esperan dos. Debido a que aquí hemos creado
una matriz de dos, lo que podemos usar es
solo el sistema de comas, por
ejemplo, 00 Ahora que realmente dará salida al primer número en
el primer bloque. Aquí está el primer bloque, aquí está el segundo bloque. Aquí está el tercer bloque. Nuevamente, todos los índices
comienzan en cero. Este es el primero representado por el primer
número aquí, cero. El segundo número aquí, Este es el número del
ítem dentro del primer bloque, que es el primero
ahí, que debería ser uno. Esto debería sacar el
número uno
aquí mismo si ejecutamos la aplicación
ahí, número uno, Si cambiamos el segundo
dígito, por ejemplo, dos, luego 012, debería sacar número tres como se
puede ver ahí Si aumentamos esto a dos, entonces debería estar aquí afuera, porque es dos de
ancho y dos abajo, deberíamos obtener el número nueve. Ahí vamos. Así
es como acceder a la información de una matriz de dos
D en C sharp. Ahora puede que estés haciendo la
pregunta, ¿qué pasa con tres? ¿Qué pasa con cuatro arreglos? Consideramos estos dos. Ahora bien, este ejemplo se va
a poner demasiado loco. Eso es minimizarlo. Ahora esto se verá así. ¿Qué tal una matriz de tres? Bueno, sí, muy sencillo. Tomemos cada uno de estos y reemplacemos cada número
por un juego extra. Ahora bien, si pasamos el cursor por aquí, número
equivocado de índices
esperaban tres, entremos un tercero Ahora se puede ver que el sistema de
coordenadas está en tres dimensiones. Si ejecuto el programa ahora el primer número de la
matriz es uno, que es. Este es el primer ítem. Entonces puedes ver que esto es una especie
de concepto de dos matrices. Tres arreglos. Y ya sabes, puede continuar a partir de ahí. Y usted puede hacer la
pregunta, bueno, ¿a cuántas dimensiones
podemos ir? Bueno, la respuesta 32, si alguna vez
te lo estás preguntando. Así podemos tener hasta 32
dimensiones en una matriz en tienda.
36. 8-3. EJERCICIO - Ajedrez - Encuentra el juego de la reina: Ahora voy a hacer un pequeño
reto. Voy a poner a prueba
tus conocimientos sobre matrices
bidimensionales
y también en la resolución de problemas. Considera esta plantilla aquí, emula un tablero de ajedrez Si estás familiarizado con el ajedrez, entonces tal vez ya
lo hayas descubierto. Si no lo haces, no
te preocupes por ello. Vamos a crear una pieza de software para encontrar a
todas las reinas, que está representada por
una Q en este tablero de ajedrez Ahora bien, así es como se ve el
tablero de ajedrez. Tenemos un castillo, una rook, una reina obispo, y un
rey, todos los peones, algunas casillas vacías
representadas por cero, y las
piezas de los demás jugadores también Si no estás
familiarizado con el ajedrez, lo que queremos hacer
es encontrar la señal. Esta es una matriz de caracteres
representada por Shah. En un personaje, todos van entre comillas
simples y
solo puedes tener una letra dentro, lo contrario arroja un error. Lo que queremos hacer
es encontrar las señales en esta matriz bidimensional y luego
enviarlas a la ventana Entonces, ¿cómo hacemos esto?
¿Cómo encontramos algo? Aquí está nuestra matriz de dos D. ¿Cómo seleccionamos a estas reinas? Bueno, lo que queremos hacer,
queremos poner a prueba cada uno. Es esto una señal, ¿es esto una que, no, etcétera, etcétera. En tu cabeza,
deberías estar pensando, bien, un bucle. Necesitamos un bucle. Pero debido a que hay
más de una dimensión, tenemos que comprobar yendo a través. También tenemos que revisar, bajar, verificamos todos estos. Baje uno, revisa
todos estos abajo. Uno, revisa, todos estos. En tu cabeza, deberías
estar pensando, bien, necesitamos un bucle y
necesitamos dos de ellos. Ya sabemos cuántas
iteraciones necesitamos, porque tenemos ocho
atravesando y ocho bajando. Deberías pensar,
bien, 24 bucles. Cuatro, porque
conocemos el número de iteraciones y un bucle, porque tenemos que revisar
algo una y otra vez, Hagamos 24 bucles El primer bucle que voy
a hacer es el bucle y, y eso se moverá hacia abajo.
Empecemos con eso. Vamos a empezar con cero, porque todos los índices
empiezan en cero. Esto es leve 00
ahí, y es menos. Ahora queremos obtener la longitud
de esta dimensión aquí. ¿Cómo lo hacemos?
Tomamos el nombre de nuestra matriz de dos aquí, punto. Y luego queremos usar
el método get length. Cuando abrimos
paréntesis sobre
eso, me pide una
dimensión, bueno, esta es la primera dimensión, voy a poner cero aquí Eso obtiene la primera
dimensión y luego el punto y coma y se
incrementa en uno cada vez Ese es nuestro primer bucle. Ahora estamos haciendo un bucle hacia abajo. También necesitamos dar vueltas a través. Vamos a necesitar
otro bucle dentro nuestro bucle que
representará el eje x aquí. Queremos meter ahí dentro la segunda
dimensión, cual está representada por una. Ahora esto va a través de la
primera dimensión aquí abajo. Esto va a través de la
segunda dimensión a través de aquí. Ahora tenemos nuestros
dos bucles establecidos. Necesitamos verificar realmente
cada uno de estos valores. Podemos hacerlo usando
una sentencia if. Eso podemos decir
el valor actual si es una reina. Y entonces sólo
voy a decir reina
encontrada en este lugar. Sólo para que esto tenga sentido. Si el ítem en X, que está representado
por este bucle de cuatro, y X obviamente
se incrementa uno cada vez que cruza, eso va en la
primera ranura aquí Entonces el segundo es el
Y y eso se mueve hacia abajo. Lo que estamos haciendo, estamos
comprobando cada valor, vamos todo el camino a través
y luego hacia abajo uno a través, hacia abajo otro a través. Eso es lo que está haciendo el loop. Y cada vez estamos comprobando para ver si el slot es una reina. Si es así, la condición es verdadera, entonces estamos ejecutando esta
línea de código
aquí mismo eso es solo decir
reina encontrada en el lugar. Y estamos sacando X e Y. Veamos si esto funciona Ejecutemos la aplicación. Reina encontrada en la ubicación 03 y Reina encontrada
en la ubicación 73. Si tenemos razón,
03, esto es cero. Esto es todo de cero aquí mismo. 0123. Eso es correcto. El siguiente que creo fue 701-23-4567 Se puede ver que encontró
con éxito ambas reinas en este tablero de ajedrez Si quieres modificar eso,
podemos encontrar a los reyes, y luego solo podemos
encontrar una K en su lugar, y eso encontrará a los
reyes en el tablero. Ese fue un reto bastante divertido. Si algo de esto resulta confuso,
repasarlo de nuevo. Puede que no lo consigas la primera vez, no te preocupes por eso. Pero poco a poco lo
entenderás cuanto más
puedas ver este video y
entender el problema. Pero eso es como
un ejemplo del mundo real donde simulamos un tablero de ajedrez, por ejemplo, cuando trabajamos
con dos matrices D en C Sharp.
37. 8-4. Listas: Ahora voy a introducir una nueva colección en C Sharp
y eso se llama lista. Ahora una lista es bastante
poderosa internamente, en realidad está construida
sobre una matriz estándar, pero incluye muchas
más opciones y muchas
formas en las que puedes trabajar con la información
dentro de la matriz. Por ejemplo, hablemos de
este ejemplo aquí mismo. Estamos definiendo una
matriz entera en C Sharp. Sólo le estamos dando algunos valores numéricos
aleatorios. Estamos usando un
bucle de cuatro cada uno para recorrer cada elemento de la colección y sacarlo a la pantalla Si ejecuto la aplicación ahora puedes ver todos esos
números ahí mismo. Muy sencillo, lo que voy
a hacer es crear una nueva lista. Voy a imitar
esta funcionalidad. Se puede ver la
diferencia entre una matriz y una
lista, por ejemplo. Ahora es un tema un poco
complicado. Dado nuestro aprendizaje hasta el momento, no
voy a
explicar todo, pero voy a cubrir algunas de las
cosas que hacer con listas. Ahora bien, ¿cómo creamos una lista? Bueno, el tipo de datos es lista. Ahora hay una nueva notación realmente no
hemos hablado. Esto se llama genéricos. Ahora, no voy a
hablar demasiado de genéricos porque creo que es un
tema
bastante complicado en este momento Pero lo que quiero hacer es definir una lista que contenga enteros, por
ejemplo, se puede ver que Visual Studio está
tratando de ayudarme aquí En realidad es insinuar lo
que quiero hacer. Es correcto. Vamos a presionar tabulación
en el teclado ahí. Y está escrito en esta
notación para nosotros. Sólo voy a
completar esto como. Así que hemos imitado la
funcionalidad anterior. Ahora bien, esta línea de aquí es exactamente la misma que
esta línea de aquí. Este es un tipo de colección. Este es un tipo de colección. Es una matriz entera. Aquí, es una lista entera, y todas contienen
la misma información. Te lo demostraré. Si hago un bucle a través de
esta lista
aquí mismo y la salida de todos los
números a la pantalla, hace exactamente lo mismo. ¿Cómo definimos e
inicializamos una lista en C Sharp? Bueno, usamos la
palabra clave list con una
L mayúscula en estos corchetes angulares. Aquí mismo, ponemos en la lista el tipo
de datos que queremos almacenar. Del mismo modo, si quisiéramos una lista de cadenas, lo
haríamos. Por ejemplo, ponemos el tipo de datos en estos corchetes
angulares, le damos un nombre, y luego
usamos un signo igual. Y entonces queremos
decirle al sistema, Bien, ahora queremos
inicializar la lista Ahora queremos crear la lista y poner algo de
información ahí. Usamos esta nueva palabra clave, repetimos nuevamente el tipo de datos. Entonces en estos paréntesis, podemos dejarlos en blanco o podemos darle una capacidad
igual que una matriz Incluso podemos pasarle una colección
existente , por ejemplo. Lo que podría hacer es hacer esto. Esto creará una lista basada
en mi matriz aquí mismo. puede ver como ya empieza a ser bastante potente. Nuevamente, puedo demostrar que
también funciona ejecutando la aplicación y está
recorriendo los números que le
hemos pasado. Se puede ver que es bastante
poderoso en ese sentido. Pero lo que pasa con las matrices
estándar en C Sharp, por ejemplo, trabajemos con nuestra matriz
estándar aquí mismo. Si miro los
métodos nativos para hacer con una matriz, realmente no
podemos hacer mucho con él. Tenemos algunos
métodos diversos que podemos usar, como obtener la longitud de las matrices o el número
de elementos en la matriz, pero no mucho más que
ver con los métodos nativos. ¿Y si queremos
ordenar esta información? ¿A lo mejor poner
el número más pequeño al inicio y luego el
más grande al final? ¿Cómo invertimos el
orden de estos números? Varias cosas así. Bueno, este es uno de
los muchos beneficios de usar listas en tienda. Lo que podemos hacer. algunos ejemplos de
trabajo con listas. Aquí estoy definiendo una nueva lista. Puedo definir una nueva lista
y simplemente dejarla vacía. Y luego más adelante
en la aplicación, cuando averiguamos lo que realmente queremos poner en nuestra lista, podemos dinámicamente, sobre la marcha, agregarle elementos. Entonces podría agregar este
número aquí mismo. Y luego otra. A lo mejor si queremos
construir una aplicación donde recogemos
números de un usuario, podemos definir la lista. Y luego más adelante podremos agregar en los números del usuario cuando
ejecutemos el software. Ahora podemos ver que
la lista ahora contiene esos dos números que
le hemos agregado usando
el método add aquí. Pero no sólo podemos agregar cosas, también
podemos quitar cosas. Podemos hacer varias
cosas de forma nativa. Pero uno de los más
poderosos, en realidad
podemos ordenar los datos. Podemos ordenarlo en orden. Incluso podemos revertir los números. Por ejemplo, aquí hay definir una lista con estos
números. Y usaremos el método sort. Y lo que esto va a hacer,
esto tomará todos
los enteros y los
ordenará en orden Eso es lo único que
hay que hacer para poder hacerlo si ejecutamos el software. Ahora puedes ver que todos nuestros números están en orden
secuencial. Eso es muy fácil de hacer, solo solo esta muy corta pieza de código de
una línea. Aquí puedes hacer varias
cosas con la clase list y ofrece una forma
más poderosa de trabajar con tus datos. Eso no quiere decir necesariamente
un recaudatorio inútil. Puedes lograr estas
cosas con un aumento usando extensiones como link
y cosas así, pero no voy a meterme en eso ahora. No quiero complicar demasiado
este tutorial, pero solo estoy presentando
algunas de las ventajas de
usar listas a la hora de programar en C sharp Para resumir, si tienes
una colección de datos, ya sean enteros, cadenas u otro tipo de datos, y no necesariamente
conoces la capacidad, tal vez quieras
agregar valores durante
la aplicación A lo mejor el usuario necesita
agregar elementos o quieres controlar los
datos de una mejor manera. Entonces tal vez la lista es
algo para ti. A lo mejor es un tipo de datos que
quieres explorar. Pero es un potente tipo de datos, y te recomiendo que uses listas con tus
aventuras en C shop.
38. 9-1. O-O, clases y objetos: Clases y objetos en C Sharp. ¿Qué es una clase?
¿Qué es un objeto? ¿Qué significa todo esto? Bueno, déjame explicarte Ahora, Clases y objetos en C Sharp, apoyan lo que se llama el paradigma de programación.
¿Qué significa todo eso? La programación es
la abreviatura de lo que se llama programación orientada a
objetos
y es un paradigma Un paradigma es solo
una palabra elegante de decir una forma de hacer
algo así como un método. Si sigues con tus
esfuerzos en la programación, tal vez
veas mucho esta palabra, así que pensé que la
sacaría a colación. Ahora un paradigma es un
estilo de programación. Imagina un chef en la cocina
con un poco de pollo crudo. Podría asar el pollo. Podía hervir el pollo, podría freír el pollo. Pero cada uno de
esos es un paradigma, una forma diferente de llegar
al resultado final. Entonces eso es lo que es un paradigma. Ahora bien, cuando se trata de programas
básicos como construir una calculadora o
algo muy simple así, los paradigmas no son realmente
importantes para No es de sorprender,
probablemente nunca
antes habías usado realmente ninguno cuando el software
solo tiene 2030, 40, tal vez incluso 50 líneas de código. La forma de estructurar tu
software no es realmente tan importante porque es una programación
bastante pequeña, el estilo de programación
es muy importante. Cuando tienes grandes
piezas de software, es posible que tengas 2030, 100 personas trabajando en
una sola pieza de software. La organización del código es muy importante. Entonces considera esto por ejemplo. Si tienes muchas líneas de
código que se ven así, ¿cómo mantienes esto? Podría tener 50 páginas de
largo, 1,000 páginas de largo. Necesitamos una estructura, necesitamos alguna organización. Y ese es uno de los muchos
elementos de la programación 00. Ahora, 00 de programación,
es un tema muy grande, complicado
que tiene muchas ventajas y
muchos beneficios, pero ese es uno de ellos. Ahora o programación, se
remonta a los años 50, 60, pero definitivamente
ganó popularidad hasta donde recuerdo
a principios del 2000 Fue entonces cuando
realmente arrancó. Lo que realmente hemos
estado haciendo hasta ahora es lo que se llama programación
procesal, donde el programa inicia y
como que ejecutamos
cada línea en orden. Podríamos tener uno o dos métodos. Y, ya sabes, las cosas
son muy sencillas. Pero nuevamente, en aplicaciones de
software muy grandes, esto es bastante difícil de mantener. Por ejemplo, 00 programación, tema
muy grande, muy
complicado. Te puedo aburrir con
todos los entresijos
ahora mismo, pero no creo
que sea una buena manera de aprender 00 de programación. Creo que la mejor manera de
aprender es lidiar con algunos
ejemplos del mundo real y realmente pasarlo por ellos con ejemplos de
trabajo. Entonces, ¿recuerdas
la película Karate Kid, Donde Daniel Larusso
está pintando la casa
y pintando la barda
y lijando el Y secretamente, estaba
aprendiendo todo este karate, pero sin saber realmente por qué Y luego al
final, el señor Magi dijo,
oh, bien, ahora pon a prueba tus habilidades Entonces, para los beneficios
de mantenerme comprometido, es exactamente como quiero
enseñar programación O, y creo que es
una forma fantástica de
aprender la programación 00
aprendiendo con el ejemplo, luego volviendo en un
bucle de rotonda justo al final Entonces cuando hablo palabras
complicadas
como instanciación, abstracción de
polimorfismo,
cohesión, acoplamiento, todas estas cosas complicadas que
podría Pero el problema es en realidad, son asesinos de
motivación Y por los intereses
de preservar motivación y
mantenerte comprometido, voy a hacer
esto de esta manera y creo que será
una forma fantástica de aprender estas clases
y objetos en C Sharp. ¿Qué es una clase?
¿Qué es un objeto, y cómo me beneficia, y por qué debería siquiera usarlos? Hasta ahora, si has
estado siguiendo algunos de los tutoriales que
hemos hecho hasta ahora, hemos creado algunos ejemplos
básicos como multiplicar dos
números juntos. Donde tomamos dos números de un usuario y los multiplicamos
juntos, por ejemplo. Y cuando tomamos un
número de un usuario, podemos representar esto como un tipo de datos enteros,
lo cual es bastante fácil. Y eso es todo lo que tenemos que hacer. No necesitamos conocer más
información sobre estos números para
multiplicarlos juntos. Del mismo modo, si tomamos
el nombre del usuario, podemos almacenarlo en un tipo de
datos simple que es una cadena, y simplemente almacenamos
el nombre del usuario. Así que muy fácil. Pero, ¿cómo representamos un tipo de datos
complejo, como un usuario o tal vez una
cuenta como una cuenta social, o una cuenta bancaria, o incluso una bicicleta como
un objeto del mundo real, o un sándwich, o incluso un planeta entero como planeta Tierra o
algo así? Bueno, hasta ahora con nuestro estilo de programación
procedimental cano, tal vez para representar a un usuario, podríamos tener una cadena que podría ser el nombre del
usuario, y luego otra cadena
para su apellido. Tal vez un entero para su edad, y luego tal vez una cadena
para su nombre de usuario. Si tienen un nombre de usuario, podríamos tener tal vez un decimal o un doble
para su altura. La lista continúa.
Hay tantas cosas que puedes almacenar sobre un usuario. Puedes ver que ya tengo cinco líneas de código para
todas estas variables. Esta puede página aquí mismo, va a llenar muy rápido
con mucha información. Quizás podría usar estos
cinco tipos de datos aquí. Estos
tipos de datos simples, string, int, y double para representar un objeto
complejo como un usuario. De igual manera, si tengo una bicicleta, podría querer el
color de la bicicleta, la marca de la bicicleta, tal vez las medidas,
cosas así. Y así
representaría un objeto de bicicleta. Pero, ¿cómo pongo todos
estos en su propio objeto? Por ejemplo, en lugar por cada usuario en
nuestra aplicación, solo
puedo escribir user y
podríamos tener nuestro propio tipo de datos,
como un tipo de datos de usuario. Eso sería
genial, ¿no? Este es uno de los beneficios de usar clases y
objetos en C Sharp. Echemos un vistazo a
cómo podemos
crear nuestro propio
tipo de datos en C Sharp. Lo que voy a hacer ahora es
crear una clase completamente nueva, básicamente un
nuevo tipo de datos personalizados que podamos usar
en cualquier parte de nuestro software. Si vamos hacia el lado
derecho aquí, este es el nombre de nuestro proyecto aquí
mismo, la programación. Y tiene un pequeño
icono de C filoso con un cuadrado a su alrededor. Entonces voy a hacer click
derecho en esto. Voy a ir a Agregar, y después voy
a ir a clase. Una vez que estemos aquí, podemos
ver que las clases han sido seleccionadas. Aquí abajo, podemos darle un nombre a
la clase. Ahora puedes llamar a la clase como
quieras. Pero es
una práctica común
iniciarlo con mayúscula que
ver con su propósito. ¿Cuál es el propósito de esta
clase? ¿Qué hace? ¿Qué información contiene? ¿O cuál es su función primaria? De esa manera, cuando tienes
una aplicación muy grande con tal vez mil clases, sabes exactamente por el nombre, qué logra, qué pretende hacer. Lo que voy a hacer es crear un tipo de datos personalizado llamado Usuario. Eso va a hacer es
almacenar información sobre un usuario potencial que podría
estar usando nuestro software. Voy a llamarlo usuario, luego hago clic en el
botón de anuncio aquí mismo. Lo que eso hace, crea una nueva clase
en nuestro proyecto. Este es nuestro proyecto aquí. Hemos estado hasta ahora, si has estado viendo nuestros tutoriales
anteriores con la clase predeterminada que
se llama programa, y hemos estado trabajando
con el método principal. Puedes ver aquí hay una clase llamada programa y el método principal se encuentra dentro de ella. Esta es una clase predeterminada de
un tipo de aplicación de consola. Pero si vamos por aquí, ahora tenemos una
nueva clase llamada Usuario. Y ahora podemos poner
algo de información dentro de esta clase aquí mismo. Para que veas que Visual Studio está insinuando lo que podría
querer poner aquí Sí, puede ser una
forma preferible de hacer esto, pero voy a hablar de get and set en un futuro tutorial. Entonces voy a hacer esto
un poco diferente. Lo que queremos hacer
aquí en nuestra nueva clase, que se llama usuario, es poner todo
sobre nuestro usuario. Entonces tal vez el nombre del usuario, el apellido del usuario,
la edad del usuario. Cualquier cosa que tenga que ver con un usuario. Lo que voy a hacer,
voy a definir algunas variables simples aquí. Entonces lo que voy a hacer, voy a llamarlo tal vez nombre de
pila por ejemplo, y luego tal vez apellido, y luego tal vez la edad,
algo así. Antes de cada uno de
estos, solo quiero poner esta palabra clave interna. No te preocupes por lo
que eso significa ahora mismo. Vamos a cubrir eso
nuevamente en un tutorial posterior. Pero lo que he hecho, he definido tres tipos de datos simples aquí, dos cadenas y un entero. Y los tres están
dentro de la clase de usuario. Esta es la nueva clase que acabamos crear. ¿Qué significa
todo esto? Este es nuestro tipo de
datos personalizado aquí mismo, Al
igual que un entero
es un tipo de datos, una cadena es un tipo de datos. Ahora, el usuario es nuestro propio tipo de datos
personalizado y tiene todas estas
cosas dentro de él. Veamos un ejemplo
de lo que esto significa. Si volvemos a nuestra clase principal aquí con el método main, realmente
podemos configurar lo que
se llama una instancia
de nuestra nueva clase. Al igual que cuando
creamos una cadena, podríamos hacer algo como esto. Pero cuando tenemos un tipo de datos
personalizado, como una nueva clase, por ejemplo, el formato es un
poco diferente. Sería nuestro tipo de datos
personalizado, que es el nombre de nuestra clase, que es usuario, porque hemos creado una clase
con el nombre usuario. Ya puedes ver
esto es verde y en
realidad tiene alguna
información sobre nuestra clase. Si escribo Bacon por ejemplo, entonces puedes ver que es
negro, hay una línea roja. Eso es porque no
tenemos una clase llamada Bacon. Ahora tenemos una clase
llamada Usuario, Es verde. Y en realidad podemos
hacer uso de esto. Ahora vamos a darle un
nombre igual que lo hacemos aquí, por
ejemplo, con
una simple variable. Sólo voy a llamarlo EU. R, abreviatura de usuario. Entonces voy a ir igual. Y visual studio me está dando una pista sobre
lo que quiero hacer. Eso es exactamente
lo que quiero hacer. Quiero crear una nueva instancia
de nuestra clase llamada user. Y le estoy dando el nombre USR. Puedo darle el nombre que quiera,
realmente no importa. Ahora tengo una variable completamente nueva, igual que una variable
aquí de tipo string. Ahora tengo una nueva variable
aquí llamada US user. Si empiezo a usar mi variable USR y
pongo un dardo después, puedes ver que
realmente puedo acceder a estas variables que acabo de
crear dentro de nuestra clase Puedes ver aquí,
apellido, nombre y edad. Vamos a configurar una variable de
usuario de muestra. Si digo nombre de usuario, sabemos que esto es una cadena. Vamos a llamarlo, no lo sé. Vamos a llamarlo Bob. ¿Por qué no? Vamos a configurar un
apellido para nuestro usuario. Le llamaremos Bob Smith. Entonces por último, Bob Visual
Studio quiere que ponga 30. ¿Por qué no? No estoy seguro de por qué Visual Studio está indicando
30, pero ahí tienes. Ahora lo que he hecho
aquí, he creado un nuevo
objeto de usuario aquí mismo. Y luego le he
dado alguna información. Estos campos aquí. Estos son exactamente los mismos
campos que hemos definido en nuestro nuevo usuario que
es como nuestro tipo de datos, y le hemos dado
algunos valores aquí. Lo que ahora puedo hacer es en realidad
usar esta información. Si hago consola de línea derecha, en realidad
puedo emitir parte de esta información
a la pantalla. Digamos, déjenme
dar salida al nombre,
apellido y edad del usuario . Mantengamos
abierta la ventana de la consola para que no se cierre sobre nosotros. Ahora vamos a ejecutar la aplicación
para ver qué tenemos aquí. ejecutar la aplicación, podemos ver que en realidad estamos dando salida a la pantalla
todos los valores para nuestro tipo de datos
personalizados Estamos estableciendo los
valores de esta manera. Estamos sacando los valores
de nuestro tipo de datos personalizados, así a la pantalla Al crear
clases en C Sharp, como nuestra clase de
usuario personalizada aquí mismo, imagina que esta clase es un
blueprint, una especificación Todo dentro de nuestra clase
aquí tiene que ver con un usuario, no tiene
que ver con una bicicleta o un sándwich o
algo al azar. Todo aquí está involucrado
con la creación de un nuevo usuario. Tenemos el nombre del usuario, la edad
del usuario, todo lo que tiene que ver con un usuario. Imagina que esto
es como un plano para eso, o como digo, una especificación El proceso aquí, lo que
estamos haciendo es crear un objeto igual que
cuando creamos una simple variable de cadena
llamada name, por ejemplo. Cuando se trata de
clases personalizadas y cosas así, estas se llaman objetos. Ahora se puede ver de dónde
vino
el término programación
orientada a objetos vino
el término programación
orientada a Porque representamos cosas
del mundo real como usuarios, autos, bicicletas como objetos
como clases, USR Aquí está el objeto, este es el tipo de datos
que es una clase. Este proceso aquí se
llama instanciación. Y se llama
instanciación porque estás creando una nueva
instancia de una clase Lo que también podemos hacer es crear una segunda instancia
de la misma clase. Esta es la primera instancia. Esta es la segunda instancia. Podemos crear 50. Podríamos crear 100 por ejemplo. Lo que podemos hacer aquí
es otro usuario y a lo mejor se llama Darren
Smith y tiene 75 años De igual manera, podemos sacar su
información a la ventana. Como puedes ver ahí, comienzas a ver el verdadero poder de la programación orientada a objetos. Podríamos crear miles
de estos objetos de usuario y replicar miles de usuarios en nuestro software
si quisiéramos No nos limitamos a
tener únicamente objetos de usuario. Podríamos tener objetos de cuenta, muchas cosas diferentes para
unir nuestro software. Lo que podemos hacer con
estos objetos aquí, podemos pasarlos a métodos, podemos ponerlos en matrices, podemos
recorrerlos en bucles. Los límites son infinitos. Pero eso es sólo una pequeña muestra de
programación orientada a objetos Y comienza con la creación de
clases y nuevos objetos. Entonces espero que esto
te haya ayudado a comenzar con tu
viaje orientado a objetos en C shop
39. 9-2. Constructores: Voy a hablar de
constructores ahora en C Sharp. ¿Qué es un constructor?
¿Cómo funcionan? Bueno, vamos
a comprobarlo aquí tenemos un ejemplo
muy sencillo. Tenemos una
clase personalizada llamada user. Tenemos tres variables
dentro de la clase, que es información sobre el usuario y la
edad del usuario. Entonces solo estamos
configurando un nuevo objeto, que es una instancia
de la clase. Le estamos dando algunos
valores, nombre, apellido y edad, y
sacándolo a la pantalla Pieza de software muy simple. Voy a introducir un
constructor en este ejemplo. Ahora lo que hace un constructor, nos ayuda a construir
nuestros objetos. Aquí estamos creando una nueva
instancia de nuestra clase. Aquí está nuestro objeto. Lo que hace un constructor, nos da alguna ayuda para
configurar este objeto. Aprendamos con el ejemplo. Creo que aquí
sería más fácil. Aquí estamos configurando
un nuevo objeto de usuario. Sólo voy a copiar
y pegar este. Y vamos a crear un
nuevo objeto, otro objeto. Bien, aquí estoy creando
un nuevo usuario llamado Tony,
Tony Smith y su edad es de 41 años. Cuando configuro este usuario, puedes ver que usa
cuatro líneas de código. A lo mejor si queremos
montar 100 de estos, no
va a
quedar muy elegante, va a parecer
bastante hinchado Esta es una de las ventajas
de utilizar constructores. Lo que puedo hacer cuando creo una
nueva instancia de esta clase, en realidad
puedo pasar estos
valores como parámetros. hora de crear una nueva instancia, lo que puedo hacer es
pasar por decir Tony, puedo pasar en Smith y luego
pasar en la era aquí mismo. Entonces puedo borrar todas
estas líneas de código. Y entonces esencialmente esta línea hará exactamente lo mismo, estas cuatro líneas aquí. Esa es una ventaja de los constructores es la
minimalización de código Se representa
sólo en una línea. Pero, ¿cómo configuramos esto? Porque ahora mismo
tenemos una línea roja. Y si coloco el cursor sobre
eso, dice que user no contiene un constructor que
tome tres argumentos Bueno, vamos a agregar uno. Voy a entrar en la clase de
usuario aquí, necesito configurar un constructor. ¿Cómo hago eso? Comienza
con la palabra clave interna. Ahora, no te preocupes por lo que es lo
interno en estos momentos. Lo discutiré en
un tutorial posterior. Todos los constructores toman
el nombre de la clase. El nombre de la clase es usuario. Voy a poner ahí el
nombre de la clase. Después de eso, puse paréntesis y luego las llaves
familiares Este es un constructor básico
en su forma mínima. Podemos tener
más de un constructor por clase si queremos. Lo que quiero hacer es
tomar
aquí estos valores e inicializarlos
en nuestras variables aquí Quiero poner esos
valores aquí mismo. Lo que tengo que hacer, cuando
trabajamos con métodos, funciona muy similar a eso. Quiero pasarlos
como esencialmente parámetros que
voy a hacer primero. Por ejemplo,
nombre, apellido, edad. Cuando le des el nombre a tus
parámetros, dales nombres significativos como nombre,
apellido y edad. Y asegúrate de que
no sean exactamente lo
mismo que estas
variables locales aquí mismo. Dales una carcasa ligeramente
diferente, por ejemplo, o un nombre completamente
diferente. Lo discutiré
en un tutorial posterior cuando hable de esta palabra clave. Por ahora, nuestros parámetros están entrando en nuestro
constructor aquí. Ahora quiero inicializar estas variables locales con
estos valores aquí mismo Es muy fácil hacerlo. Tomo la variable local aquí, configuro como el valor
del parámetro. Eso ya está hecho y continuaremos con
los otros dos. Visual Studio nos ha
ayudado allí amablemente. Vamos a repasar lo que
está pasando aquí ahora. La línea roja se ha ido. Si pongo el cursor sobre esto, está funcionando.
No hay línea roja. Estoy pasando una cadena, una cadena y un entero en el constructor para la clase. Al crear nuestro objeto, estos valores se pasan como parámetros al constructor,
que es todo esto. Entonces el valor de los
parámetros asignados, bueno, inicializado en
nuestras variables locales aquí Ahora bien, estas variables locales
aquí mantendrán para siempre estos valores
siempre y cuando esta instancia permanezca
viva en nuestro sistema. Eso es genial, ¿no? Déjame ejecutar el software muy rápido para que puedas
ver lo que está pasando. Voy a comentar esto, y volveré
a eso en un segundo. Ahora, pongamos eso
ahí, no hay problemas. Ejecutamos el software. Ahora mismo, se puede ver que
dice Tony Smith, de 41 años. Parece que está
funcionando correctamente. Permítanme deshacer esos comentarios y hablar de una cosa más. Se puede ver algo
interesante. Ahora, hay una línea roja
debajo de esta parte de aquí. Cuando intentamos
configurar un nuevo objeto, ya no
funciona. ¿Por qué es eso? Eso es porque en nuestra
clase aquí, por defecto, no
tenemos constructor.
Se ve así. Sin embargo,
una vez que definimos un constructor con
parámetros como este, ya no
podemos configurar una instancia de nuestra
clase así. Hay una manera fácil
de sortear eso. Definimos solo un constructor muy
básico sin parámetros. Entonces ahora puedes ver esta línea roja se ha ido
y todo está feliz. ¿Cómo está funcionando eso? Bueno, cuando llamamos aquí a
este constructor, cuando creamos este objeto, estamos pasando en
tres parámetros. Cuando esta línea es
ejecutada por el software, la ejecución del código
salta aquí. Y todo está configurado aquí. Cuando creamos una nueva instancia
usando esta línea aquí mismo, no
hay parámetros, se llama a este
constructor. En cambio, esto nunca se ejecuta, solo esta sección aquí, No pasa nada aquí. Ahora esa es la diferencia
entre los dos. En realidad hay dos constructores
ahora dentro de esta clase. Esto es usar el
primer constructor, esto es usar el segundo. Y podemos tener 50
constructores si queremos, pero así es
como van las cosas internamente dentro
de nuestra clase Para que veas que los constructores nos
han permitido
minimizar el código, ya
sabes, en una sola
línea, por ejemplo Pero, ¿qué más
pueden hacer? Ya sabes, ¿cuál es otro beneficio? Bueno, constructores como
decimos nosotros pueden ayudarte a construir tu objeto y como que lo
hace detrás de escena Entonces, a partir de este archivo de aquí mismo, realmente no
necesitamos saber
cómo está configurado este usuario. Sólo le estamos pasando alguna información y
podemos recuperarla cuando la queramos. Entonces toda esa clase de lógica se nos
oculta,
lo cual es bastante genial. Los constructores internamente pueden hacer algunas cosas de las que no necesitamos
preocuparnos detrás de escena Por ejemplo, si llamo a este constructor pasando
los dos nombres en la era, podría sacar algo a
la ventana, por ejemplo. Podría decirle al usuario, estamos configurando un nuevo usuario. Por ejemplo, cuando
ejecuto el software. Ahora pueden ver me sale un
pequeño mensaje diciendo, bien, por favor espere, solo estoy
configurando un nuevo usuario. Y luego da salida
a la información. Constructores, hacen
algunas cosas extra, no
necesitan
simplemente configurar variables Podrían iniciar sesión en una base de datos, podían hablar con un sitio web. Podrían abrir una conexión de
base de datos. Pueden hacer muchas
cosas internas detrás de escena. Es así como pueden ayudar a
construir un objeto, y es por eso que
se les llama constructores Los constructores son elementos bastante
poderosos de la programación orientada
a objetos Y puedes ver, usando este
ejemplo en este tutorial, cómo simplifica las cosas Quizás no en la clase en sí sino definitivamente trabajando
desde aquí afuera. Puedes ver lo simple que se ve
todo con
solo usar una línea de
código para configurar un objeto. Y no necesitamos
preocuparnos por las cosas internas que
suceden aquí. Ese es un ejemplo de
constructores en tienda C, y espero que les resulte
bastante útil
40. 9-3. Métodos de objetos: Hablemos de métodos de objeto. Ahora, aquí tengo una aplicación
de muestra. Lo que estoy haciendo, estoy
creando una nueva lista aquí. Entonces estoy creando tres usuarios. Todos ellos tienen
información única aquí. Por ejemplo, Tony
Smith tiene 70 años, Bob Holmes y Tyrone Jones Entonces cada uno de estos objetos aquí, estoy agregando cada uno a nuestra lista. Ahora nuestra lista de usuarios
contendrá estos tres
objetos. Estoy usando un cuatro
cada bucle para
recorrer todos los
usuarios y a su vez,
sacar toda esta información
a la ventana de la consola. Solo echemos un vistazo a eso. Ahora puedes ver que este
es el resultado que obtenemos. Es solo dar salida a toda
esta información de objeto
en la pantalla Ahora lo que quiero hacer,
quiero saber cuáles de estos
usuarios se han retirado. ¿Han alcanzado la
edad de jubilación o son pensionados? Dependiendo en qué país
vivas ahora En Reino Unido, no
estoy seguro de América, pero la edad de jubilación es, creo que 66 para los varones. Sólo usaremos 66 como número
arbitrario.
Podría ser cualquier cosa. Tony Smith estaría
retirado en ese caso, pero Bob Holmes y Tyrone Jones todavía
tienen un camino por recorrer
antes de que se retiren Lo que quiero hacer, quiero
sacar un poco extra de información para decir ¿el usuario
está retirado? forma en que normalmente haríamos esto se configura tal vez una declaración if. Y decimos si la edad del usuario, edad es mayor o igual a, digamos que 66 es
la edad de jubilación, Entonces diríamos, bien,
están jubilados. Diríamos jubilados. Lo inicializaremos a false. Si son mayores que eso, solo
diré que jubilado es cierto, pero por ejemplo,
algo así. Así es como
normalmente estableceríamos un caso donde si están jubilados, usaríamos una condición. Y luego sacamos esa
información a la pantalla. Se vería
algo así. Puedes ver que aquí tenemos nuestro bonito
bucle con nuestra edad, apellido y edad. Pero a la hora de jubilarse, tenemos toda esta información. Se ve un poco hinchado. A lo mejor podamos mover
esto a otro lado. Tal vez dentro de nuestra clase aquí. Y entonces sólo tienes
otro trazador de líneas aquí. Esto es lo que podemos lograr
con los métodos objeto. En este caso, lo que queremos
hacer es poner aquí esta lógica, esta condición dentro de nuestra clase. No tenemos que preocuparnos por ello. No sabemos cómo se
calcula, realmente no nos importa. Solo queremos una pequeña
variable aquí, esto está retirado, y podemos
mostrar esa información. Echemos un vistazo a
cómo podemos crear un método de objeto moviendo esta lógica dentro de nuestra clase. Justo antes de hacer eso, voy
a ejecutar la aplicación
muy rápido. Sólo para que podamos ver
el resultado aquí. Puedes ver debajo cada usuario dice que
jubilado es cierto porque esta edad es mayor de 66 y el resto son falsas solo porque no
tienen 66 o más. Eso va a mover
esta lógica a
lo que se llama un método de objeto. Y eso lo definimos dentro nuestra clase aquí mismo.
Aquí está nuestra clase. Aquí tenemos nuestras variables, aquí tenemos dos constructores Lo que queremos hacer es simplemente
crear un método aquí, vamos a volver a usar la palabra clave
interna, No te preocupes por lo
que eso significa ahora mismo. Sólo lo vamos
a poner aquí. Cuando definimos un método, necesitamos un tipo de retorno. Va a ser un
gravamen toro porque queremos decir son verdaderos retirados o son
falsos retirados, Por ejemplo Ahora el nombre del
método que voy a
llamarlo se retira entonces. No toma ningún
parámetro porque tenemos acceso a la edad a través de
la propia clase aquí arriba. Usar a la edad, solo
vamos a crear nuestro método aquí y luego lo que queremos
hacer es devolver
algo así. Ahora, Visual Studio
ya ha insinuado lo que
podríamos querer hacer, pero vamos a tomar esto aquí Lo que estamos diciendo aquí
es que si la edad del usuario es mayor o igual a 66
jubilado es igual a true, también
podríamos decir eso, que es exactamente lo mismo, porque esta condición
evaluará a true o false. Y luego el resultado se almacena en un bolen. Muy sencillo, de verdad. Lo que quiero hacer es
tomar la condición aquí, ir a nuestra clase y queremos devolver esto
de este método aquí. Así como así, porque aquí
estamos dentro de nuestra clase. Tenemos acceso a la edad del usuario aquí. Sólo vamos a tomar esto y vamos a
poner eso ahí. Hemos creado un método, no
tiene parámetros, pero tiene un
tipo de retorno de booling Estamos devolviendo verdadero o falso si la edad del usuario aquí mismo es
mayor o igual a 66. Al volver aquí, podemos
eliminar esto por completo. Ahora lo que podemos hacer es
tomar nuestro objeto aquí, que es usuario, porque estamos pasando por
esto en un bucle de proa. Y entonces podemos acceder a un
nuevo método que
acabamos de crear aquí mismo
llamado es retirado. Y se puede ver que
devuelve un bolen. Entonces hago doble clic en ese
abrir y cerrar paréntesis porque no toma parámetros Y ahora se puede ver que el código se ve mucho más aerodinámico. Aquí no tenemos ese tipo
de condición. Solo tenemos cuatro tipos
de bonitos bits de código. Uno consiguiendo el nombre, otro obteniendo la edad, y otro
obteniendo si están jubilados. Acabo de darme cuenta que
deletreé retirado mal en el método ahí,
nadie es perfecto. Pero puedes ver que ahora se ve
mucho más simple. Pero uno de los beneficios y
ventajas de 00 de todos modos, es que tu lógica está algo
escondida aquí dentro. Digamos por ejemplo, si un
miembro de tu equipo, si estás trabajando en un equipo grande, trabaja en esta clase aquí y
trabajas en esta clase aquí. No hace falta que te preocupes por cómo se calcula el retiro. No lo sabes, a lo mejor ni siquiera
te importa. Ni siquiera sabes cuál es
la edad de jubilación. Eso está bien, porque
lo único que necesitamos llamar es este
método aquí mismo. Entonces tal vez nuestro amigo en nuestro equipo de
software pueda, ya sabes, lidiar con las complejidades de tal
vez cuál es
la edad de jubilación Entonces el principio es que te está ocultando la
información, la
está abstrayendo. Y ese es uno de
los puntos clave de la abstracción de programación orientada a
objetos. No hace falta
saber cómo funciona esto. Por ejemplo, si
tienes una cafetera, no necesitas
saber cómo va. Ya sabes cómo funciona dentro, internamente, toda la electrónica. Lo único que
debes hacer es
llenarlo de agua y
presionar el botón. Entonces eso es lo que estoy
tratando de explicar aquí. No necesitamos
saber cómo funciona esto, solo
necesitamos llamar
al método y se obtiene como un valor verdadero o falso. Entonces esa es una de las
ventajas de usar programación orientada a
objetos y así es como
funcionan los métodos de objetos en Sea Shop.
41. 9-4. Modificadores de acceso (público, privado, etc): Ahora voy a hablar de modificadores de
acceso en tienda. Suena un poco complicado, pero voy a descomponerlo. Entonces es muy sencillo y
vas a entender todo lo que tiene que ver con los modificadores de
acceso en tienda Entonces, ¿qué es un modificador de acceso? Ahora, antes hablábamos del tipo de trabajo que tendría una
clase, modela un
objeto del mundo real. En este ejemplo. Aquí tengo una clase de videojuegos. Cuando creo un nuevo
videojuego, por ejemplo, quiere el nombre del videojuego, su editor, y una
calificación para el juego. Entonces puedes ver una clase aquí representa un objeto de videojuego. Es como un objeto del mundo real. Y cuando creamos clases, queremos todo
dentro de la clase. Por ejemplo, esta clase de
videojuego aquí para simplemente ser sobre
el videojuego. Así que no queremos
hablar de otra cosa que no
sea el videojuego de aquí. A lo mejor como qué comida comemos mientras
jugamos al videojuego. O tal vez alguna información sobre el usuario jugando el juego. Porque tal vez esa información
del usuario podría estar en una clase de usuario. O tal vez la comida que
el usuario está comiendo mientras juega al videojuego
sería en una clase de comida. Esto es bastante importante
con la programación 00, se mantienen las clases lo que
se llama altamente cohesivo Y eso solo significa que
todo dentro la clase de videojuegos tiene
que ver directamente con un videojuego. Ese es el principio general. En fin, esto no sólo
beneficia a la organización del código, sino que permite que diferentes personas
trabajen en este proyecto. Por ejemplo, tal vez 100 personas. Entonces puedes delegar a
una o dos personas para trabajar en, digamos, esta clase. Si bien otra persona
podría enfocarse en esta clase principal aquí mismo, tiene múltiples beneficios. Pero, ¿cómo se vincula eso los modificadores de
acceso y
cosas así Bueno, considera
este ejemplo aquí. Lo que estoy haciendo, estoy construyendo cuatro objetos de videojuegos aquí. Estoy poniendo algunos datos de muestra, ¿qué está pasando
detrás de escena aquí cuando estoy construyendo
estos cuatro objetos? Sólo estoy configurando
algunas variables aquí. El nombre, el editor
y la calificación. Se puede ver que los parámetros están entrando en el constructor, y yo solo estoy configurando los valores. Sin embargo, secretamente
dentro de esta clase, lo que estoy haciendo es generar un nuevo ID único para cada
objeto que estamos creando. Lo que está pasando aquí es que
tengo un método aquí. Es solo configurar esta variable
aquí en un ID único. No necesitas
preocuparte por lo que hace
esto, pero lo que hace, genera un ID único, que es único y nunca
debería haber un duplicado. Esta es una función incorporada que puedes usar para hacer eso Y es solo establecer esta
variable aquí en un ID único. Entonces, si creamos un juego aquí
usando este constructor
, siempre tendrá un ID único. De esta parte
del programa aquí, no
tenemos idea de que
esto está sucediendo. Sólo estamos pasando
en tres valores. Ni siquiera sabíamos
que tenía una identificación única. No tenemos idea de lo que está
pasando detrás de escena. Y esa es la belleza de la programación orientada a
objetos. No necesitamos saber y no
necesitamos que nos importe. Por ejemplo, acabo de crear este objeto aquí
llamado Game One. Cuando entro aquí puedo
volver a editar el editor. Puedo cambiarlo a
un valor diferente. Ahora lo he construido. Digamos por ejemplo, World of Warcraft Blizzard se
han
apoderado de los juegos antidisturbios Entonces podría querer modificar el editor a riot games más adelante en el software,
por ejemplo. Yo puedo hacer eso no hay problema. Sin embargo, ¿y si alguien puede cambiar
accidentalmente
este valor de ID aquí? Lo que voy a
hacer es salir por aquí, juego uno, y puedes
ver este campo de identificación aquí. Podría cambiar esto
a lo que quiera. El caso es que no quiero que
nadie cambie este campo de ID. Ya es único. No quiero que ningún otro
miembro del equipo modifique este valor. Podría corromper los datos
porque el ID es único. Y cualquiera podría simplemente cambiar este valor de identificación a
sándwich de jamón, por ejemplo. Ya sabes, eso podría tener
muchos efectos adversos. Uno, podría romper
el software. Dos, podría causar, ya
sabes, pérdida de información. Ya sabes, podría tener muchos efectos
negativos para el software. Entonces lo que quiero
hacer, quiero mantener esta identificación privada a la clase. Solo quiero que la clase
en sí sepa sobre este ID y administre el ID
internamente a esta clase. No quiero que nadie más
en el software modifique ninguna otra clase o cualquier otra parte del
software para tocar este ID. A lo mejor les puede
gustar mirarlo, pero no quiero que lo
editen, por ejemplo. Aquí es donde los
modificadores de acceso son útiles. Ahora los modificadores de acceso hacen cumplir
lo que se llama encapsulación, es asegurarse de que
los datos confidenciales como ID en este caso, ocultos de
los usuarios o personas, o incluso de otras piezas de software que
nunca deberían tener acceso a él Ese es un ejemplo de encapsulación
y por qué la encapsulación es importante a la hora de generar programas orientados a
objetos Echemos un vistazo a cómo
podemos restringir el acceso a ciertas variables o incluso
métodos usando modificadores de acceso Vamos a entrar en nuestra clase. Hablemos de varios modificadores de
acceso que podemos tener en C Sharp Ahora bien, el primero es
lo que se llama público. Se puede ver aquí público. Eso solo significa cualquier cosa
definida como pública, podrías tener una
variable por ejemplo, o incluso puedes tener un método. Por ejemplo, este de aquí abajo, si hago esto público. Y eso significa que cuando creamos
un objeto de esta clase, podemos acceder a él desde
fuera de la clase. Podemos acceder a él desde
cualquier parte de nuestro proyecto. En cualquier lugar de nuestra solución. He escrito en el juego uno, luego un poco t ahí, y ahora podemos acceder a ID Podemos acceder al método generar
nuevo ID aquí. Eso es porque estos
son públicos y podemos acceder a ellos
desde cualquier lugar. Ahora el otro es
lo que se llama interno. Podemos tener variables aquí, podemos tener
constructores internos, podemos tener métodos internos La diferencia entre público
e interno es interno sólo
es accesible dentro la asamblea o proyecto actual. ¿Qué significa eso?
Bueno, ven a través de aquí. Hasta el momento, hemos estado trabajando
con un proyecto hasta el momento. Ahora lo que podemos hacer, podemos tener otro proyecto en nuestra solución. Podríamos tener 50
proyectos, por ejemplo. Lo que eso significa en nuestro proyecto. Aquí, nuestro proyecto predeterminado, solo las clases dentro del proyecto pueden acceder a cosas
internas. Si estamos en otro proyecto, tal vez este proyecto
represente la base de datos, como la capa de datos o
tal vez el front-end donde están todas las cosas tal vez
gráficas. Entonces no pueden acceder a cosas
internas porque solo es interno
al proyecto actual. Hablaremos más de
múltiples proyectos más adelante, pero eso es básicamente lo que es
la palabra clave interna. Otro modificador de acceso es
lo que se llama protegido. Ahora, vamos a estar
hablando de protegido más adelante, así que no te preocupes por
eso por ahora. El último del que quiero
hablar es privado. Ahora, privado es muy importante para el
ejemplo que acabo de dar con respecto al acceso
al ID desde fuera
de esta clase. ¿Qué privado hace cumplir? Las variables locales como esta
o incluso métodos como este solo serán accesibles desde con
dentro de la clase actual. Lo que he hecho, he
cambiado este ID a privado y he cambiado
este método a también privado. Si vuelvo a mi programa principal aquí y pongo un punto
después de este objeto, se
puede ver que
la propiedad ID, la variable ID,
falta en esta lista. También notarás que
el método para generar un nuevo ID también
falta en esta lista. Se puede ver lo que
está pasando aquí. Es hacer cumplir la encapsulación. Está ocultando
información sensible porque solo queremos que la clase de
videojuego pueda generar nuevos ID's y tú controlas las ID
para el videojuego. Nadie más en toda esta pieza de software necesita
saber sobre las identificaciones. Es exclusivo de los videojuegos y
debe permanecer único en
el videojuego. Por lo tanto, estos campos
deben hacerse privados porque solo el videojuego necesita
saber de esto, es información
privada. Entonces,
considérelo así por ejemplo. Sin embargo, el nombre es
editor es público. Hagamos que la calificación sea interna. Mientras esté trabajando
dentro del mismo proyecto, debería poder acceder a
nombre, editorial y calificación. Lo que puedo hacer aquí mismo, Calificación de
nombre y editor. En este momento la identificación es privada. Si estoy tratando de usar eso de todos modos, por ejemplo, poner alguna
información dentro de ID ahí. Puedes ver que tengo
un error aquí. Y si pongo el cursor sobre eso, dice
que el ID de punto del videojuego es inaccesible debido a
su nivel de protección Eso es porque es privado. En realidad no podemos acceder a esta información si tratamos ejecutar el software
y
compilarlo, ni siquiera va a letras. Para que veas que así es
lo estricto que se hace cumplir. En cuanto cambie esta
identificación a pública o interna, entonces la línea roja
va a desaparecer. El amparo ha desaparecido. Podemos ejecutar el
programa de forma normal. Entonces este es el poder de los modificadores de
acceso en C Sharp. Hace cumplir lo que se llama
encapsulación y protege nuestros datos confidenciales de
otras piezas de software, otros segmentos del software
existente e incluso los usuarios que trabajan en diferentes partes
del software también Hace cumplir la integridad de los datos y evita muchos problemas adversos que pueden ocurrir debido a esto Estos son modificadores de acceso
en C Sharp y por qué son muy útiles a la hora de
crear clases y objetos Por último, quiero hablar lo que puede tener modificadores de acceso Aquí tenemos un método que
tiene un modificador de acceso. Tenemos un par de
constructores aquí que tienen modificadores de
acceso y también
algunas variables locales aquí arriba. También tienen
modificadores de acceso aquí. Pero notarás que la
clase que contiene todos estos elementos también
tiene un modificador de acceso. Ahora público es el modificador de acceso
más débil. Si algo se hace público, entonces cualquier persona en cualquier parte la solución completa
puede acceder a este elemento. No obstante, la clase misma
está marcada como interna. Y eso significa que solo
las clases dentro del proyecto o
ensamblaje existente pueden acceder a esta clase. Por defecto, este modificador de acceso
más fuerte anula cualquier cosa interna
más débil Anularemos todos estos modificadores de acceso
público aquí. Y eso se debe a que
la clase circundante está marcada como interna. Por defecto, el acceso para
estos será todos internos. Si son públicos, se
verá algo así. Incluso si están
marcados como públicos, así es como se
accederá a ellos. No obstante, si
marco la clase como pública, entonces no hay problema
porque este es el modificador de acceso más débil Todos estos serán
públicos si alguna vez has trabajado con permisos de archivos y
carpetas para sistemas
operativos
y varios ajustes pueden anular las subcarpetas, Funciona de manera muy similar a eso Para aclarar, si pude
marcar esta clase como privada, entonces por defecto todo
dentro de ella será privado independientemente
del modificador de acceso. Ese es el punto que estoy
tratando de cruzar. Ahora, escribir modificadores de acceso
en C sharp es opcional. Si elimino el
modificador de acceso de la clase, entonces por defecto las clases
son todas internas. Podría escribir esto
y esto
sería exactamente lo
mismo que hacer esto. Es opcional, pero se
asume interna por defecto. Sin embargo, cualquier cosa
dentro de la clase, métodos, constructores,
propiedades, o variables, por defecto estas
son todas privadas, a menos que estén explícitamente marcadas
como públicas o internas, Entonces se asume
que son privadas Escribir esto sería exactamente lo
mismo que escribir esto. En este caso,
privado es opcional. Podríamos eliminar el modificador
de acceso
privado del método y
la variable aquí arriba. Y tendrá
exactamente el mismo efecto porque por defecto, cualquier cosa dentro de la
clase se asume privada si
no hay modificador de acceso.
42. 9-5. Propiedades: Voy a estar
hablando de propiedades en tienda. Ahora, también vamos a estar discutiendo la palabra clave get
y la palabra clave set, también conocidas como
getters y setters Entonces, ¿qué significa todo eso? Bueno, vamos a echar un vistazo. Si has seguido junto con
los otros tutoriales
hasta ahora para hacer con la programación
orientada a objetos, entonces esto va a tener
perfecto sentido y
a partir de eso. Si no lo has hecho, entonces te recomiendo
encarecidamente que
los veas para que estés a
punto de entender lo que te voy a mostrar. ¿Qué es una propiedad de tienda? ¿Por qué deberíamos usarlos? Así que las propiedades de la tienda obligan a uno de los principios básicos de la programación
00, que
es la encapsulación. Y eso es solo garantizar información
confidencial no sea accesible desde ningún otro lugar. Al igual que cuando hablamos de
esta variable privada aquí, solo
es accesible
dentro de la clase y entonces nadie que acceda a ella tiene ningún control sobre
eso, por ejemplo. Entonces esto va a empujar
eso un paso más allá. Así que voy a
presentar un escenario aquí y mostrarte
uno de los beneficios
de usar unas propiedades afiladas y getters, y setters En este ejemplo, aquí hemos definido
una clase de videojuegos. Tiene varias variables
aquí podemos usar y un constructor con
tres parámetros. Aquí estamos configurando
cuatro objetos de videojuegos. Juego 123.4 Dentro
del constructor estamos creando un
nombre de videojuego, el editor del juego, y una calificación para el juego, digamos que cuando comience nuestro
programa, todos estos datos se
cargan en el sistema En algún momento posterior en el software el usuario
quiere modificar. Por ejemplo, el nombre de
este juego aquí mismo. Han hecho clic en el botón de edición, quizá en el tipo, y quieren
cambiar el nombre Por cualquier razón, tal vez el videojuego ahora se
llama un nombre diferente. Vamos a pedirle al usuario un nuevo nombre para este
juego aquí, Game One. Y van a escribir
algo en el sistema. Digamos por ejemplo, les
pedimos un nuevo nombre, podemos establecerlo usando aquí
el nombre de la variable. A lo mejor accidentalmente golpearon G en el teclado,
luego golpearon Enter. Lo que estamos haciendo aquí, solo
estamos pasando su entrada a esta
variable. No hay problema en absoluto. Seguiremos con nuestro día. No obstante, tal vez esto no
sea una buena idea. A lo mejor queremos validar primero
esta entrada. A lo mejor queremos asegurarnos de que el nombre del juego tenga
al menos dos caracteres o no contenga ningún carácter numérico
o algo así. A lo mejor hay algunas
comprobaciones que tenemos que hacer. Aquí es donde pueden entrar
las propiedades C sharp. En este escenario en particular, hay muchas razones para
usar propiedades C sharp, pero este es solo un ejemplo por el que
vamos a pasar. Ahora lo que podría
hacer en este caso es que en lugar de establecer la variable
name directamente, puedo crear un método
aquí llamado update name. Y eso puede tomar en nuestro
nuevo nombre del usuario. Lo que puede hacer, puede hacer
varias comprobaciones de validación. Se puede decir, bien, ¿ el nuevo nombre
es menor o
igual a un personaje? Si es así, entonces no podemos actualizar el nombre y podemos hacer cualquier
otra validación sobre el nombre. Y luego, finalmente,
podemos actualizar el nombre. Por ejemplo, lo que
puedo hacer aquí es decir, juego uno para actualizar nombre. Ahora, en lugar de
establecer una variable, puedo usar un método. Para
lograrlo, paso nuestro potencial nuevo nombre
que nos da el usuario. Entonces este método
devolverá true si puede o
false si no puede. Y luego actualizar la interna en una variable de nombre aquí
internamente dentro de la clase. Y eso es perfectamente aceptable lugar de usar un
método en este caso, porque lo que podría
suceder es que tal vez necesitemos un método para luego
actualizar el editor, o necesitamos entonces otro
método para actualizar la calificación. Pero ahora estamos usando métodos para actualizar el nombre, por ejemplo. Bueno, todavía podemos
acceder al nombre en sí, así que necesitamos restringir el acceso
al nombre porque
solo queremos actualizar el campo name usando nuestro
nuevo método, update name. Entonces aquí es esencialmente donde entran las propiedades
C sharp. Y el principio de hacer que las variables
locales a una
clase
sean privadas solamente, se
puede ver en nuestra clase aquí tenemos todas estas
variables
aquí mismo se
puede ver en nuestra clase aquí
tenemos todas estas
variables
aquí mismo tenemos tres públicas y una privada. Hemos pasado por un ejemplo y te voy a
decir ahora es práctica
común hacer privadas todas
tus variables dentro de las
clases. Eso significa que nadie
fuera de la clase puede modificar estas variables
de ninguna manera. Si accedo al juego un objeto. Ahora no puedo acceder directamente al
nombre. No puedo acceder a la
variable editorial, nada. La única forma en que puedo acceder o actualizar el nombre es usando
nuestro método de actualización. Y eso es exactamente lo que queremos porque cuando el
usuario escribe en alguna entrada aquí, queremos que
pase por la validación. Queremos
asegurarnos de que el nombre tenga al
menos tantas letras o, ya
sabes, varias otras cosas. Y luego queremos actualizarlo
por fin. Entonces este método aquí es una solución aceptable
sobre cómo hacer eso. Y hace cumplir que todas nuestras variables aquí son privadas porque
son sensibles No queremos que otras
personas, ya sabes, accedan a estos y pongan
cualquier valor antiguo y hace cumplir encapsulación
así como un principio Core 00 Pero, ¿y si te dijera que hay una manera más fácil de
hacer este método? No tenemos que escribir
un método como este por cada vez
que actualizamos una variable. A lo mejor hay otra manera. Aquí es donde entran
las propiedades C sharp. Entonces voy a crear
una nueva propiedad de C Sharp. Ahora cuando creamos una propiedad, le
damos un modificador de acceso. Voy a llamarlo
público porque quiero que todos accedan a
nuestro campo de nombre. Entonces el nombre es una cadena. Como pueden ver aquí, el
nombre es una cadena, entonces tengo que darle un nombre. Ahora, al crear
propiedades y variables, por ejemplo, estas
también se conocen como campos. Los campos en sí por lo general y típicamente son
todos minúsculas. Puedes ver todos estos
son casos aquí mismo. Las propiedades en sí,
solo tienen una primera letra
mayúscula. Si las variables
aquí tienen dos palabras, entonces se vería
algo así. Caso de título, por ejemplo, sin los espacios en blanco. Esa es una práctica común. Los campos locales aquí, las variables locales
minúsculas y las propiedades siempre se
capitalizan al inicio Eso es sólo una buena práctica. Una vez que hayamos hecho esto, ahora
voy a mostrarles una propiedad
C sharp en su forma básica. Cada vez que queremos actualizar
el nombre del campo privado, pasamos por esta
propiedad aquí, al
igual que cuando
hablé del ejemplo. Cada vez que queremos
actualizar el campo name, utilizamos este método. Bueno, en lugar de usar
este método aquí, vamos a usar esta propiedad C
sharp en su lugar. Cada vez que queremos acceder a
esta variable local aquí, siempre
vamos a usar
nuestra propiedad en su lugar. Considera esto como un accesor
para nuestra variable local aquí. Para que la variable realmente obtenga el valor de la misma, la
va a devolver
usando la palabra clave return. Cada vez que queremos establecer un valor, entonces la
variable local va a
igualar esta palabra clave especial
aquí llamada valor. Ese es el valor que se está
pasando a esto. Veamos ahora mismo un ejemplo
de eso. Si entramos en nuestra clase
principal aquí, lugar de usar este
método aquí en nuestro ejemplo, lo que quiero hacer es
decir juego un nombre. Esta es nuestra
propiedad de tienda aquí mismo. Entonces en realidad podemos darle a esto
un valor como por ejemplo. Ahora lo que está sucediendo aquí, estamos usando el nombre de la propiedad, pero internamente
dentro de esta clase, en
realidad está entrando aquí
y estableciendo el valor. Esta sección aquí
dentro de esta declaración Get. Aquí es donde queremos
hacer esta validación. Copiemos todo
esto aquí mismo, entonces pongamos estas
llaves en una nueva línea Borremos eso por ahora. Lo que estamos haciendo aquí es cada vez que establecemos esta propiedad de tiro, se llama
esta declaración de conjunto. Puedes ver aquí cuando usamos un signo igual con un nuevo
valor en esta propiedad de tienda, internamente este bloque conjunto, todo esto se ejecuta
al final de esto, solo
queremos establecer nuestra variable
local aquí, nombre, a cualquier
valor que se pase. Ese
valor mágico de palabra clave del que estaba hablando será igual a
este valor aquí mismo, Lo que sea que se esté asignando. Cada vez que se establece esta
propiedad aquí, que es lo que estamos haciendo,
la estamos configurando, entonces estamos haciendo toda
esta validación aquí. Tenemos que usar el valor
mágico de la palabra clave, que es el valor que
en realidad estamos comprobando. Esto lograría exactamente
lo mismo que este método aquí. valor solo reemplaza el
nombre en esta instancia, vamos a comprobarlo y
repasarlo una vez más. Le estamos dando un valor al
nombre de la propiedad de la tienda aquí mismo. Ahora bien, el valor va a ser igual a, podría ser lo que sea. Realmente
no importa. Entonces el flujo de
ejecución entra aquí, y se
llama a este método set porque estamos
estableciendo un valor, esta palabra clave mágica aquí. El valor va a ser igual porque ese es el
valor que se pasa. Ahora estamos comprobando
que el del usuario, la longitud del nombre sea
menor o igual a uno. Si lo es, bueno no
podemos actualizarlo, entonces mala suerte, Hacemos cualquier otra validación,
cualquiera que sea. Si finalmente podemos actualizarlo, entonces vamos a establecer
nuestro nombre de variable privada, que es esto al valor
que se está pasando. Esa es la magia de usar una propiedad de tienda y
la palabra clave set aquí, no
necesitamos un método
completamente nuevo. Para lograr esto, podemos usar la
funcionalidad incorporada. La principal conclusión
de esto es que las propiedades de las
tiendas controlan el acceso
a la información sensible. Y estos artículos son todos nuestros campos locales aquí se consideran
todos información
sensible. No queremos que los usuarios simplemente
pongan valores antiguos aquí. Quizás queremos alguna
validación para asegurarnos, ya
sabes, de que los valores que
se pasan son precisos. Sabes que son válidos o
por cualquier otra razón. Y luego cuando finalmente lo estén, entonces podremos actualizar nuestras sensibles y preciosas variables
privadas en este caso. Entonces esta es la ventaja de
usar propiedades C sharp. Hemos hablado de la
palabra clave set bastante extensamente. Vamos a cubrir la palabra clave
get muy rápido. La palabra clave get
simplemente obtiene el valor de nuestra variable
privada. Nuevamente, podemos hacer varias cosas el
camino antes de devolverlo
en última instancia. Podemos hacer lo que queramos aquí, igual que en la
palabra clave set aquí mismo, podemos hacer lo que queramos. Pero en última instancia, finalmente
vamos a devolverlo fuera de aquí. Lo que podemos hacer aquí,
vamos a sacar el nombre del juego aquí a
la ventana de la consola. Cuando esta línea se ejecuta aquí, sólo
estamos salida en el juego
un nombre a la ventana Así que puedes ver aquí mismo. Entonces lo que sucede es internamente cuando
realmente obtenemos este valor, así que lo que queremos hacer es
obtener el nombre del juego. Internamente se está
llamando a este bloque get. Podemos hacer lo que
queramos aquí, cualquier comprobación, cualquier validación que pudiéramos
registrar en una base de datos o un archivo. Y entonces finalmente podemos devolver nuestra información sensible aquí, el campo privado fuera de aquí, y luego salir a la ventana. Puedes ver la palabra clave get, en este caso controla la obtención de nuestra variable
local aquí. Del mismo modo, la palabra clave set
controla la inicialización un valor a nuestro precioso campo
local sensible aquí mismo Y nuevamente, siempre es una
buena práctica tener una propiedad C sharp para cada uno de sus campos
privados aquí. Y por defecto,
siempre debes hacer que tus campos locales privados a menos que haya alguna circunstancia
atenuante o razón especial para no Una de las otras
cosas que podemos hacer con propiedades
C sharp es
hacerlas de solo lectura. Lo que quiero decir con eso
es que el usuario puede acceder a las variables
privadas, pero no pueden inicializarlas, no
les pueden dar ningún valor Por ejemplo, digamos
el campo editor, queremos que eso sea de
solo lectura. ¿Qué quiero decir con eso? Por ejemplo, digamos que
si quiero obtener el editor para alguno
de estos objetos de juego, usaría Game one publisher. Y eso sería como leer solo puedo acceder a
la información. Pero cuando en realidad
intento establecer los datos, por ejemplo, establecer el
nombre, no puedo hacer eso. No me deja, ¿cómo
voy a hacer eso? A lo mejor es algo útil. Lo que podemos hacer aquí es crear una nueva propiedad para
nuestro editor. Nuevamente, tenemos nuestro formato
familiar, hacemos una mayúscula sobre el
justo por buenas prácticas. Entonces Visual Studio
nos está ayudando insinuando lo
que podríamos querer hacer Eso es genial, los usaré. Así es como hacer que una
propiedad sea de solo lectura. Lo hacemos, simplemente no definimos
una palabra clave establecida en absoluto. Sólo tiene una entrada aquí. Ahora, no puedes tener
un set por sí solo, siempre
necesitas un get. Pero puedes tener solo un get
que lo haga de solo lectura. Echemos un
vistazo a ese ejemplo. Ahora bien, si queremos mostrar editor a la pantalla, simplemente
podemos hacer eso. Podemos mostrar el
editor a la pantalla. No es ningún problema,
va a funcionar. Si trato de
establecer un valor aquí, quiero actualizar esta
editorial a cualquier cosa realmente. Puedes ver que
aquí hay un error, hay una línea roja. Si pongo el cursor sobre eso,
puedes ver aquí, no se puede asignar
propiedad o indexador, es de sólo lectura Eso es solo porque en realidad no
hemos establecido una palabra clave establecida aquí. No hay setter, en
realidad no podemos establecer un valor aquí. Esto es bastante útil si tienes algún campo sensible aquí donde solo quieres acceso de lectura. A lo mejor queremos leer
nuestro campo ID aquí, pero no queremos que el usuario
lo establezca por ejemplo. Entonces tendríamos algo como esto donde solo proporcionamos acceso de
lectura a nuestras
variables locales aquí mismo. Otra cosa que incluso
podemos hacer es agregar modificadores de
acceso a
nuestras y establecer palabras clave Aquí tenemos nuestro nombre aquí, queremos que todos
obtengan el nombre. Pero sin embargo, tal vez queremos que el escenario
de este sea privado. Solo las cosas dentro de nuestra clase
aquí en realidad pueden hacer esto. Lo que podemos hacer aquí, podemos
hacer privado al setter. Y eso significa que si intentamos establecer este valor de nombre aquí desde
cualquier lugar fuera de esta clase, no
va a letras. Entonces si voy al archivo
principal aquí, lo que estoy haciendo es
intentar inicializar el nombre como un valor.
Yo me cierro sobre eso Se puede ver que no se puede usar en este contexto porque el
accesorio set es inaccesible En realidad no podemos configurarlo desde ningún lugar fuera de esa clase. Tan pronto como lo quite, se
puede ver que el error desaparece y podemos volver a establecer el
nombre. Las propiedades afiladas son en
realidad bastante poderosas, solo
acabamos de tocarlas, pero creo que esto
será suficiente para que
comiences con tus
esfuerzos en usarlos. Lo que debes
quitar de esto es que las propiedades en C Sharp, el acceso de control usando getters y setters a
tus campos privados, que forman parte de
tus clases de C Sharp Gracias por ver.
43. 9-6. Herencia: Bien, herencia en C Sharp. Puede que hayas escuchado
la palabra antes, quizá no la hayas escuchado, pero ahora mismo la
voy a explicar
. Entonces, ¿qué es la herencia
en C Sharp? Básicamente, el
principio central en torno a la herencia es aumentar la reutilización del código Y eso es muy importante incluso en términos de programación
orientada a objetos, no en términos de programación
orientada a objetos El caso es que, si copiamos
y duplicamos código, entonces nuestro software
eventualmente será muy
difícil de mantener. Va a tener
un archivo de gran tamaño y vas a
tener muchos problemas. Siempre, siempre reutilice
código cuando sea posible. Echemos un vistazo a un ejemplo de
herencia en C Sharp. Entonces lo que tengo aquí es una aplicación
muy básica. He creado un nuevo objeto animal y tengo una
clase de animales para eso. Echemos un vistazo a
la clase de animales. Entonces aquí está mi clase de animales. Tiene
aquí dos campos privados, nombre y edad. Entonces el nombre del
animal podría ser Rocky, y la edad de Rocky podría ser siete, como Rocky podría ser
un perro por ejemplo. Tengo aquí dos
métodos básicos que solo hacen eco del nombre
del animal a la ventana de
la consola
y también otro método aquí que hace eco de
la edad del Tengo dos propiedades de tienda aquí, dos propiedades públicas que permiten control sobre mis
campos privados aquí, nombre y edad. Entonces es una clase muy sencilla. He creado un objeto
animal aquí. He establecido el nombre propiedad
y edad rocosa en siete. Ahora solo estoy usando estos
métodos aquí que simplemente hacen eco estos valores a la pantalla
si ejecutamos la aplicación. Ahora puedes ver
que es muy sencillo. Mi nombre es Rocky,
tengo siete años. Entonces esa es una clase básica de
animales ahí. Entonces ahora digamos que quiero
ampliar mi aplicación. A lo mejor quiero una pieza de software donde pueda
crear un zoológico de animales. Podría querer una clase de perro, una clase ratas, una clase de gatos,
una clase de hámster. Quizá quiera
20 clases y cada una representando a un
animal a su manera. Si venimos por aquí ahora, podemos hacer clic derecho en
el proyecto aquí y podemos ir a agregar nueva clase. Y digamos que queremos
crear una clase de perros. Esta clase tendrá
todo que ver con un perro. Por ejemplo, tal vez el
zoológico tiene cientos de perros y queremos manejar a nuestros perros en su
propia clase de perros. Es perfectamente razonable. De nuevo, podríamos
tener una clase de gatos, una clase de hámster, muchas cosas. Pero lo que queremos, nuestra clase de perros, queremos toda
esta funcionalidad aquí de esta clase animal, porque nuestro perro va a tener un
nombre, va a tener una edad. Pero a lo mejor tiene
algunas otras cosas, como tal vez algunos métodos
que ver con la excavación. Y no todos los animales pueden cavar, Por ejemplo, tal vez algo
específico para un perro. Pero sí queremos esta funcionalidad
central. Nuestro perro va a
tener un nombre y una edad. Quiero todas estas cosas y voy a poner
eso en mi clase de perros. Así que ahora puedo
construir sobre esto. Puedo agregar algunos métodos
para, ya sabes, la excavación del perro o el
perro que pide golosinas,
o tal vez ciertos trucos para perros Pero el problema es que hemos copiado toda esta funcionalidad central que va a
funcionar, no hay problema. Pero el problema es cuando
tengo otra clase, tal vez una clase de gato o
una clase de conejillo de indias , de
nuevo, quiero que también tengan esta funcionalidad central. Y el problema es que voy a tener toda esta información en unas 20 clases diferentes y va a ser muy
difícil de mantener. Y no sólo eso,
va a aumentar, como digo antes, el
tamaño del archivo en la aplicación. ¿Cómo solucionamos
este problema aquí? O tienda tiene algo que podemos utilizar y eso se
llama herencia. Herencia en C Sharp, es muy fácil empezar, pero quizás más
complejo de dominar. Pero comencemos y echemos
un vistazo a cómo podemos hacerlo. No necesitamos ninguna de esa
funcionalidad en nuestra clase. Lo que podemos hacer es heredar la funcionalidad de
la clase animal Toda esta lata de cosas aquí, todas las cosas públicas de todos modos. Y podemos ir a nuestra clase de perros
y podemos usar dos puntos y luego escribir la
clase de la que queremos
heredar las características En este caso va a ser
animal con sólo hacer eso. Aquí hay una
pieza muy pequeña de código. Ahora nuestra clase de perros
conoce todos
los métodos públicos aquí y cualquier propiedad pública que
podamos tener en esta clase. Echemos un vistazo a un ejemplo. Ahora mismo, puedes ver que nuestra clase de
perros está perfectamente vacía. Nuestra clase animal
tiene toda esta lógica. Vamos a crear un nuevo
objeto para un perro y ver si
realmente podemos usar algunas de estas propiedades y
métodos aquí mismo. Vamos a crear un nuevo
objeto para un perro. Yo sólo lo llamaré Do.
Podemos poner el nombre al perro. Bingo, ¿por qué no la edad del perro? Podemos fijarlo en
tres, por ejemplo. Sólo voy a renombrar estos. Puedes ver aquí,
no hay líneas rojas debajo de
estas propiedades. No hay errores al
usar estos métodos. Incluso podemos ejecutar la
aplicación, no hay problema. Y ahora, mira, mi nombre es Bingo. Tengo tres años. Puedes ver aquí, el perro ha heredado toda la
funcionalidad del animal, todos los métodos públicos
y propiedades del animal. Puedes ver aquí está la clase de
perros aquí mismo. Está totalmente vacía. Pero puedes ver que estamos
usando todo este código aquí que es realmente
eficiente y ese es el punto de herencia. En este ejemplo aquí, decimos animal es o
la clase de padres, como la forma en que tienes un
padre y un hijo, donde el niño podría heredar
la capacidad de respirar, o sangrar, o comer
cosas en tu ADN De ahí viene la
terminología. El animal en este caso sería el padre y el perro
sería el niño. Pero algunos otros sinónimos
para eso
serían la clase base
o la superclase Perro sería el niño, la clase derivada
o la subclase Todos son sinónimos, pero
básicamente significan el
mismo tipo de cosas. Al considerar la
herencia en C Sharp, que considerar una
cosa, un pensamiento debe estar
yendo en tu cabeza, y eso es un es un perro, un animal es un gato. Un animal es una rata, un animal. Si es así, entonces la herencia
es perfecta para ti. Y no estás
malentendiendo el concepto. Siempre considera cuando estás
heredando en una tienda es es una relación La herencia es un tema muy
largo. Pero otra cosa
voy a explicar así que queda absolutamente claro
lo que voy a hacer. Voy a definir
un método dentro nuestra clase de perros que
es único para un perro. Quiero que eso sea, quizá
ladrar, por ejemplo. Porque todos los perros ladran, déjame crear un método
donde el perro ladraría. Así se puede ver que he creado
un método aquí llamado ladrido. Y todo lo que hace, escribe en
la ventana de la consola. Woof, guay. Así que muy sencillo. Y al igual que en
los humanos, si tienes una, puedes heredar cosas
cuando naces, como mencioné antes Pero el padre no puede
heredar del niño. Por ejemplo, si el niño tiene una nueva habilidad como
ladrar por ejemplo, entonces el animal
no tiene conocimiento de esto Al igual que en una relación de padres,
hijos, si tu hijo tiene una nueva habilidad, tal vez se convirtió en artista. No significa que el
padre sea artista. Ya sabes, la herencia
no funciona de esa manera. Entonces déjame mostrarte un
ejemplo de eso ahora. Así que hemos definido un método en
la clase de perros llamado ladrido. Si voy a nuestro
programa principal de cañones aquí mismo, si pongo un puntito
tras animal aquí, se
puede ver animal no tiene
conocimiento del método de ladrido. Ni siquiera está en esta
lista lo que se espera. Sin embargo, si vamos al
perro aquí y escribimos, ¿tenemos nuestro método que
acabamos de crear llamado ladrido? Ya podemos ejecutar la aplicación
ya puedes ver que puedes. Entonces el perro está ladrando y luego sólo estamos haciéndonos eco del nombre y
la edad del Ese es un ejemplo muy básico
de herencia en una tienda.
44. 9-7. Método de sobreescritura (polimorfismo): Bien método sobre montar a caballo. Si no has visto el
tutorial anterior sobre herencia, entonces te sugiero que
veas eso porque de eso se desprende
lo que tengo aquí. Tengo una clase básica de animales. Le estamos dando nombre y edad a la
clase animal. Ahora tengo una clase de perros. Y nuevamente, el perro
tiene nombre y
edad y también una
clase de gato aquí mismo. Y hacen varias
cosas con el animal. Estoy diciendo el nombre
edad y haciendo un ruido igual para el perro
y lo mismo para el gato. Si voy a mi clase de animales aquí, tenemos las cosas habituales, los métodos
del último tutorial. Pero también tenemos un método más aquí y se llama make noise. Todo lo que hace es hacer
eco de algo a la pantalla que dice que hace ruidos
aleatorios de animales Tengo una clase de perro que
hereda de animal. Hereda toda la
funcionalidad pública que le
hemos definido. Y una clase de gatos que también hereda del animal,
pero no hacen nada Las clases de gato y perro no están
haciendo nada Ahora mismo, si ejecutamos el programa, puedes ver aquí,
mi nombre es Henry. Tengo cinco años. Hace ruidos aleatorios de animales. Y hace lo mismo por lo
mismo para el gato. Lo que estamos haciendo aquí, estamos heredando toda
esta funcionalidad Pero se puede ver en
particular que estamos heredando este método
aquí llamado make Noise Ahora bien, esto es parte de la clase
animal, por ejemplo, tal vez no sepamos qué
tipo de animal
tenemos, solo tenemos un
animal genérico llamado Henry. No obstante, en mi clase de perros, bueno, sé que los perros ladran. Por ejemplo S, me
gustaría que Lassie bar. No quiero que Lassie
haga ruidos aleatorios de animales. Lo mismo con la
clase de gatos. Tenemos a Félix. Me gustaría que el
gato por ejemplo, podría hacerlo
fácilmente definiendo un nuevo método aquí llamado
ladrido en la clase de perros. Entonces en la clase de gato, puedo definir un método
llamado make noise o per, o maullido o algo así,
que es único para un gato Pero lo que realmente podemos hacer es anular este método
aquí llamado make noise. Lo que eso significa es que podemos heredar esta
funcionalidad de ruido. Pero no va a hacer esto, va a hacer otra cosa. Eso es algo más que podemos
definir en nuestra clase infantil. Por ejemplo, la clase de perros. ¿Cómo anulamos este método? ¿Cómo heredamos
esto y lo anulamos? Bueno, en la
clase infantil aquí, perro, ya
estamos
heredando el método ya porque estamos haciendo ruidos
aleatorios de animales Pero queremos que el perro ladre. Entonces, ¿cómo hacemos eso? Lo que tenemos que hacer en la clase de padres, así que en este caso animal, necesitamos hacer del método
lo que se llama virtual. Y lo que es eso, es una
nueva palabra clave llamada virtual. Y eso solo dice, bien, cualquiera que herede esta clase, puedes darle tu
propia definición a este método si
quieres. Es tu elección. No tienes que hacerlo ahora mismo. Ni siquiera estoy haciendo eso. Yo ejecuto el programa, estoy heredando
toda esta funcionalidad. Virtual es básicamente
decir, bien, la opción está ahí para
redefinir tu propio contenido Para este método, es opcional, no
tienes que hacerlo.
Eso es virtual. Pero lo que queremos hacer, sí, en realidad queremos
nuestra propia funcionalidad. Por ejemplo, en esta clase
infantil aquí, haz lo que quiero
hacer cuando llame aquí al método make
noise. Quiero ladrar.
Quiero que el perro ladre. Para hacer eso, digo
ladrar o guau, o tal vez ambos. ¿Por qué no? He copiado
este método desde arriba, pero aquí no ponemos virtual. Usamos una nueva palabra clave
llamada override. Y esa es otra vez una palabra clave
especial. En la clase base, la clase padre, usamos
la palabra clave virtual. En la clase hijo, usamos la palabra clave override. Eso básicamente es decir, bien, estoy heredando este método
del animal de clase padre, pero quiero mi propia definición Quiero anular tu lógica
cano y poner mi propia anulación siempre
va en la clase infantil, en este caso perro. En la clase base, tenemos que
configurarla a virtual. Si no ponemos virtual, entonces no podemos anularlo. Van juntos como una
pareja en nuestra clase de gatos. Bueno, quiero el gato para mí ahora, Por ejemplo ahí, es tan sencillo como si
ejecutara la aplicación. Ahora puedes ver aquí
mi nombre es Henry. Ahora Henry es un animal genérico. No es un perro o
no es un gato. Henry hace ruidos aleatorios de
animales. Sin embargo, Lassie
o Less es un perro. Cuando llamamos al método hacer
ruido aquí para el perro, entonces el perro va
a ladrar y guau Bueno, el gato
no va a hacer ruidos
aleatorios de animales porque la clase de gatos también anula
el método virtual Hacer ruido y el
gato está maullando. Se puede ver que es un ejemplo
bastante básico de cómo podemos reutilizar
este método aquí, hacer ruido que se define
en nuestra clase padre, pero darle nuestra propia
definición a ella. Esto es reutilizar
código existente como este método aquí. Pero no queremos esta
funcionalidad, Queremos la nuestra propia. El proceso de definir
nuestra propia definición es un ejemplo de lo que
se llama polimorfismo ¿Qué es eso? Es
una palabra griega que significa muchas formas o muchas formas. Pero es un principio clave de la programación orientada a
objetos. Entonces has estado
haciendo un ejemplo de polimorfismo todo este tiempo,
tal vez sin Pero este es el principio clave
de la programación 00 y es muy importante como ya
has visto. Se logra a través de
la herencia y la reutilización del código. Pero no sólo eso, sino aportando tu propia
definición para algo. Entonces esto es polimorfismo. Entonces este es un ejemplo de
sobreposición de método en C sharp.
45. 9-8. Herencia multinivel: Bien, herencia multinivel. Si no has visto los tutoriales
anteriores
sobre herencia, te
recomiendo encarecidamente que
los veas ahora porque se desprende de esa herencia
multinivel. Entonces veamos un
ejemplo aquí mismo. Aquí tengo una clase de animales, Aquí está justo aquí. Define algunas
cosas básicas que hacer con los animales, sobre todo este método
aquí hacen ruido. Ahora bien, este método es virtual, lo que significa que cualquier clase infantil de este animal de clase base puede definir
opcionalmente su propio
contenido para este método. Bien, ya hemos hablado de esto, ahora tenemos dos clases nuevas. Uno llamado carnívoro y su clase parental es animal
y otra llamada El carnívoro es como
comer carne y un herbívoro come plantas y un herbívoro es un animal Así es que satisface ese
tipo de relación. Y el herbívoro
anula el método del animal de clase parental y define su propia funcionalidad,
que es que soy herbívoro, hace que la planta coma ruidos, y lo mismo con el carnívoro define su propia funcionalidad,
que es que soy herbívoro,
hace que la planta coma ruidos,
y lo mismo con el carnívoro. Está anulando
el método virtual y definiendo su propio código Soy carnívoro hace
carne comiendo ruidos. ¿Bien? Si creamos
un objeto que es carnívoro o herbívoro
y ejecutamos este método, vamos a Ahora, gato y perro. Ahora, el gato es carnívoro. El perro también es carnívoro. Se puede ver lo que está
pasando aquí es que el perro es casi como el
nieto de animal La clase carnívora se sienta
entre perro y animal. La clase base aquí es
animal, luego animales, niño es el carnívoro, luego el hijo de
carnívoro Ese es un ejemplo de herencia
multinivel. Aquí tenemos una jerarquía. Tenemos al nieto, al perro. El padre es el carnívoro. El abuelo sería
el animal por ejemplo. Aquí hay múltiples capas
de herencia, puedes hacer perfectamente lo que
encuentres en C sharp. Esto es sólo un ejemplo. Se puede ver aquí perro también anula el
método hacer ruido Es ladrar, guau. Entonces echemos un
vistazo a un ejemplo. Aquí estoy creando un nuevo animal, esa es la clase base,
como el abuelo Estoy creando un nuevo perro que es como el nieto y un gato nuevo, y luego estoy llamando al método make noise en cada uno de estos No tengo un objeto carnívoro. No tengo un objeto herbívoro. Ejecutemos la aplicación aquí. Hace ruidos aleatorios de animales porque no sabemos
qué animal es Henry Eso es lo que hemos definido entonces. Perro y gato tienen sus propias
definiciones para hacer ruido. Corteza, lobo y O, ¿qué pasa si le quito
este método aquí al perro? ¿Qué pasa? ¿Estoy
heredando carnívoro? ¿Estoy heredando animal
como el abuelo de esto? Bueno, te voy a mostrar ahora mismo, hereda la clase padre, así puedes ver ahora no tengo un método llamado
hacer ruido en perro Cuando el perro hace ruido, mira a su clase de padres, y en este caso es carnívoro Carnívoro es en realidad
anular hacer ruido y dar su propia definición
cuando ejecutamos Este es Henry, el animal
aleatorio Noise. Vamos a poner eso a
la vista ahí. Este es Henry, este es el perro. Porque la clase de perros
ahora no está anulando esto. Ahora salta a su padre, que es carnívoro
que sí lo anula Ahora el perro está diciendo, soy carnívoro, hace ruidos de comer
carne, y el gato todavía tiene su propio método anulado definido para que el Pero ese es un ejemplo muy
básico de herencia
multinivel en C Sharp y cómo
podemos utilizarla. ¿Cuántas capas de
herencia puedes tener? ¿Qué tan grande puede construir este árbol
genealógico animal por ejemplo? Bueno, no hay un límite establecido
real, pero al hacer software, no
quieres que sea
absolutamente ridículo. 234 niveles tal vez, podrían estar dependiendo del
tamaño de su aplicación. Así que teniendo diez o 50
niveles de herencia, no
puedo pensar en
un ejemplo de por qué
alguna vez querrías hacer eso. Pero el propósito de este
tutorial es solo
mostrarte como esto es posible
y sabes que es, la gente lo usa en el mundo real. Hay otro tipo de herencia y eso
se llama herencia múltiple. Ahí es donde una clase, por
ejemplo, como gato, puede heredar no
sólo, por ejemplo, de
animal, sino quizá de
otra cosa como felino o algo otra cosa como felino o Entonces dos clases. Ahora, shop
no soporta esto de forma nativa, pero se puede lograr
a través de interfaces, que vamos a discutir
en un tutorial posterior. Entonces hay diferentes
diseños para la herencia, pero esto es solo un ejemplo
de herencia de múltiples capas. Entonces, ¿puedo empezar con? Espero que este tutorial
te haya ayudado a considerar muchas de las posibilidades con
herencia en tienda.
46. 9-9. La palabra clave sellada: Quiero hablar la palabra clave sellada en tienda
y se ve así. La palabra clave sealed es bastante
útil para restringir la herencia a nivel de clase.
¿Qué significa eso? Aquí tengo un ejemplo de herencia
multinivel en tienda C. Tengo una clase de juego que es como la madre, por ejemplo. Tengo videojuego,
que es el niño. Y luego tengo a Super Mario, que es el nieto Entonces se ve algo así. Entonces aquí está el juego de la clase base. Sólo tiene un método
que dice lo que es genial, y está marcado como virtual. Entonces eso significa que cualquier clase
hijo de esto puede optar por anular este
método si así lo desea. Entonces, debajo del juego de clase
base, tengo uno llamado
videojuego que hereda del juego y
anulado ese método Pero en vez de decir que
el juego es genial, es decir que este
videojuego es genial. Entonces tengo la clase de
nietos en esta aplicación que está
heredando del videojuego También está anulando el método
what is call. Ahora dice que Super Mario es llamado. Si miro esta
aplicación aquí donde
configuro tres objetos y
simplemente llamo a esos métodos, solo
va a dar salida a los resultados de esos métodos,
Eso es polimorfismo Lo que puedo hacer con
la palabra clave sellada, realidad
puedo restringir
la herencia en una clase. El videojuego es como el
relleno de este sándwich. Su padre es juego, pero su hijo es Super Mario. Entonces, por ejemplo, si digo que
esta fue una clase sellada, eso significa que ninguna otra clase
puede heredar de esta clase, así que no puede tener
más hijos Imagínate que sea como tal vez una fasectomía o
algo así Sin embargo quieres
intentar recordar que ahora si voy a
la clase infantil, ya
ves que ahora
hay un problema. Super Mario no puede derivar del videojuego de clase
sellada porque videojuego no puede tener
más hijos. Está sellado. Previene la herencia
a nivel de clase aquí, ¿a qué me refiero a nivel de clase? Eso solo significa en
esta línea aquí mismo. Sin embargo, en realidad podemos
usarlo a nivel de método también. Y eso restringe cualquier
herencia adicional a un método, no a toda la clase,
sino solo a un método No podemos poner esto en la
clase base como regla general, nunca
podremos poner esto en la clase magistral,
el padre supremo. Lo que haríamos, definimos un método aquí llamado
lo que es genial. Lo marcamos como virtual. Cuando algo se
marca como virtual, eso significa que la
clase hijo puede proporcionar su propia definición al
anular el método Ya lo hemos hecho antes. Ahora voy al niño inmediato, que es videojuego. Estoy anulando este
método, ¿verdad? Esta es la primera
vez que estamos anulando este método porque es
el hijo inmediato Aquí es donde puedo hacer
uso de la palabra clave sealed. Solo puedes usar
sellado con anulación. No se puede usar con virtual. Tiene que ser por lo menos
un nivel inferior. Ahora estoy restringiendo cualquier
otro acceso a este método. Lo que es genial ahora la
pobre clase Super Mario, ya no puede usar este
método. Se puede ver. Entonces no se puede anular el miembro
heredado, lo que se llama
porque está sellado. El uso de la
palabra clave sealed evita a nivel de
clase cualquier
herencia adicional de la clase misma. Y un nivel de método evita cualquier anulación adicional
del método, siempre y cuando el método
esté marcado como sellado Entonces ese es el poder de la palabra clave
sellada en C Sharp.
47. 9-10. Clases abstractas y métodos abstractos: Hablemos de
clases abstractas y métodos abstractos. ¿Qué son? ¿Por qué
deberíamos usarlos? Echemos un vistazo a
este ejemplo aquí, siguiendo desde antes. Si no has visto
los otros tutoriales, te
recomiendo que
los veas porque
siguen uno de esos. Tenemos nuestra clase base aquí, animal, y solo estamos
configurando un animal llamado Henry. Tenemos nuestro perro que
hereda de animal, y nuevamente un gato que
hereda de Y sólo nos estamos haciendo eco
del nombre del animal, el perro y el gato Aquí está nuestra clase de animales.
No está haciendo mucho. Tenemos tres métodos. Hemos marcado, hacemos ruido, decimos la edad y decimos el
nombre. Todo como virtual. Si las clases hijo quieren
anularlas, pueden hacerlo. Ahora estamos anulando el mismo nombre. Si obtenemos el
nombre del perro, es decir, oh mi nombre es entonces el nombre del perro y
luego guau al final Y lo mismo con el gato.
No está pasando mucho. Realmente no nos hemos
construido tanto sobre él. Nosotros ejecutamos el programa, esto es lo que se puede
ver, por ejemplo. Es bastante normal. Ahora imagina que tienes una pieza de software muy
grande. Tienes otras diez personas
trabajando en el software, y quieres una clase
para cada animal. Estás emulando un
zoológico, por ejemplo. Estás creando una
pieza de software para un zoológico o incluso un juego de Pokémon. Y quieres una clase para cada
personaje o cada animal. Podrías hacer que una persona en tu equipo cree
todas estas clases, pero en equipos de tal vez
diez o 100 personas, vas a
delegar eso. No vas
a ser el único cree estas clases. En estas clases aquí tenemos una que dice hacer ruido y
es ladrar y wooffing Tenemos uno que
dice decir el nombre y es decir el
nombre del animal, por
ejemplo, el perro aquí. Y el perro woofs después de hacerse
eco de su nombre.
Lo mismo con el gato. Pero y si nuestro compañero Randy,
por ejemplo, está
creando una clase de hámster A lo mejor se olvida de
anular este método. Recordó decir el nombre,
pero a lo mejor se olvidó de
hacer el ruido cuando se ejecuta
la aplicación en lugar anular hacer ruido y
está haciendo sonidos de hámster Simplemente va a
hacer que la lata predeterminada suene de clase
aparente aquí, ruidos de animales
aleatorios Entonces, ¿cómo podemos decirle a
Randy, nuestro amigo, y olvidaste
anular este método,
hacer ruido, tus hámsters
no hacen ruidos de hámster Bueno, en realidad podemos hacer cumplir esto en nuestro animal de clase de padres. Lo que podemos hacer en animal, podemos decir, bien, voy a elaborar
un contrato y decir cualquier clase que herede
esta clase tiene que anular,
digamos, estos tres métodos aquí De lo contrario el software ni
siquiera compilará. Ni siquiera podemos ejecutar el software que nos asegure de que
nuestro amigo Randy, por
ejemplo, anula los métodos queremos que anule nuestro amigo
Randy Podemos introducir algo
llamado clases abstractas. Para lograrlo, ¿qué hacen las clases
abstractas? Imagínalo como bien, si quiero una clase abstracta
y un método abstracto, cualquier clase que
herede esta clase aquí tiene que anular
esos métodos Tienen que especificar
una definición. Si se trata de un método abstracto perteneciente a una clase abstracta, entonces si Randy, nuestro amigo, crea una clase Hamster, entonces el software ni
siquiera se ejecutará Si no proporciona su propia definición para estos métodos, esa es la ventaja de una clase abstracta y
un método abstracto. Te voy a enseñar
cómo configurarlo. Ahora lo primero que
hacemos para configurar una clase abstracta es
marcar la clase como abstracta. Eso es tan simple como escribir ahí la
palabra clave abstracta. Eso hace un par de cosas. Una vez que marcamos una
clase como abstracta, ya no
podremos crear un
objeto a partir de esta clase. ¿Qué significa eso? Si
vamos al programa aquí, se
puede ver que estamos creando un objeto animal
aquí llamado Henry. Ahora no sabemos
qué animal es Henry, acaba de ser usado
en nuestro ejemplo. Pero puedes ver aquí
ahora hay una línea roja debajo de esta nueva línea de
instancia aquí mismo. Cuando pongo el cursor sobre eso, dice, no se puede crear una instancia
del tipo abstracto o animal de
interfaz Eso es porque si marca
alguna clase como abstracta, ya no se
puede crear
una instancia de esa clase. Ahora, Henry, vamos
a tener que decidir qué tipo de animal es
Henry en este momento. O es un perro, un hámster, un gato, o algo más. Pero ahora hemos marcado esta clase
animal como abstracta. No podemos crear una
instancia de animal. Henry va a tener que ir y vamos a tener que tomar
una decisión sobre lo que es Henry. Pero eso es por diseño. Si tienes una clase abstracta, no
puedes crear una
instancia de esta clase. Ahora, método abstracto. Entonces tenemos nuestra clase
abstracta establecida. Ahora vamos a crear
un método abstracto. Como mencioné, si
un método es abstracto, entonces cualquier clase hija que herede esta clase debe
proporcionar una definición Por ejemplo, nuestra clase de perro do
class hereda de animal. Lo que voy a hacer, voy
a eliminar estos dos métodos. Perro es simplemente heredar
las cosas normales. Ahora, voy a marcar
este método como abstracto. Este es un método abstracto. Cuando marco un
método como abstracto, no
podemos proporcionar una
definición para el método. Como mencioné antes, impone en todas las
clases infantiles proporcionar su propia definición porque ni siquiera
podemos crear
una instancia de esta clase y
solo estamos haciendo cumplir las clases
infantiles para proporcionar
su propia Entonces no
tiene sentido ni siquiera tener una definición aquí
porque es irrelevante Nunca se
llamaría ni se alcanzaría cuando definas un método
abstracto, es solo una plantilla. Es solo decir, bien,
todas las clases infantiles, necesitas proporcionar tu propia
definición para este método. En la clase de gatos, estamos
haciendo exactamente eso. Tenemos nuestro propio método aquí y lo
estamos anulando cuando define un método como abstracto para proporcionar
su propia definición, al igual que virtual, usa
la palabra clave override aquí Ahora en la clase de perros, se
puede ver que hay un error. Si pongo el cursor sobre perro
aquí está diciendo mira, perro no implementa heredado abstracto miembro
animal hacer ruido Se puede ver que el software ni
siquiera está compilando. Simplemente no podemos
compilar el software. Esa es la razón por la
que tenemos que hacer, tenemos que definir ese método. Nuestro amigo Randy que olvidó
su definición para su hámster
haciendo ruidos de hámster Bueno, ahora el software
físicamente no
compilará a menos que nuestro compañero recuerde sobrescribir Ese es un muy buen uso de
tener un método abstracto. Podemos hacer esto por
todos estos métodos. Por ejemplo, por
ejemplo, di nombre. Podemos definir una
plantilla para eso. Quizás te preguntes, ¿cuál es el punto de
tener siquiera un método? Entonces, por ejemplo, por qué
incluso han dicho, envejecer bien. Eso es porque todas nuestras
clases de niños como gato y perro, todavía
pueden usar
digamos, envejecer aquí. Por ejemplo, podemos llamar digamos, edad en estos métodos, podemos utilizarlos de cualquier clase
hijo de esta. Estos métodos siguen siendo útiles. Entonces este es un método estándar, pero este es un método abstracto. Los métodos abstractos, básicamente
estamos obligando a todas las clases infantiles de animales
a implementar algo. Para darle una definición, una función, eso es lo que es
un método abstracto. Está obligando a todas las clases de niños a implementar una
definición para ellos. Sin embargo, todavía podemos tener métodos
normales como
decir la edad por ejemplo. Todavía podemos usar
virtual y hacer que perro y gato
anulen los métodos virtuales. Esos están perfectamente bien, pero ese es el
punto de lo abstracto. Entonces, el uso de clases abstractas aquí, como animal, no solo
impone la abstracción, que hablamos antes con modificadores de
acceso, sino también polimorfismo, donde podemos definir nuestra propia lata de función Aquí, no solo eso, sino que las clases abstractas pueden hacer cumplir cualquier clase hijo que herede del animal le da alguna funcionalidad
a estos métodos, considerarlo como un blueprint o un contrato o
algo así Agradezco que este tutorial
pueda ser mucho para asimilar, pero siéntete libre de
repetirlo una y otra vez
hasta que entiendas Pero este es el
principio genérico detrás las clases
abstractas y los métodos
abstractos en tienda.
48. 9-11. La palabra clave: Voy a hablar de
esta palabra clave en C sharp, se ve así. Lo que esto es, básicamente es un atajo para una
instancia de una clase. Aquí tenemos una clase llamada dog, y estoy creando una instancia. Esto puede ser un atajo
para esta instancia aquí. Si miro mi clase de perro aquí, tiene un método
llamado hacer ruido. Cuando llamamos a ese método, es solo escribir corteza guau en la ventana
de la consola Si nos fijamos en eso, ahora
estamos llamando a hacer ruido. Si ejecuto el programa,
puedes ver que no hace mucho. Si voy dentro de esta clase de perro, puedo referirme a esta instancia
actual cuando se
está llamando a este método. Por ejemplo, voy aquí, si tecleo en esto,
me puedo referir a cualquier cosa que tenga que ver con esta instancia actual que
se está creando aquí. Veamos un
ejemplo de eso, solo para que pueda demostrártelo. He creado una clase
llamada helper. Ahora ayudante no hace mucho. Tiene un método
llamado hacer más ruido. Se necesita un parámetro, que es un perro tipo, y ahí está la
instancia del perro. Esto se está pasando como parámetro
a este método. Estamos escribiendo una línea, estoy haciendo más
ruido para el nombre del perro. Si voy a mi clase de perro aquí, voy a crear
una nueva instancia de ayudante para poder
usar la clase. Entonces voy a usar
ayuda, hacer más ruido. Quiero pasar en
una instancia de perro. Lo que puedo hacer es pasar
en la palabra clave esto, porque esto representa
la instancia que he creado aquí mismo. Cuando llamamos al método
en esta instancia. Imagínate que aquí lo
recuerden. Ahora bien, esto representa
esa misma instancia. Imagina que esto es esto. Ahora, cuando llamamos helper, estamos llamando al
método, hacemos más ruido. Esta instancia está siendo aprobada
. Ha recorrido un largo camino. Ahora solo nos estamos
haciendo eco del nombre
del perro que pertenece a
esa instancia actual Si ejecuto el programa ahora
puedes ver a Barkworfi'k. Más Ruido ¿Qué? Está en blanco porque no
le hemos dado nombre al perro. Vamos a darle un nombre al perro. Entonces, nombre de perro. Vamos, llamémosle Rocky. Por qué no Ahora el perro tiene
nombre. Volvamos a ejecutarlo. Ahora, estoy haciendo más
ruido para Rocky. Se puede ver que ese es el
poder de la palabra clave, esto. Toma la instancia actual, es básicamente un
atajo para ello. Imagina que esto es un atajo
para la instancia actual. Y podemos hacer lo que
queramos con él. Podemos acceder,
acceder a propiedades, acceder a cualquier campo privado, o incluso pasarlo a diferentes
métodos como parámetros. Ese es el poder de
esta palabra clave en tienda. Otra cosa que podemos hacer con
esta palabra clave en C Sharp. He aquí un buen ejemplo. Veo que la gente hace esto
mucho si tenemos un constructor para una
clase como animal, y toma en dos parámetros, por ejemplo, nombre y edad. En nuestro constructor, queremos
construir nuestro objeto. Lo que hacemos, establecemos nuestro nombre de campo local
al parámetro, así. Entonces establecemos la edad al parámetro también, así
como esto. Ahora que ya lo hemos hecho,
podemos usar esta palabra clave para diferenciar
esta instancia de nombre. Este es el parámetro de
esta instancia de nombre. Este es el campo privado. Lo que podemos hacer para que sea
más evidente es decir esto. Ahora bien, este nombre
se refiere a éste, porque esta es la
instancia actual de esta clase, se va a referir a
ésta. Lo mismo con la edad. Esto se refiere a la instancia
que es ésta de aquí. No obstante, el nombre aquí se refiere a éste porque no está
en la instancia actual. Se está pasando
como parámetro. Esto lo verás mucho a la hora de
configurar constructores, y simplemente diferencia
los nombres para que
no haya ambigüedad Es claramente obvio
lo que está pasando. La instancia actual aquí
es igual al parámetro. Verás esto bastante
en tus futuros empeños.
49. 9-12. Palabra clave base y constructores de clase: La palabra clave base en tienda. ¿Cuál es la palabra clave base? Ahora, usarías la
palabra clave base cuando intentas
acceder desde una
clase secundaria como perro. Aquí, esta es una clase hijo, queremos acceder a cualquier cosa
en la clase base, ahí la palabra clave base. Considérelo como un
atajo para acceder a métodos, propiedades y
cosas así. Aquí, por ejemplo, tengo aquí una clase de animales
base que tiene un par de
campos privados y algunos métodos. Por ejemplo, este método aquí, se llama método animal, es público y forma parte
de la clase animal. Lo que puedo hacer desde
el perro de clase infantil, puedo entrar aquí y
decir base y luego puedo acceder al método animal porque esta es una
clase infantil en este caso. La base es opcional, pero
puedes ver cómo funciona. Agrega un poco de claridad. Por ejemplo, lo que tengo aquí, tengo un método
llamado info que solo da salida a la pantalla alguna información sobre
este perro actual. Si voy por aquí, he creado un nuevo objeto aquí,
una instancia de perro. Le he dado un nombre, una edad y una raza. Y entonces sólo estoy
dando salida a la información aquí. Entonces cuando ejecutamos el programa, podemos ver alguna
información sobre el perro. Lo que verás mucho es solo agregar un poco
de claridad porque nombre y la edad están definidos en la clase base animal aquí. Para que puedas ver nombre, edad, agrega un poco de claridad. Si miras el código, puedes ver rápidamente, oh bien, estos son miembros de la clase de
padres para mirar ahí. No obstante, Breed es
miembro de esta clase, por lo que no tiene
la palabra clave base, Pero puedes ver con bastante facilidad
sabes a dónde pertenecen estos con solo
mirar esa palabra clave. Pero esa no es la
característica principal de la clase base. De lo que quiero
hablar ahora es si tienes un en la clase de padres,
por ejemplo, animal. Si configuro un constructor
en animal esto, se
puede ver que hay un pequeño
problema con eso. Si ahora trato de
ejecutar el programa, no me va a dejar, si voy a mi clase infantil, a ninguna de las clases infantiles, ha aparecido
este error. Esta pequeña línea roja. Si coloco el cursor sobre eso, aquí hay un mensaje de
error críptico Ahora, por defecto,
los constructores no son heredados porque en
realidad no son miembros de una clase Pero ahora he definido un
constructor en animal aquí. Ahora está teniendo un problema. Ni siquiera puedo compilar
mi software. Lo que vamos a
hacer aquí es definir un constructor en perro aquí. Manera cuando creo
mi objeto perro aquí, no
tengo que establecer
todas estas propiedades. Yo sólo puedo
ponerlos en parámetros aquí al crear
nuestra nueva instancia. Echemos un vistazo a
cómo podemos hacer eso. Cuando creamos un objeto perro, quiero especificar un nombre
que está en la clase padre, una edad que también está en la clase padre,
y también una raza. Quiero estos como
todos los parámetros y raza es parte de la
clase de perro, no de la clase base. Si voy aquí a la clase de
perros, la clase infantil, empiezo a
crear un constructor. Quiero tomar en nombre
del perro,
la edad del perro,
y también la raza. Se ve algo así. Ahora hay un atajo aquí. Lo que podemos hacer aquí es pasar nombre y edad a la clase base. Cómo lo hacemos es después
del constructor aquí, ponemos dos puntos y
ponemos la base de palabras clave. Después abre y cierra los
paréntesis aquí. Esto prácticamente llama al
constructor de la clase base. Nuestro constructor aquí
toma dos parámetros. Base en este caso
es un atajo para el constructor de
la clase padre. El constructor toma
dos argumentos. Si volvemos por aquí, toma en el nombre, toma en la edad. Ahora estamos tratando con
estos dos parámetros aquí. Están siendo arrojados a la clase base y se llama al
constructor. Entonces solo tenemos que
hacer algo con la raza, Nosotros lo pusimos aquí. Ahora podemos configurar nuestros parámetros aquí cuando estemos
creando la nueva instancia. Ahora no necesitamos nada de eso. Esencialmente, esto va a hacer exactamente lo mismo
si ejecuto el programa. Ahora se puede ver que da salida a
toda la información. Una vez más, ¿cómo
funciona eso? Estamos creando una nueva
instancia de la clase de perros. Estamos llamando al constructor de
perros, que toma en tres parámetros. Aquí está nuestro constructor de perros. Sí, sí toma en
tres parámetros. Una vez
que se llama al constructor, toma estos dos parámetros y los arroja
a la clase base. Arriba en la clase base, se
puede ver que hay
dos parámetros, Aquí está, llamando al
constructor con dos parámetros. Solo tenemos un constructor, Tiene dos parámetros
entonces esto se llama. Esto establece nuestras propiedades
aquí, nombre y edad, que posteriormente establecen
nuestros campos privados a través de getters y setters Una vez que el constructor
ha construido nuestro flujo de objetos animales vuelve a salir y luego se llama al resto del constructor de
perros. Lo que simplemente establece el campo
local aquí, raza para criar aquí. Así es esencialmente como
funciona en segundo plano. Es solo llamar al constructor
de clase base. Escribe aquí, tal vez te estés preguntando ¿por qué no podemos
simplemente eliminar eso? Y hago nombre base igual nombre y luego
la edad por ejemplo. No, no va a funcionar porque esta
terminología aquí arriba, la base de dos puntos
en realidad está llamando
al constructor de la clase
padre en sí. Entonces se requiere y entonces ese error se resolverá
por sí mismo sin eso. E incluso si pones
esas bases ahí, todavía
va a arrojar
este error aquí porque el constructor de la clase padre nunca
se construye. Así que en
realidad nunca crea este objeto animal porque
esta es la clase padre. El perro de clase infantil
depende de esto. Es por ello que aquí se requiere. Y ese es el poder de
la palabra clave base en tienda.
50. 9-13. Interfaces: Interfaces en tienda. Las interfaces son otra forma de
lograr abstracción en tienda. Hablamos un poco de clases
abstractas antes. La abstracción es un principio clave
orientado a objetos, que es solo el
proceso de ocultar los detalles internos y
mostrar solo la funcionalidad Echemos un
vistazo a las interfaces en la tienda como mini repaso. Me limitaré a referirme a
este proyecto donde
hicimos aquí una clase de
animales abstractos. Aquí está nuestra clase de
animales abstractos. Tenemos algunos campos privados y métodos
públicos aquí y también
algunas propiedades públicas. Tengo un método abstracto aquí, porque la clase perro aquí está heredando de la clase
abstracta animal, tiene
que anular
este método abstracto Se ve obligado a hacer eso. Y ese es el punto de las clases
abstractas
a través del polimorfismo Estamos anulando este
método, hacer ruido. Y solo estamos sacando guau, guau para
nuestra clase de perros Cuando creamos un nuevo
objeto perro y ejecutamos el método, hacemos ruido, solo
obtenemos guau, guau En principio, esa es la clase
abstracta ahí. Nos vemos obligados a anular
estos métodos abstractos. Aquí, echemos
un vistazo a cómo podemos crear una interfaz animal y ver
también cómo las interfaces difieren de
las clases abstractas también. Interfaces en tienda, bastante
similares a las clases abstractas. Lo que voy a hacer es crear una nueva interfaz en tienda. Entonces
te voy a mostrar algunas diferencias entre
clases abstractas e interfaces. Entonces nuestra clase de perro aquí
va a usar nuestra
nueva interfaz. Todo se
aclarará momentáneamente. Si pasamos por el
lado derecho aquí a nuestro proyecto, haga clic
derecho, vaya a Agregar,
y luego ir a clase. Del menú aquí
solo elegimos Interfaz. Ahora podemos darle a la interfaz el nombre
que queramos, pero quiero crear
una interfaz animal. hora de crear
interfaces, siempre es buena práctica usar un I
capital de antemano. Eso es porque cuando
agregas interfaces, o al menos tienes un proyecto
realmente grande con tal vez decenas o
cientos de interfaces, puedes
distinguirlas de las clases normales. Aquí tenemos animales y
puedes ver animales. Esta es claramente una interfaz, solo porque la hemos
llamado así. Es sólo una buena práctica. La diferencia entre una
interfaz como esta aquí y una clase, esta de aquí. Aquí está solo la diferencia
en la palabra clave, que es que tenemos una palabra clave de
clase para una clase y la
palabra clave de interfaz para una interfaz. Práctico cualquier otra cosa
aquí mismo es lo mismo. Esa es la única
diferencia sutil aquí. Ahora interfaces en C sharp, puedes considerarlas como prácticamente 100%
totalmente abstractas. ¿Qué significa eso?
Bueno, si has visto el tutorial de clase abstracta
como este de aquí, tenemos algunos
métodos abstractos aquí. Cuando tenemos un método abstracto, no
definimos un cuerpo para ello. Porque nuestras clases que
heredan esta clase abstracta, definen sus propios
métodos para ellas, como la clase de perro y la clase de
gato por ejemplo Proporcionan código. Cuando vamos a nuestra clase
abstracta, no tiene cuerpo por ejemplo. Sin embargo, una
clase abstracta puede definir sus propios métodos como
decir nombre, decir edad. También pueden hacer varias
otras cosas. Esto no es cierto
con las interfaces. Considera una interfaz como una clase puramente abstracta
donde no definas cuerpos. Hay una pequeña excepción para que esa regla tenga que ver con los miembros
privados, pero voy a discutir eso quizás más tarde o
en otro momento. Considera las interfaces como
una clase puramente abstracta. No estamos definiendo cuerpos en
interfaces para nuestros métodos. Si vengo a mi clase de
perro aquí mismo, que es heredar de
esta clase de animales abstractos, puedes ver que estoy anulando un método make noise y luego dándole mi
propia funcionalidad Quiero hacer el mismo tipo
de cosas en mi interfaz. En mi interfaz, quiero
definir un método
llamado make noise, que va a ser abstracto porque ese es el
propósito de la interfaz. Si defino un nuevo método llamado
make noise como dices, porque es abstracto,
no tengo un cuerpo aquí. Y por defecto esto es público. El modificador de acceso
es público por defecto. Y esto es solo por diseño de interfaces porque queremos que todos usen
estas interfaces. Así que así, hemos definido nuestro primer método
en nuestra interfaz. Muy sencillo, ¿no? Porque es público y
abstracto por defecto. No necesitamos ningún
modificador de acceso como público. Es opcional y no
necesitamos la palabra clave abstracta. Por ejemplo, así
es como definir un método abstracto público en
C Sharp para una interfaz. Ahora voy a mi clase de perros. Ahora mismo está heredando de esta clase abstracta y
estoy bien aquí Quiero implementar
la interfaz. Así que sólo voy a
poner un yo al frente. Así que ahora usa nuestra interfaz en lugar de nuestra clase abstracta. Ahora bien, ¿cómo podemos reescribir esto para que funcione con
nuestra interfaz aquí Bueno, cuando heredamos de una clase abstracta y
tenemos un método abstracto, tal como
hablamos antes, aquí
usamos la
palabra clave override Pero con las interfaces no
usamos la palabra clave override, no
es necesaria en absoluto. Esto es perfectamente suficiente. Por ejemplo, otra cosa. Si elegimos no definir un método para nuestra interfaz
y simplemente dejarlo así. Si pasamos el cursor sobre esto aquí, es decir perro no implementa el miembro de la
interfaz
hace ruido al
igual que las clases abstractas Nos está obligando a proporcionar
una implementación para ese método para que pueda
obligarnos a hacerlo. Cuando tienes grandes equipos
de personas por ejemplo, es bastante útil porque entonces todas tus clases están
algo estandarizadas. Y entonces todos anularán este método make noise aquí, tal como ya hablamos
antes en clases abstractas. Ahora tengo esta clase de perro aquí. Se trata de implementar el método make
noise que
definimos en nuestra interfaz
y a través del polimorfismo, está definiendo su
propia funcionalidad Si voy al programa
aquí donde creamos un nuevo objeto perro
y estamos llamando
al método make noise que está disponible
a través de la interfaz, vamos a obtener
exactamente el mismo resultado. Así que permítanme repasar algunas similitudes y
también algunas diferencias entre clases abstractas en C shop y también
interfaces también. Porque quizás en la superficie, logran algo
muy similar antes cuando intentamos crear una instancia de una clase
abstracta. No nos dejaría.
No es posible, y esto es a través del diseño. Incluso si intento
hacer lo mismo con una interfaz por ejemplo, no me va a dejar ni siquiera Visual Studio no está ofreciendo una
función de autocompletar para esto Cuando coloco el cursor sobre este nuevo intento de
instancia aquí, está diciendo que no puede
crear una instancia
del animal de interfaz de tipo abstracto Entonces no es posible. En una clase abstracta, podemos tener un constructor, pero solo es llamado
por las clases secundarias, no en ningún lugar fuera de esa cadena de herencia
con interfaces. No se puede tener un constructor
porque nunca
bajo ninguna circunstancia
construiría una interfaz. La interfaz simplemente
actúa como un contrato, por lo que cualquier cosa que implemente
la interfaz puede anular aquellos métodos
que están disponibles. No hay constructores en interfaces. Si queremos hacer eso, entonces
el propósito es que tenemos una clase y luego
implementamos una interfaz, o heredamos de una
clase abstracta y luego definimos nuestras propias anulaciones para
estos métodos abstractos Por ejemplo, esta es la
razón por la que no creamos nuevas instancias de
clases abstractas e interfaces, y por lo tanto no
necesitamos un constructor. Otra cosa que también
mencionamos fue el hecho que las clases abstractas pueden
tener campos aquí mismo, que no puedes tener
en una interfaz. Nuevamente, en los métodos aquí podemos definir cuerpos en clases
abstractas. Sin embargo, en las interfaces no
podemos porque es
puramente abstracto. Estas son algunas diferencias aquí. Puede que te estés haciendo
la siguiente pregunta. ¿Por qué debería incluso usar una interfaz cuando en
una clase abstracta, por ejemplo, puedo usar campos, puedo definir
cuerpos de método si quiero. ¿Por qué debería usar una interfaz? ¿Cuál es el punto?
Parece más limitado, sí. Tal vez sea 100% abstracto, por ejemplo, pero ¿por qué
debería usar uno? Bueno, las interfaces
soportan la idea de herencia
múltiple en
C Sharp por ejemplo. Si tengo una
interfaz animal como animal, puedo crear una interfaz llamada tal vez carnívoro
por Entonces nuestra clase de perros
en realidad puede implementar desde animal e iconivorre o tal vez
algo más Entonces puede implementar desde
múltiples clases aquí arriba, múltiples interfaces, y no se puede hacer eso
con clases abstractas. Por lo que esta es una de
las principales fortalezas de las interfaces en C Sharp. Entonces echemos un vistazo a
un ejemplo ahora mismo. Si vengo por aquí, voy a hacer clic derecho en el proyecto, ir a Añadir interfaz de clase. Sólo voy a
crear iconivorre porque los perros son carnívoros También es un animal. A lo mejor hay una mejor
manera de representar esto, pero vamos a
repasar por este ejemplo. Para que puedas ver el
punto de esto. En carnívoro, sólo voy
a definir un método llamado tal vez comer carne porque
todos los carnívoros comen carne Así como así. Nuevamente, es abstracto y público por defecto. Eso es todo lo que necesitamos en este caso. Ahora bien, si quiero
heredar o implementar desde
múltiples interfaces, separo la clase de
los dos puntos, igual que antes Y luego poner en la clase o interfaz que quiero
implementar o heredar de Pero si quiero heredar
de múltiples interfaces, solo
pongo una coma aquí Entonces puedo poner el siguiente iconivor de
interfaz, por ejemplo. Ahora se puede ver que hay una línea
roja porque no implementa a nuestro nuevo miembro
comer carne, lo cual es cierto. No hemos definido un
método para hacer eso. Si voy a aquí y
escribo comer carne, ahora estoy implementando ese
método aquí desde iconivor Estoy implementando este
método desde animal ahora. Todos están contentos, no
hay líneas rojas, todo satisfecho. Entonces puedo poner mi
propia definición, algo así como comer carne. Entonces si vengo a
mi aplicación aquí, solo
escribo comer
carne por ejemplo. Ahora bien, este es el
método que estamos implementando desde nuestro
nuevo icono de interfaz. O comer carne. Oh, vamos a deshacernos de eso porque no podemos crear una nueva instancia
de una interfaz. Ahora estoy creando
un nuevo objeto perro y ahora estoy comiendo algo de carne. Y eso es miembro
de nuestra nueva interfaz. Puedes ver aquí, este es un ejemplo muy rápido de
herencia múltiple en C Sharp. Y se logra mediante el
uso de interfaces, que es algo que no se puede
hacer con clases abstractas. Estos son los beneficios de ambos. Se puede ver que mediante el
uso de interfaces en C Sharp y también clases
abstractas, podemos lograr la abstracción, que es un principio de
programación orientado a objetos clave. Ahora probando tus conocimientos
de herencia o tal vez solo consultando que entiendas
completamente este tema Por ejemplo, si voy a
mi aplicación principal aquí, puedo crear un nuevo método aquí. Por ejemplo, voy
a llamarlo hacer ruido. No va a
devolver un valor, solo
va a
hacer algo de ruido sobre nuestros animales a la ventana de la
consola. Y va a
tomar un parámetro aquí porque perro implementa nuestra interfaz animal porque sabemos a través de hablar herencia antes que un perro
satisfaciente es una relación, un perro es un animal De igual manera, nuestra clase de gatos. Un gato es un animal, un hámster es un animal. Entonces podemos simplemente ir hasta
aquí y tomar en animal como parámetro porque nuestro perro implementa esta interfaz aquí. Entonces podemos hacer las cosas desde aquí. Podemos decir hacer ruido. Lo que podemos hacer aquí,
podemos crear un objeto perro. Entonces podemos pasar a nuestro perro a este método aquí mismo
llamado make noise. Entonces, porque el
perro es un animal, entonces esto va
a funcionar, no hay problema. va a llamar
al método make noise Aquí va a llamar
al método make noise
en el objeto, que es un animal. Es un animal. Si creo un objeto gato, puedo usar este mismo método porque gato
implementaría animal. En este caso, podría crear una clase Delfín
siempre y cuando implemente animal. Nuevamente, puedo llamar a este
método, no hay problema. Se puede ver que este es el
poder de la herencia, pero también usando cosas
como interfaces. Esto también funciona con clases
abstractas también, igual que antes, no hay problema. Siempre y cuando mi clase de perro herede de la clase
abstracta animal Ya puedes ver si
ejecuto este programa, ya puedes ver que ahora está
diciendo guau, guau De igual manera, si tengo una
clase de gato como esta de aquí, implementa desde animal el
método make noise y anula su propio tipo de lógica
aquí, que es O. Luego voy al programa, creo un nuevo objeto gato, entonces quiero hacer
ruido con el gato Y mientras esté
implementando nuestra interfaz, entonces va a
funcionar, no hay problema. Se puede ver el
poder de la herencia y por qué utilizamos interfaces. Solo tenemos que
pasar la interfaz alrededor del software, por
ejemplo, como un parámetro de método o
incluso un retorno de un método, o prácticamente cualquier cosa. Nuevamente, si ejecuto el programa, se
puede ver a través del
polimorfismo, estamos anulando el método make
noise para perro y gato, pero también usando interfaces para pasar ese objeto
alrededor puede ver que es bastante potente y las posibilidades también
son infinitas. Puedes ver aquí si cambio esta interfaz a nuestra clase
abstracta aquí, ve a clase y
asegúrate de que implemente
la clase abstracta. Con clases abstractas, usamos la
palabra clave override porque esa es la diferencia entre
esas e interfaces. Reflejamos eso también
en la clase de perros. Y luego volver a
nuestro programa principal aquí. Después ejecuta el programa. Se puede ver que hemos pasado alrededor una clase abstracta y
funciona exactamente
igual que una interfaz. Pero hay diferencias
sutiles, como hemos discutido anteriormente, entre las interfaces
y las clases abstractas. Pero este es un
ejemplo tanto de cómo se comparan como de
las ventajas de usar interfaces para satisfacer herencia
múltiple en C Sharp. Espero que este tutorial te haya ayudado, y gracias por verlo.
51. 9-14. Resumen de O-O: Así que acabamos de completar
bastantes tutoriales sobre
programación orientada a objetos Ahora hemos pasado
por casi todos los principios del paradigma de
programación. Y ahora solo
vamos a dar un círculo
completo y reflexionar
sobre lo que hemos aprendido, y dejar caer algunas palabras clave
y cosas así. Entonces nuevamente, como mencioné
al inicio de nuestro viaje 00, C sharp es un lenguaje de
programación orientado a objetos. Y usar 00 realmente te ayudará a
estructurar tus proyectos. Cuando
tus proyectos sean muy grandes, van a ser
mucho más fáciles de mantener. Vas a
practicar mucha reutilización de código
quizás en el futuro. Si continúas este viaje, vas a trabajar
con otras personas. Quizás en una empresa
que también entienda programación. Todos
van a conocer y ya entender las mismas técnicas
para escribir software. Así que vas a empezar
corriendo muy rápido. Así que vamos a repasar de nuevo algo de la terminología solo
para que entiendas completamente. Y luego vamos a pasar
a algo un poco diferente. Programación orientada a objetos. Nuevamente, es un paradigma, que es una forma de
hacer algo. Hablamos de clases. Ahora clases modelan objetos del mundo
real. Entonces, si tienes una pieza de
software sobre una biblioteca, entonces una clase podría ser un libro. Debido a que un libro es un objeto del mundo
real, su clase de libro debe
ser altamente cohesiva Eso significa que la clase
sobre el libro solo
debe ser sobre el libro. No debería tratarse de que el
usuario lea el libro. Entonces cuando tienes una
clase de libro, todos los métodos, todas las propiedades
siempre deben ser sobre el libro. Esta es muy buena práctica y tus clases deben
estar vagamente acopladas Eso significa que tu clase de libro
debe ser sobre el libro. Tu clase de usuario debe
ser sobre el usuario. Y en
realidad no deberían tener mucho en común entre sí objetos. Ahora objetos está creando una
nueva instancia de una clase. Una clase es como
la plantilla con todos los
métodos y propiedades. Y cuando queremos crear
una nueva instancia de eso, puedes tener uno o
miles si quieres. A eso se le llama
crear un objeto. Entonces un objeto es solo una
instancia de una clase, y cuando creas una instancia, se llama instanciación Ahora, la herencia,
la herencia promueve la reutilización del código, y cuando reutilizas el código, lo hace más fácil de mantener No tenemos que copiar código y ponerlo en cada clase, porque si tenemos
una clase como perro, entonces puede heredar del animal Si tenemos una clase llamada gato, nuevamente puede heredar
del animal Y muchas de estas clases
tendrán las mismas características. Entonces vas a usar y
escribir mucho menos código. Y cuando escribes
mucho menos código, eso significa que tu código
será mucho más mantenible, mucho más fácil de administrar No sólo eso, el tamaño
del archivo del software será mínimo. Y también probando el
software también, puedes tener mucho
menos código para probar. Así que la herencia en es un muy buen
principio para practicar. Hablamos del polimorfismo, esa rara palabra griega que significa muchas formas o muchas formas, lo que logramos con sobrecargar el
método hora de hablar de métodos, cómo podemos tener
diferentes parámetros pero con el mismo nombre de método. Pero también más recientemente
hablamos de polimorfismo con método anulando En una clase
base como animal, podemos decir hacer ruido Entonces cuando heredamos
de esa clase, en una clase de perro, gato, hámster, podemos anular ese método y proporcionar
nuestra propia funcionalidad Podemos ver el resultado de eso cuando ejecutamos
la aplicación, como al usar el, el perro ladrará al usar
el método make noise. Al usar la clase de gato, el gato maullará Podemos reutilizar este mismo método pero aportando diferentes
funcionalidades. Eso es polimorfismo. Los dos últimos. Ahora las dos últimas personas se
confunden entre las dos porque son muy similares
y sí van de la mano. Y eso es
abstracción de encapsulación . Ahora,
la encapsulación oculta la funcionalidad interna
de un objeto Sólo permite el acceso a través de
un conjunto público de funciones. Por ejemplo, cuando
hablamos modificadores de
acceso
públicos y privados, porque queremos ocultar
nuestra información sensible, como nuestros
campos privados, por ejemplo Pero solo accedemos a ellos a través de métodos
públicos para que así podamos verificar los datos y asegurarnos de que la gente no esté
rompiendo cosas. Cosas así por ejemplo. Y también propiedades de tiendas de mar. Cuando se habla de abstracción, significa mostrar solo información
esencial y ocultar los detalles esenciales y
arenosos Y lo hicimos a través de clases
abstractas y también interfaces. Así que imagina como una cafetera, si quieres preparar un café, presionas el botón de preparación del
café. Si quieres arrancar un
auto, giras la llave. No necesitas
saber cómo funciona un motor de arranque en un automóvil, o un alternador
o carga de batería. Como usuario, como desarrollador, solo
necesitas girar la
llave para que el auto funcione. Similar con una
cafetera, elaboras un café, no
necesitas saber
cómo funciona la electrónica, cómo se calienta el agua. Todo eso se
abstrae lejos de ti, es
información innecesaria Si solo eres un
usuario final de estas cosas, como una cafetera o
el conductor de un auto, simplemente no
necesitas saber esto. Y eso es abstracción. Y vemos esto
en la vida cotidiana, todos los días, varias veces al día. Y esa es la
diferencia entre encapsulación y abstracción Nuevamente, ambos términos clave de programación
orientados a objetos, pero sí van
de la mano mucho. Y a veces, a menudo puede
parecer que hay una línea un poco borrosa entre la línea un poco borrosa entre encampulación y la
abstracción Así que enhorabuena, hemos
repasado todos los principios de la programación
orientada a objetos Y si eliges tomar otro idioma como
C plus Plus o Java, puedes llevar estos
principios
y comenzar a funcionar
casi de inmediato. No está atado a C.
Sharp es algo muy popular y también se usa en
muchos lenguajes de programación.
52. 10-1. EJERCICIO - Dibujo de pirámides: Hoy vamos a estar dibujando pirámides y las vamos a estar dibujando en nuestro tipo de aplicación de
consola Y vamos a
dejar que el usuario decida
qué tan grande quiere que sea
su pirámide. Por ejemplo, si el
usuario escribe en 45, entonces aquí se va
a generar una pirámide. Y va a
ser 45 líneas de alto, como puedes ver aquí mismo. Se ve bastante
genial, ¿no? No obstante, si el usuario
ingresa el número cinco, por ejemplo, entonces su pirámide sólo
va a tener
cinco líneas de alto. Esto es un poco de ejercicio. No solo va a poner a prueba tus habilidades de programación C sharp, sino que también va a
poner a prueba tu habilidad lógica. Cómo se puede ver un problema
y desarrollar una solución
dividiéndolo en pequeños subgrupos y luego
atacando el problema Entonces voy a resolver este problema y voy
a mostrarte cómo
abordaría esta tarea para
que veas cómo funciona
mi mente y cómo abordo
este problema en particular. Es bastante común ver ejercicios
como este
a la hora de realizar
una entrevista de trabajo. Por ejemplo, el entrevistador podría preguntarte cómo desarrollas un poco de
software para generar una forma o una pirámide o
algo así Porque cualquiera puede buscar sintaxis y código en internet. Pero lo que a muchos
empleadores les gusta hacer estos días es probar cómo funciona
tu mente, como el pensamiento
lógico. ver si se le puede
llegar a una solución en el acto y también
tal vez bajo presión. Entonces voy a desarrollar una solución para esto y
voy a mostrarte cómo pienso esto paso a
paso para que
veas cómo funciona mi mente y
cómo abordo este problema. Vamos a ponernos en marcha. El primer paso es analizar el problema. Cuando el usuario ingresa un número, esto denota la
altura de la pirámide. No sólo la altura
de la pirámide, sino el número de
líneas que se dibujan. Se puede ver que aquí hay
cinco líneas. La pirámide termina cuando
hay un símbolo de una libra, y la base de la pirámide
cubre toda la línea aquí Pero puedes ver aquí, es
la altura de la pirámide, que se denota con este número La pirámide tiene cinco líneas de alto, eso es una cosa a tener en cuenta. Lo segundo a tener en cuenta es que todas estas plazas
están pobladas. Si no están poblados
por hashes aquí, el símbolo de la libra
que representa la pirámide Después están poblados
por el fondo, que se denotan con guiones Aquí se puede ver que la parte superior de la pirámide tiene el símbolo de
una libra, y luego en ambos lados
tiene cuatro guiones La siguiente línea, se puede ver la pirámide aumenta
en dos en lugar de uno. Aquí son ahora tres, y luego hay un
guión menos a cada lado Nuevamente, debajo de la pirámide
crece dos por línea, y luego el guión se
encoge en uno Aquí tenemos un par de reglas. Cada nueva línea, la
pirámide crece en dos. Y cada nueva línea, el guión, se encoge
por uno a cada lado Una última cosa a tener en
cuenta es que en este ejemplo donde tengo
una altura piramidal de cinco, tenemos nueve caracteres
a lo largo del ancho aquí, cinco abajo y nueve de ancho. Tenemos muchos
datos con los que trabajar. Veamos cómo podemos desarrollar
una solución para este ejemplo. Si has seguido nuestros
tutoriales anteriormente, es posible que hayas visto el ejemplo que hicimos cuando dibujamos un
cubo en la pantalla. Ahora bien, este ejercicio es
un poco diferente, es un poco más complejo, pero los principios y procedimientos detrás de
escena son bastante similares. En ese ejemplo,
usamos algunos bucles, usamos cuatro bucles. Este ejemplo
no debería ser diferente Cuando vemos repetir datos como este
y así en nuestra cabeza, deberíamos estar pensando, bien, un bucle debe estar involucrado. Algo debe estar dando
vueltas e iterando para generar
estos guiones Entonces necesitamos otro bucle para luego generar
estos símbolos de libra. Y entonces tal vez un tercer bucle aquí para continuar
con los guiones Hay algunas formas en las que
podemos abordar este problema. A lo mejor podríamos tener
un bucle donde simplemente
cambiemos el carácter
por la parte piramidal. Sí, eso también puede funcionar. A la hora de desarrollar
soluciones como esta. Hay bastantes
soluciones al problema, pero la elección es suya. Cuando tomas esa decisión, quieres hacer la más fácil eficiente en el tiempo. Pero también genera el código
que sea más mantenible,
más mantenible por
ti mismo en el futuro, pero más mantenible
por cualquier compañero de equipo que realmente tome tu código
y lo desarrolle en el Hay muchas cosas en
las que pensar. Creo que la forma en que abordaría este problema es tener un bucle principal
bajando por el eje y. Tenemos un bucle principal que
genera cada línea a su vez. Entonces dentro de ese bucle, tendré un bucle que
genere estos guiones Un segundo bucle que genera la
parte piramidal, que es ésta. Y luego un tercer bucle que
continúa con estos guiones, un bucle principal que
hace el eje y Entonces dentro de ese bucle, creo que tres bucles separados. Esa es una solución perfecta para
abordar este problema. Echemos un
vistazo a eso ahora y veamos si podemos desarrollar
algo así. Entonces aquí está el código que
tenemos hasta ahora, realidad no está haciendo
nada en absoluto, es solo dar salida a algunos
mensajes al usuario,
darle la bienvenida al software Gracias por usar la aplicación. Esto es lo que hace. Y luego le
estamos haciendo la pregunta al
usuario. Estamos tomando la entrada del usuario, convirtiéndola en un entero y almacenándola en
una variable entera. Ahora lo que quiero hacer,
voy a crear un método. Porque cuando creo un método, puedo llamarlo varias
veces desde múltiples lugares, y luego puedo generar
pirámides desde donde quiera Creo que toda la lógica para
generar la pirámide
del tamaño personalizado aquí
debería pertenecer en un método. Y luego es fácilmente
reutilizable por cualquier otra cosa. Voy a crear
una plantilla de método. Ahora el método no tendrá un tipo de retorno
porque solo
quiero que el método
dibuje la pirámide. Se va a crear
un parámetro y ese solo va a ser
el tamaño de la pirámide. Ahí está nuestro método básico. Lo primero que
dije que iba
a hacer era generar un bucle, que imprimiría
cada línea a su vez, y eso
bajaría por el eje y. Voy a crear
un bucle para hacer eso. Entonces este bucle aquí representa
la altura del lienzo. Entonces la altura de la
pirámide en este caso, debido a que la pirámide
toca la parte superior del lienzo
sobre
el que estamos dibujando y también la parte inferior, es seguro decir
que cualquiera que sea
el número que el usuario dé la
altura completa de la pirámide, no
tenemos fondo por encima la pirámide y ningún fondo
debajo de la pirámide. Hacer el eje y a partir de uno
menor o igual al
tamaño de la pirámide e incrementar en uno
asegurará que dibujemos la pirámide a lo largo del eje
y bajando Ahora dentro de este bucle, mencioné que una
posible solución era tener tres bucles
separados. El primero en dibujar los
guiones del lado izquierdo, el segundo para
dibujar la pirámide, y el tercero para
continuar con los guiones del lado derecho Déjame configurar esos bucles ahora sin
pensar realmente en escribir código. Por ejemplo, ya
tengo esta linda plantilla. Acabo de generar
esta plantilla a partir de solo
pensar lógicamente en el problema Necesito algún bucle para
dibujar hacia abajo para el
tamaño de la pirámide. Entonces dentro de cada línea, necesito algo que genere la pirámide y el fondo
en cada línea separada. Ya, tengo una pequeña plantilla
agradable aquí sin
pensar demasiado en el problema. Cuando dibujamos los
guiones de la izquierda, lo único que queremos hacer es sacar un guión a Hagámoslo ahora.
De igual manera, cuando dibujamos los guiones
de la derecha, vamos a dibujar un guión De igual manera, cuando
dibujamos la pirámide, necesitamos el símbolo de la libra. Más o menos
lo único que tenemos que hacer ahora es trabajar cuando
estos bucles terminen. Cuando miramos el
ejemplo antes y el usuario ingresó el número
cinco por ejemplo, entonces la pirámide tenía
un ancho de nueve, pero una altura de cinco. La primera línea de la
pirámide tenía el símbolo de una libra, pero tenía cuatro
guiones a cada lado Tenemos que averiguar cuándo
dejar de dibujar guiones. Para calcular cuándo dejar dibujar guiones en
el lado izquierdo, necesitamos calcular cuándo
terminar este bucle de proa De igual manera, qué ancho
debemos dibujar la pirámide en cada lado y también cuándo
dejar de dibujar guiones en
el lado derecho Y al desarrollar
software como este, algunos días tendrás la
máxima claridad. Esto será fácil para ti, solo
tienes que escribir los valores. Sabes, estás
teniendo un buen día. Pero a veces si solo estoy cansado o no estoy en
la mentalidad correcta o tal vez eres un
principiante y sabes que estás trabajando
en ello en tu cabeza Bueno, entonces no es una pena
usar algo como celda
Microsoftic o un bloc de
notas solo para trazar todas tus figuras para que entonces
puedas usar tu espacio
cerebral sobrante para una solución para el problema o tal vez
cualquier otra cosa Entonces no hay vergüenza haciendo nodos ni nada por el estilo,
es perfectamente normal. Permítanme abrir Excel y trazar aquí
algunas de estas cifras. He abierto Microsoftic Cell aquí y he mapeado
la solución Bueno, solución inesperada. En fin, si el usuario ingresa
el número cinco por ejemplo, entonces sabemos que nuestra pirámide
va a tener cinco unidades de altura. Cuando el usuario ingresa cinco, va a generar una pirámide que se ve simplemente
algo así. La solución que hemos
desarrollado hasta ahora. Tengo un bucle que
imprime cada línea a su vez. Ese es nuestro bucle principal. Denotamos eso con y. puede ver aquí lo
acabo de llamar la variable y, y es igual a uno Y va todo el camino hasta
el tamaño de la pirámide. Menos o igual a
lo que voy a hacer. Voy a poner la
variable y aquí mismo. Lo siguiente dentro de este bucle, tengo tres bucles. Uno generará este contenido, el siguiente bucle
generará este contenido, y el tercer bucle
generará este contenido. También voy a
poner eso por aquí. Este va a ser el
primer conjunto de guiones uno. Esta será la pirámide, Y este es el segundo
conjunto de guiones Ahora cuando y es uno, esta es la primera
vez que nuestro loop loop se repite. Queremos generar cuatro
guiones a la izquierda, queremos generar un
carácter para la pirámide,
y también cuatro guiones a la derecha cuando Ahora nuestro bucle se repite
por segunda vez estamos
generando esta línea. Nuestro primer bucle
generará tres guiones. Nuestro segundo bucle
generará tres segmentos
para la pirámide. Nuevamente, los guiones van
a ser los mismos a la derecha, luego tres y luego
la tercera línea Se puede ver a dónde va
esto dos, la pirámide será cinco
y los guiones dos, luego la línea número cuatro
y la línea número Yo sólo voy a llenar. Ahora puedes ver
aquí algunas cifras sobre cuántos caracteres se
imprimirán para cada
iteración del bucle Ahora usando esto, puedes
averiguar lo que necesitas hacer. Tienes más claridad
en tu cabeza. No hace falta que
recuerdes estos números. Puedes denotar tu poder cerebral para pensar en una
solución al problema Veamos generar una
solución a este problema. Cuando el usuario
ingresa el número cinco, entonces cinco es del
tamaño de nuestra pirámide. Nuestro tamaño variable, que
entra en nuestro método, será cinco la primera
vez que se ejecute el bucle. Recuerda y es nuestro bucle. La primera vez que se ejecuta el bucle, y es igual a uno. Podemos ver que cuando y es uno, el número de guiones
en cada lado aquí es uno menos que el
tamaño de la pirámide La segunda vez que se ejecuta el bucle, puede ver que los guiones de
cada lado son dos menos que
el tamaño de la pirámide Puedes ver un poco
de regla aquí. Se puede ver que
cuando el tamaño es cinco y restamos
uno del tamaño, obtenemos el número de
guiones en Cuando Y es 25, quitar dos es 35, quitar tres es dos. Se puede ver para
generar el número de guiones en cada lado, tomamos el tamaño
de la pirámide en este ejemplo es cinco y
restamos y Eso nos dará el número
de guiones a cada lado. Veamos la generación de
esos bucles de guión. Estos son los dos
bucles que generan los guiones a la izquierda
aquí y también a la derecha Dijimos que el
número de guiones para cada línea es el
tamaño total de la pirámide Y restamos y de eso. Nosotros solo decimos tamaño menos Y. Para agregar claridad, ponemos
corchetes por ahí, luego agrega más legibilidad.
Tengo bastante confianza. Ahora para cada línea, estamos emitiendo el número
correcto de guiones a la izquierda
y también a la derecha Lo que suelen
hacer muchos desarrolladores es ejecutar la aplicación temprano. Hay un par de
razones para hacer eso. Uno, puedes ver si tu
último cambio fue correcto. Y dos, solo puedes mirar el estado actual
de la aplicación. En todo caso, te
da un poco más disfrute ver lo
que ya has hecho. Echemos un vistazo. Ahora, en realidad estamos llamando al método, ahora estamos tomando
el número del usuario. Estamos llamando al método, y luego este método
se está ejecutando. Echemos un vistazo a
los resultados hasta el momento. Si escribo el número cinco, ahora se puede ver que todo está en una línea. Entonces, ¿por qué es eso? Eso es porque después
de todos estos tres bucles, en realidad no
estamos
dando salida a una nueva línea Aquí también hay un poco de
problema. Cada vez que
sacamos un personaje, estamos generando una
nueva línea dos Eso también es un error. Cada vez
que
sacamos un carácter, no queremos
escribir una nueva línea, solo
queremos escribir
ese carácter. Así que usamos la consola para hacer eso cuando realmente
queremos una nueva línea. Bueno entonces vamos a hacer eso después de todos estos bucles. Echemos un
vistazo
ahora a la aplicación y veamos cómo se ve. Así que ya puedes ver que tenemos
un poco de forma de rumbus. Se ve bastante interesante, pero se puede ver que el
número de guiones es correcto Empezamos con 43210. Ahora tenemos que arreglar
aquí
esta sección media , que es la pirámide. Echemos un
vistazo a cómo hacer eso. Voy a volver a
Excel, estoy de vuelta en Excel. Ahora lo que quiero hacer
es averiguar cómo generar estos números utilizando
nuestra información disponible. Tenemos el tamaño de la pirámide y también tenemos el valor de y
En cada iteración del bucle, ya
hemos hecho las
cantidades de guiones para cada línea. En cada iteración del bucle, ya
hemos hecho las
cantidades de guiones para cada línea Parece bastante sencillo de hacer, pero ¿cómo generamos
este número usando la información
que tenemos en la línea uno? Aquí, la pirámide
es de un carácter, se
puede ver ahí en la línea
dos, la pirámide es tres. Se puede ver en cada nueva línea, la pirámide aumenta
en dos símbolos de libra, 13579, aquí son todos números
impares ¿Cómo podemos generar
estos números usando la información
que tenemos aquí? Para aquellos de ustedes que
son buenos en matemáticas, probablemente
sea bastante
fácil para ustedes, pero a veces los desarrolladores no son realmente buenos en
matemáticas en estos días. A lo mejor en los años 70 y 80 donde todos los matemáticos
y médicos hacían un poco de programación, era bastante obvio, pero en estos
días es programación informática Es un poco de una habilidad separada, A veces no se traduce
directamente a las matemáticas. Pero si notas aquí
con este valor y aquí, tomemos el número tres. Por ejemplo, si multiplicamos
tres por dos, obtenemos seis. Y luego restamos
uno de eso, luego obtenemos el valor cinco Otra vez, quizá cuatro. Por ejemplo, cuatro por dos es ocho. Restar uno es 75
veces dos es diez, restar uno es nueve Y creo que esa es
una regla que podría funcionar
en todo el campo, pero siempre debemos probar
con 1.0 en casos como este. Uno por dos es 21 es uno. Sí, eso parece funcionar también. Creo que esa podría ser
una regla que funcione. Lo que podemos decir es que p es igual a y multiplicado por
dos, quitarle uno. Esa es una regla que debería
funcionar para generar la pirámide a partir
del propio número de línea. Podría haber muchas más
soluciones a este problema, pero sin duda esta es
una que funcionaría para nosotros basándonos en y aquí mismo. Volviendo a nuestro software, aquí tenemos el valor de y en cada iteración del bucle Lo que hacemos aquí, queremos
generar la pirámide en cada línea cuando y es
tres, por ejemplo. Entonces queremos generar
cinco de estos símbolos de libra. Aquí dijimos que es Y multiplicar por dos y luego
restar uno de eso Se vería
algo así. Creo que esto funcionaría, pero para agregar un poco de claridad, siempre uso
corchetes adicionales como este. Simplemente lo hace más legible para que podamos ver lo que está pasando. Pero obtendrías
exactamente el mismo resultado usando esto debido a la masa de la oferta, porque la multiplicación
viene antes de la resta Pero en casos como este, siempre lo
escribiría así. Por ejemplo, echemos
un vistazo al ejemplo ahora
y veamos qué está pasando. Si sacamos el número cinco, ingresamos el número cinco,
se puede ver ahora obtenemos
una bonita pirámide. Eso es genial, ¿no? ¿Esto funciona para números
más grandes? Digamos 35. Eso se ve bastante bien. Sí,
parece que está funcionando. Se puede ver así es como me
acercaría a un problema en
algo como esto. Nosotros prácticamente escribimos 90% del código con solo
analizar el problema. No necesitábamos
pensar realmente en C sharp y en la programación. Literalmente solo
miramos la pirámide, diseccionamos un poco el problema y lo dividimos
en trozos más pequeños Lo único que
fue difícil fue averiguar los límites
para estos cuatro bucles Entonces, cuántos guiones
debemos dibujar, cuánto de la pirámide
debemos dibujar en cada línea,
y nuevamente, los
guiones de la Y también una pequeña complicación sobre nuevas líneas y
cosas así, lo cual es algo normal. A veces todo el mundo
comete errores, es normal. Pero puedes ver cómo
aislamos estos problemas y usamos Microsoft Excel
para ejecutar las cifras, así que realmente no tuvimos que tener toda esta información
en nuestra cabeza. Podemos simplemente
tomar el problema aquí, diseccionarlo todo hacia abajo,
ejecutar todas las cifras, entonces solo tenemos que
averiguar cómo obtener
estas cifras a partir de la
información que tenemos, ya sea la altura
de la pirámide o el valor de y en cada
iteración del bucle Para que veas cómo rompimos el problema sin pensarlo
realmente. Realmente no usamos
ningún poder cerebral. Todo en nuestra
mente fue arrojado a Excel y podemos encontrar una solución
a partir de eso. Entonces así es como abordaría
una situación como esta. Sobre todo si estaba muy cansada o resaca
y no podía pensar, entonces, ya sabes, deja que las
herramientas hagan el trabajo por ti. Así que volviendo
al estudio visual ahora estamos dibujando pirámides
bastante geniales Incluso podemos reemplazar
el fondo con un bonito espacio en blanco vacío. Y tal vez podamos
dibujar dos pirámides. O sea, lo ponemos en un método, así que ahora podemos repetir el
método mucho más fácil. Y ese es el poder de los métodos. Entonces si ahora pongo
el número cinco, por
ejemplo, ahora estamos generando tres pirámides una
encima de la otra Eso es genial, ¿no? Entonces de todos modos, así es como me acercaría a un
problema como este. Nuevamente, es algo común que
puedes encontrar en las entrevistas de trabajo. Pero realmente el poder de un programador es
poner a prueba el pensamiento lógico. ¿Cómo funciona tu mente? Un buen programador
no es alguien que pueda recordar sintaxis y
regurgitar información Un buen programador es alguien
que puede pensar lógicamente, romper un problema y encontrar una solución adecuada Eso es lo que es un buen
programador. Entonces espero que
este ejercicio le haya resultado útil, y gracias por verlo.
53. 10-2. Soluciones, proyectos múltiples y espacios de nombres: En este tutorial voy
a estar mostrándote cómo configurar múltiples proyectos
en visual studio. Hablaré un poco sobre la
terminología como soluciones,
proyectos, montajes,
y también nombres de espacios. También puedo mostrarte cómo acceder a archivos de diferentes
ensamblajes. Esto va a ser muy
útil para avanzar. Si abrimos visual studio, podemos conseguir este diálogo aquí donde podemos crear
un proyecto completamente nuevo. Aquí, vamos a hacer click en esto, luego solo vamos a
crear una aplicación de consola. Si hago clic en siguiente aquí, me
va a pedir
el nombre de mi proyecto. Ahora porque aquí elegí una aplicación de
consola, esto es lo que representa como
una interfaz gráfica de usuario, algo que el usuario podría ver. Del mismo modo, podrías tener una aplicación de
Windows Forms, que también es una Gooey Pero esta es la
interfaz gráfica de usuario de proyectos
porque tiene una ventana que podemos
ver al nombrar este proyecto Por ejemplo, es bastante común en las aplicaciones
tener lo que se llama una
arquitectura de tres capas donde se tiene un proyecto que representa
la interfaz. mejor en un sitio web que podría tener aplicación de consola HTML, lo mejor en un sitio web que podría
tener aplicación de consola HTML, tendría como
la ventana negra y cualquier lógica que ver con eso. Y entonces tienes
una capa media, a veces llamada
la capa de negocios, y que tiene todos los cálculos de
fondo, toda la lógica, todo ver con los cerebros
de la aplicación. Y quizás la tercera
capa será como una base de datos donde se refieren todas las cosas de
datos. La capacidad de obtener
datos de una base de datos. Ya sabes, tal vez esté emparejado con una base de datos oracle
o una base de datos SQL. Entonces todas las cosas que hacer
con la capa de datos. Esto es lo que comúnmente se conoce como una arquitectura de tres
capas. Cuando creas este proyecto en C sharp aquí en Visual Studio, primero estamos creando
al tipo aquí. Y esta es la
aplicación de consola en este ejemplo. Entonces voy a
llamarlo así. Normalmente lo que hago y lo que
hacen otras compañías de software es cuando creas al chico, podrías poner chico a
nombre del proyecto. Si el proyecto se llamaba app de
prueba por ejemplo, es posible que veas
algo como esto, como test app guy. O poner a prueba a un tipo. O tal vez chico prueba Ap,
algo así. Por el nombre que sabes al instante que estás
tratando con el chico, la interfaz gráfica de usuario. Entonces sólo voy a hacer
prueba Apoe, por ejemplo. No tienes que
hacerlo así,
pero esto es una buena práctica y también
es bastante común. Si continúas con
tus esfuerzos, verás esto bastante Ahora voy a crear
el proyecto. Aquí tenemos a nuestro chico. Realmente no hace mucho. Es solo una ventana negra que se
va a cerrar instantáneamente. Pero este proyecto aquí, si venimos a la derecha, este proyecto aquí representa
cualquier cosa que tenga que ver con nuestro tipo. Cualquier cosa gráfica que
el usuario pueda ver, cualquier cosa que tenga que ver con el chico, todo eso está
contenido dentro de aquí. Se puede ver en la parte superior
aquí, tenemos una solución. Ahora, la solución puede contener
una serie de proyectos, tal vez 102030, y podemos agregar
diferentes proyectos aquí Entonces, por ejemplo, vamos a
crear una capa de negocio. Y esto tendrá todo el código, toda la lógica, todos los
cálculos, por ejemplo. Nuevamente, al crear una solución, si es solo un proyecto de prueba
pequeño, por ejemplo, muy pequeño, tal vez solo estés
haciendo un simulacro rápido, entonces tener una arquitectura de tres
capas es bastante ambicioso. Puede que no sea necesario, pero si sabes de antemano va a ser un proyecto grande o algo que podría hablar con una base de datos o tener
mucha complejidad. Entonces sí necesitas considerar
tu arquitectura antes comenzar esto
crea otro proyecto. Ahora vamos a crear
la capa de negocio. Entonces si hago clic derecho en
la solución Agregar, puedo ir a un nuevo proyecto aquí. Y a la hora de elegir los proyectos, ya
tengo a mi chico aquí,
esta aplicación de consola. Así que realmente no
quiero otro, sobre todo ahora mismo,
tal vez en el futuro. Depende de mis necesidades. Las necesidades de cada uno son diferentes. Pero algo para como una capa de
negocios donde
tienes código y
prácticamente solo código puro. Entonces quieres algo
llamado biblioteca de clase. Si hago clic en siguiente aquí, puedo
volver a llamar a la biblioteca de clases como quiera. Pero si mi aplicación se
llama aplicación de prueba así, podríamos tener algo como
B L una capa de negocios o LL una capa de lógica de negocios
o algo así. Algo que representa una capa diferente
en la aplicación. Normalmente me gustaría capa
de negocios por ejemplo. Entonces este proyecto
contendría todas las cosas de
negocios, como el
fin comercial del sistema, si ves por aquí. Ahora tenemos dos proyectos. Contamos con nuestra interfaz gráfica
de usuario. Ahora tenemos aquí nuestra
capa de negocios y eso
contendrá todos los cálculos
y cosas así. Ahora por último si escribo, haga clic de nuevo en la solución. Podría agregar algo así
como una capa de datos, tal vez un proyecto de base de datos
o algo así. También podría ser
otra biblioteca de clases que represente la capa de datos. Algo bastante así. Se podría decir Dow para la capa de acceso a
datos o
algo que tenga que ver con los datos. O incluso DB para base de datos.
Realmente no importa. Podría
llamarlo así. Entonces este último proyecto
aquí, este tercero, representaría
cualquier cosa que tenga que ver con vincular nuestra solución a
una posible base de datos, ya sea Oracle, SQL, mi CQL, algo
así, no importa Y ahora tenemos tres proyectos. Ahora, arquitectura, Hay tantas arquitecturas disponibles cuando se
construye software,
como cuando se construye un edificio No hay una manera de
construir un edificio. Hay tantas formas diferentes, pero esta es una muy popular. Lo que pasa es que si a lo mejor
tienes 50 personas en tu equipo, trabajas para una empresa. Algunas personas
sabrán de HTML por ejemplo, pero no van
a saber nada sobre tal vez una base de datos o
cálculos agudos complejos de C en este proyecto. Entonces lo que pasa es que
sólo trabajarán en este proyecto. Del mismo modo, si eres
una persona de base de datos, entonces solo trabajarás en
este proyecto de base de datos aquí. Separar tus soluciones por diferentes proyectos también ayuda con el trabajo en equipo y
cosas así Sólo las personas que
conocen la base de datos, por ejemplo, trabajarían
con este proyecto de base de datos. Eso es algo así como algunos de
los razonamientos detrás de esto. ¿Cómo consigo mi proyecto
aquí, por ejemplo? Este tipo, ¿cómo consigo que
hable con este proyecto? Porque por defecto he agregado tres proyectos aquí
bajo la solución, pero ninguno de ellos está
hablando entre sí. ¿Cómo logramos eso? Si voy a mi
interfaz gráfica de usuario, por ejemplo, este proyecto aquí, voy
a dependencias aquí Ahora, dependiendo de la
versión de Visual Studio, esta es la más nueva, ahora mismo, se
llama dependencias. Si tienes una versión anterior, podría decir referencias
o algo así. Si haces clic derecho en eso y
ve a Agregar referencia de proyecto. Cuando hago eso, aparece una
ventana. Ahora puedo ver todos
los proyectos en mi solución como denotan este menú
de la izquierda Aquí quiero checar los proyectos que
quiero atar a mi chico, digamos que quiero platicar con mi capa de negocios donde se hacen todos
los cálculos. Yo solo verifico eso
ahí y presiono bien. Y ahora internamente, mi interfaz
gráfica de usuario, esto ahora puede
hablar esencialmente de este proyecto aquí, la capa de negocios donde estarán todos
los cálculos. Pongamos una muestra aquí
para que podamos simplemente hacer algo. No va a hacer mucho. Configura un método muy simple aquí dentro de lo que se llama
la capa de negocios. Y lo que eso va a hacer es simplemente devolver
la cadena hola. Eso es todo lo que va a hacer. Voy a llamarlo hola. Voy a
llamarlo hola clase. Ahora dentro de nuestra
capa de negocios por aquí, tengo una clase
llamada hola clase. Tiene un método, y todo lo que hace ese método es
devuelve la cadena hola. Ahora si vuelvo a mi proyecto de
interfaz gráfica de usuario aquí, prueba app guy y escribo, por ejemplo, hola clase. Se puede ver que
ni siquiera está en esta lista, pero en realidad he hecho referencia
al proyecto a éste. ¿Por qué no puedo acceder a él? Bueno, aquí es donde entran los espacios de
nombre. Si has estado siguiendo
estos tutoriales hasta el momento, verás bastante este espacio de
nombres de palabras clave, casi en todos los archivos. Y entonces tiene nombre. Normalmente, el nombre
del espacio de nombres se genera
automáticamente a partir
del nombre del proyecto. Por ejemplo, este proyecto
aquí se llama Test App Guy. Pero si voy a
mi capa de negocios, mi proyecto empresarial que creé, se
puede ver que
se toma el nombre
del proyecto aquí.
Ahora espacio de nombres. Es como una
forma lógica de organizar las cosas. Por ejemplo, ya hemos
hablado antes de la
clase de matemáticas, por ejemplo, donde hacemos arte matemático, raíz
absoluta
o cuadrada o algo así. Pero la clase de matemáticas, si pongo el cursor sobre esto, se
puede ver que pertenece a un espacio de nombres llamado
sistema aquí mismo Por defecto, cuando creo un
nuevo proyecto en visual studio, me dan algunos
espacios de nombre por defecto. Todos estos espacios de nombre aquí, estos siete, me son proporcionados
por defecto. Esencialmente, puedo usar cualquier código que
Microsoft
me haya proporcionado que esté contenido dentro de cualquiera de estos espacios de
nombre aquí, igual que tengo un espacio de
nombres aquí con un nombre Y tengo algún código aquí. Por defecto, puedo utilizar cualquier código dentro
de cualquiera de estos espacios de nombre. Esto es muy parecido
a lo que tenemos aquí. Lo que tengo que hacer, bueno, necesito hablar con el espacio de nombres donde
he definido ese método, porque ahora mismo no lo es. Aquí. Puedes ver
donde hemos definido el método está dentro de un
espacio de nombres llamado test app PL. Si copio eso,
vuelvo a mi capa de chico, aquí
mismo, justo arriba aquí, uso una palabra especial
llamada ¿usando qué? Usando does, te permite
usar un espacio de nombres diferente. Si solo pego en
ese espacio de nombres aquí, seguido de un sam colon, si escribo hola clase, ahora se puede ver que
tengo acceso a eso, esencialmente mediante el uso de
este espacio de nombres. Tengo acceso a cualquier cosa dentro este espacio de nombres,
dentro de este archivo. Espero que eso tenga sentido ahora, porque hola clase se define
en test en el espacio de nombres B L, como puedes ver aquí mismo, está dentro del espacio de nombres Puedo acceder a todas
sus características. Voy a crear
una nueva instancia de hola clase aquí mismo. Ahora puedo decir hola,
regreso hola. Y eso
me conseguirá esa cuerda. Así es como puedo hablar con una clase diferente dentro de
un espacio de nombres diferente, que está dentro de un proyecto
diferente. Ahora para la máxima claridad, si vengo a
mi solución aquí, voy a mi capa de
negocio de aplicaciones de prueba aquí. Y voy a una clase
aquí, por ejemplo. Se puede decir que tiene el espacio de nombres
predeterminado. Si creo una clase completamente nueva, voy clic derecho, Agregar Nueva clase. Yo lo llamo como
quiera, no importa. Se puede volver a ver, tiene el mismo espacio de nombres
porque está tomado del proyecto. No importa
cuántas clases cree. Por defecto, tomará el nombre del proyecto
para el espacio de nombres. Pero puedes cambiar
el nombre del espacio a lo que quieras. Se puede ver que ese es el
poder de los espacios de nombres. En tienda, puedes tener
espacios de nombres anidados, Por ejemplo, un espacio de nombres dentro de
un espacio de nombres, nombres dentro de
un espacio de nombres, lo cual es bastante Se puede ver que hay un espacio de nombres llamado sistema dentro de eso Hay una llamada colecciones. Dentro de eso, hay
uno que se llama genérico. Piense en un espacio de nombres como una forma de agrupar
las cosas. Si tienes algo
dentro de un proyecto, que tiene que ver con un
proyecto, todo tu código, por ejemplo, en la capa de
negocios, como el corazón de
la aplicación, ese será un proyecto, un ensamblaje por ejemplo. Sin embargo, dentro de ese proyecto, podrías tener cosas diferentes. Al igual que podrías tener
parte del proyecto para calcular el área de
una casa o algo así, pero dentro de ese proyecto, podrías tener algo
completamente diferente, como calcular una declaración de impuestos. Pero tal vez esas dos
cosas podrían tener que existir dentro del mismo
proyecto por cualquier razón. Y en ese caso, lógicamente los
agruparías en quizás un espacio de nombres
diferente Entonces, cualquier cosa que tenga que ver con trabajar
en la zona de una casa, podrías llamar a eso un espacio de
nombres y al
otro para hacer declaraciones de
impuestos o
lo que sea El ejemplo podría ser cualquier cosa y ese podría ser un espacio de nombres diferente. Entonces estás
agrupando lógicamente por tal vez una actividad o
una función o lo que sea que decidas al pensar en
proyectos, piensa en arquitectura, como
estructuras tu solución Pero cuando piense en el espacio de nombres, piense en
cosas más lógicas como
cómo agrupa piezas
de código similares Y esa es una especie de
diferencia en este caso. Así que sólo voy a mostrarles una cosa más con respecto
a múltiples proyectos, y asambleas y
cosas así. Ahora bien, este es un tema bastante
complicado, un tema
bastante grande realmente. Pero lo que te estoy mostrando
es suficiente para que sigas el resto
de estos tutoriales. Pero no solo eso, sino que cuando
comienzas tus propias
soluciones y proyectos, tienes una idea general de cómo se supone que debes
estructurar las cosas. Y también cómo
organizar tu código, lo cual es muy importante
cuanto más grandes se vuelven tus proyectos. Ahora bien, si venimos aquí, tenemos nuestra solución aquí con nuestros tres proyectos debajo. Ahora cada uno de estos
representa como una asamblea. Es una palabra que
vas a escuchar mucho, pero cuando la gente
habla de asambleas y del modificador de
acceso interno, entonces es interna
a la asamblea, que suele ser
representada por un proyecto. Un proyecto por montaje. Ahora bien, si vengo a
este botón verde de reproducción aquí
mismo, cuando hago clic en este, se compila
nuestra solución, se compilan
todos nuestros proyectos y se crea un ensamblaje
para cada uno de nuestros proyectos. Entonces si voy a mi sistema de
archivos ahora, ahora estoy usando un sistema de ventanas
para el proyecto chico aquí. Está haciendo un
archivo EXE aquí mismo. Nuevamente, algunos
archivos diversos con eso. Pero también puedes ver
que en realidad está creando un archivo DLL aquí para
cada uno de nuestros proyectos. Ahora bien, esto es lo que aquí
se llama asambleas, porque tenemos tres
proyectos en este caso, también
tenemos tres
asambleas aquí. Se puede ver detrás
de escena y cómo se representa esto
en el mundo real. Cuando le das este
software a tus amigos o tal vez lo
empaquetas en un archivo configurado, puedes ver cómo
estos proyectos se representan como
archivos binarios aquí mismo, normalmente uno para cada proyecto. Una cosa que voy a mencionar
es que tener esta
palabra clave usando aquí arriba es algo opcional si decido
eliminarla, por
ejemplo, se puede ver que
esto ya no va
a funcionar porque no puede localizar el espacio de nombres donde esta clase está
contenida dentro. Lo que podemos hacer en este caso es simplemente calificarlo con
el espacio de nombres. Cada vez que uso la clase Hello, tengo que decirle al sistema
donde se encuentra, como ¿en qué
espacio de nombres se encuentra? En este caso, puedo
calificarlo con el espacio de nombres antes del nombre de
la clase. Pero si sigo usando
esta clase en este archivo tal vez 1020 veces, voy a tener mucho
tipo de código redundante aquí. Entonces, en lugar de hacer eso, puedo eliminar todos
esos y simplemente usar el espacio
de nombres
en la parte superior del archivo. Y entonces ya no necesito
calificarlo cada vez que lo uso. Entonces esa es una ventaja de usar el espacio de nombres aquí, NC Sharp
54. 11-1. Puntos de interrupción y pasos de código: Depuración, depuración en C Sharp. Qué es la depuración Si has estado siguiendo
mi tutorial hasta ahora, hemos trabajado con el lenguaje
C Sharp, hemos hecho muchas cosas
diferentes Orientación de objetos, bucles,
cálculos, métodos. Pero durante estos
ejercicios, por ejemplo, y trabajando con el lenguaje, el hecho de la vida es
que los humanos son humanos. Van a cometer errores, ya sea intencional
o no intencional, o simplemente un accidente total Estas cosas suceden. Aquí es
donde entra la depuración Ahora, la depuración es un término flojo. La palabra depuración se usa
en dos sentidos diferentes. Podemos decir, bien, voy a hacer algunas depuraciones, y este es el proceso
de tratar de encontrar bugs Quizás tu software no tenga errores, pero vas a intentar
encontrar algunos solo para
asegurarte de que funcione correctamente.
Esto es bastante normal. También puede usar el
término depuración cuando su software tiene un problema y está tratando de
localizar el problema Entonces dirías,
voy a intentar
depurar mi software porque
hay un error. No sé dónde está, pero
necesito intentar encontrarla. Entonces aquí se usa en dos sentidos. Ahora, como mencioné, el hecho de la vida es que
nadie es perfecto. Si todos fueran perfectos, entonces las empresas de software ni
siquiera contratarían equipos de prueba para realizar pruebas. No tendrías algo
llamado pruebas unitarias. No necesitarías
probar tu código. Pero el hecho de la vida
es que no somos perfectos. Y es por ello que
necesitamos saber sobre depuración y tratar de
encontrar errores en nuestro software Ahora, en lo que va de esta serie de
tutoriales, hemos estado usando Visual Studio. Ahora Visual Studio es genial. Contiene muchas herramientas, características, y apenas hemos raspado la superficie,
para ser honesto Tiene un compilador que
compila nuestro código. Tiene el IDE donde realmente
podemos escribir para crear soluciones de
proyectos. Tiene esa función de
autocompletar, también conocida como Intellisense Así que muchas cosas diferentes, pero otra cosa que también tiene es lo que se llama un depurador Entonces un depurador es una
pieza de software, un programa totalmente separado,
escrito por Microsoft Y el trabajo del
depurador es
unirse a otra
pieza de software Esto se llama
adjuntar el depurador. Entonces, ¿a qué software se une este
depurador? Bueno, este es tu
código, tu software. Cada vez que presionas ese botón
verde de reproducción, tu software se compila
en segundo plano Si estás usando
Windows, por ejemplo, se compila en un
EX, por ejemplo Entonces el depurador puede
adjuntarse a este
archivo EXE en este caso, pero no solo a su software Se puede adjuntar a otro proceso de ejecución
que su sistema está ejecutando. Es bastante poderosa.
Entonces, ¿cuál es el beneficio de que este depurador
se adhiera a su software ¿Cuál es el propósito de
eso? ¿Por qué haría eso? Bueno, cuando un depurador se
adhiere a tu software, te
permite
ejercer un nivel de control mientras tu
código se está ejecutando Y puede examinar determinados
segmentos de código cuando las cosas pueden salir mal mientras
su software se está ejecutando. Imagina que puedes pausar tu software en
cualquier momento. Digamos que su software se carga, se está ejecutando un bucle. Por ejemplo, tal vez un bucle de cuatro, y simplemente puede detener la ejecución
a mitad del bucle Digamos que tienes un bucle de cuatro
y cuenta hasta diez. Puedes detener tu software
en un momento en el tiempo, por ejemplo, cuando
solo se cuenta hasta cuatro. Entonces, mientras el
software se está ejecutando, puede ingresar a su código
e inspeccionar todo. Se pueden ver los valores de las variables. Incluso se puede controlar
la ejecución. Entonces haz manualmente que ese bucle fore haga dos iteraciones más,
por ejemplo Y puedes hacerlo tú mismo. ¿Alguna vez has visto esas películas de
superhéroes en
las que el tipo es realmente rápido y
el mundo entero está congelado Pero debido a que es tan rápido, puede interactuar con la
gente en tiempo real. Imagínese que para ser
como un depurador. El mundo se está
ocupando de sus asuntos. Pero esta entidad súper rápida, este héroe súper rápido, puede
volar a la velocidad
de la luz y modificar las cosas
y controlar las cosas Así es como funciona
un depurador. Es bastante potente y bastante entretenido de
usar, para ser honestos. Y el proceso de pausar
tu aplicación mientras se está ejecutando usando el depurador se llama entrar en modo break Y cuando dije
en realidad puedes controlar la ejecución. Por ejemplo, si su software se está ejecutando y está
a punto de ejecutar un método, puede omitir este método por
completo pasándolo por encima y controlando el flujo
de su software mientras se está ejecutando se
llama paso a paso de código. El depurador es en realidad una
pieza de software
bastante poderosa, y el 99.999% de los desarrolladores usaría un depurador para
crear algún tipo Entonces echemos un
vistazo a un ejemplo de eso. Ahora bien, ¿cómo entramos en este mundo donde somos un superhéroe rápido Y podemos pausar el software
y cambiar las cosas, y cambiar los valores de las variables y omitir métodos
y todas las cosas así. ¿Cómo lo hacemos? Bueno,
vamos a echar un vistazo. Entonces, si has estado
siguiendo nuestros otros tutoriales hasta ahora, cuando escribimos algún código, hemos estado presionando este botón
verde de reproducción aquí arriba. Cuando presionamos el
botón verde de reproducción, nuestro software se ejecuta. Y cuando queremos matarlo o
terminarlo, o
cruzamos la ventana aquí o presionamos este botón rojo de
parada de aquí arriba. Entonces eso es lo que hemos
estado haciendo hasta ahora. Si vas a la izquierda de
este botón verde de reproducción aquí, notarás una lista
desplegable aquí. Por defecto debería decir error D, pero por debajo
también tiene lanzamiento. Ahora bien, estos dos elementos aquí
son bastante importantes. Si tenemos errores
seleccionados en esta lista, entonces cada vez que presionamos
este botón verde de reproducción, también se ejecuta
el depurador y también se
adhiere a nuestro software Para los curiosos, si
seleccionas lanzamiento en esta lista, entonces normalmente usamos esto cuando queremos darle el software a otra
persona porque no contiene ninguna
información de depuración Pero por ahora,
hablemos de depuración aquí. Ahora a esto se le llama
modo de lanzamiento. Ahora mismo, queremos
depurar nuestro programa, queremos encontrar algunos errores
y hacer algún trabajo de detective. Normalmente, cuando
desarrollamos software como desarrollador y estamos encontrando errores y desarrollando
nuestra solución, usaríamos aquí este modo de
lanzamiento, bug. Y por eso es por defecto. Entonces como dije antes, cuando ejecutamos la
aplicación aquí y nuestro software se está ejecutando
en segundo plano,
el depurador, el depurador de
visual studio se
ha unido
a nuestro Y te lo puedo demostrar
si abro Administrador de tareas. Aquí está mi administrador de tareas aquí, estas son todas las
aplicaciones que estoy ejecutando. Aquí está Visual Studio,
pero debajo de aquí se
puede ver la consola del depurador de Visual
Studio Esto se está ejecutando en
segundo plano y esto en realidad está unido
a nuestro software. Pero hasta ahora realmente no
hemos hecho ningún uso de esto en nuestros tutoriales
anteriores, pero en este tutorial
y en los siguientes, vamos a estar usando
esto bastante. Ahora echemos un vistazo al depurador
de visual studio. Echemos un vistazo a hacer
algunas depuraciones aquí. Tengo una aplicación de muestra. Cuando se ejecuta este método principal. Aquí está entrando en un bucle
de cable sin fin. La aplicación nunca
va a salir. Cada vez que este bucle de alambre se enrolla, le
pedimos al usuario que
ingrese un día de la semana. Estamos tomando su respuesta, almacenándola en una variable, luego pasando su respuesta
a este método aquí, dependiendo en qué día de
la semana ingresen. Tenemos una
declaración switch que imprime un mensaje personalizado dependiendo del día de la semana que ingresen. Bastante simple, cada vez
que da salida a un mensaje, solo
estamos ingresando una línea
en blanco
y luego volviendo de nuevo para pedirles otro
día de la semana Es una
aplicación bastante sencilla con esta aplicación
aquí tengo un poco de problema cuando
escribo el miércoles. No me está dando la salida
real que quiero. Cuando escribo el miércoles, quiero que salga
miércoles o mito, que actualmente no lo hace Por ejemplo, si
escribo el martes, obtengo una respuesta para el martes. Pero para el miércoles
se puede ver que me está diciendo que
entré un día inválido. Ahora aprecio que esta es una pieza de software
muy simple, pero imagina
que este software es muy complicado. Podría tener 50 archivos. Es posible que tenga métodos, métodos, métodos llamada,
métodos dentro de los bucles. Para que veas que puede
llegar a ser muy complicado. Entonces, echemos un
vistazo a cómo podemos depurar una aplicación como esta. Sabemos hasta ahora usando nuestras habilidades de detective
que el martes funciona. Entonces, por lo tanto, el código está
entrando en este método. Se ejecuta el comunicado del switch y estamos recibiendo una
respuesta para el martes. No obstante, el miércoles no
está funcionando. Entonces, hay un problema con
este código alrededor de este punto. Al menos eso es
lo que yo pensaría. Entonces parece que cuando
escribo el miércoles, está dando salida a este tipo de sección
predeterminada aquí mismo ¿Por qué está haciendo eso?
Lo que podría hacer en este caso es agregar lo que
se llama un punto de quiebre. Si vienes a
este lado izquierdo aquí, hay una barra gris. Cuando voy a cualquier parte
de esta barra gris, ahí se ve un círculo gris. Si hago clic con el botón izquierdo, agrega un punto rojo. Entonces puedes ver
aquí mismo, así se llama. ¿Qué es establecer un punto de quiebre? ¿Por qué se llama punto de quiebre? Bueno, cuando ejecuto el software aquí y tecleo cualquier
día de la semana, puedes ver que la
ejecución del código se detiene para recordar cuando te
expliqué qué era una hamburguesa, y dije, es como
ese superhéroe que puede modificar en tiempo real, ya
sabes, como la
velocidad de la luz Esta es la inacción del depurador. Ahora el depurador se ha
unido a nuestro software estableciendo lo que se llama un
punto de ruptura, estos puntos rojos Aquí, podemos establecer
tantos como nos gustaría. Cada vez que el código alcanza
uno de estos puntos rojos, el software se congelará. Se detendrá. No se puede hacer nada
más. Si intento abrir mi software, no
puedo interactuar con él en absoluto. Está totalmente congelado. Y tenemos
control total a nivel de código. Esta pieza amarilla de aquí, esto es en lo que está congelada. Y ese es nuestro primer punto de ruptura. Así que nada más puede pasar. Está congelado en el tiempo. Entonces, lo que podemos hacer mientras
está parado aquí, en realidad
podemos inspeccionar las cosas. Mira, si pongo el cursor sobre esto, puedo ver el valor
de nuestra variable aquí Puedo ver el valor de
que se pase aquí. Así que es genial, ¿no? Es como interactuar con el mundo mientras el
mundo está congelado. Ya sabes, siente el poder. Entonces este es el poder
de un punto de quiebre. Rompe el software. Y no me refiero a
romper como romper una taza de vidrio o
romper un jarrón de vidrio. Quiero decir, rompedores en pausa, como alto. Detener la ejecución. Entonces eso es lo que es un punto de interrupción. Lo siguiente de lo que
quiero hablar es de lo que se llama paso a paso de código. ¿Qué es el paso de código? Ahora mismo, nuestro software
está congelado en el tiempo. Está congelado en esta
línea de aquí. La sentencia switch
aún no se ha ejecutado. Es amarillo, lo que significa que está a
punto de ser ejecutado,
pero aún no. Lo que podemos hacer, podemos ejecutar
manualmente la
siguiente línea de código. Esto se llama paso a paso, y podemos hacerlo manualmente. Si venimos aquí,
ven aquí todos estos íconos. Este de aquí,
dice entrar, este paso por encima, este un paso fuera. Y este un paso atrás. Así que un montón de diferentes botones de
paso a paso aquí mismo. Pero, ¿qué es pisar? Bueno, por ejemplo, este
de aquí, paso por encima. Ves el
atajo de teclado aquí es diez. Si presiono diez, eso va a dar un paso
por encima de esta declaración. Y lo que eso significa es que
el código se va a ejecutar a la
siguiente línea de código, o al siguiente bloque de código
dentro de una sentencia switch. Aquí está tomando en nuestra entrada, que es más o menos
una cadena de garboard Lo que debería suceder es que esta
línea de código se ejecutaría porque no tenemos
ningún día de la semana coincidente con nuestra entrada. Si presiono F diez, que es paso por encima, se
puede ver el código entonces
va a esta línea aquí mismo. Ahora hemos ejecutado el inicio
de la sentencia switch, y ahora el software
nuevamente se congela en el tiempo. En esta línea, se puede ver que
no tenemos un
punto de quiebre en esta línea, pero eso no importa porque
pisamos manualmente. Si queremos que el software
continúe ejecutándose, entonces presionaríamos el botón de
reproducción, por ejemplo. Entonces el software
simplemente seguiría funcionando hasta que llegue a uno de
estos puntos de interrupción rojos Pero cuando hacemos
código paso a
paso como paso sobre paso en todo
ese tipo de cosas, estamos ejecutando manualmente
una línea de código a la vez, o un bloque de código a la vez, como una
sentencia switch, por ejemplo. Entonces ese es el poder de pisar, y eso es simplemente ejecutar manualmente segmentos de su
código en secuencia, cómo normalmente
se ejecutaría. Ahora el software está
congelado en esta línea aquí. Ingresaste un día no válido. Si presiono diez de nuevo, entonces ahora nuestra ventana de consola
mostrará esta línea. Si abro la ventana de la consola, se
puede ver que esta línea ya se
ha ejecutado, pero nuevamente el software
se congela en el tiempo. Nuevamente, en este símbolo de
ruptura aquí, presiono F diez de nuevo, y ahora estamos a punto de escribir esta línea a la
consola F diez de nuevo, y ahora se ejecuta el método. Eso es genial, ¿no? Entrar en visual
studio cuando se trabaja en C sharp es
controlar manualmente el código, ejecutar
manualmente piezas de código. Eso es lo que es el paso del código. Nos permite
ejecutar manualmente líneas de código. Y podemos hacerlo nosotros mismos. Y podemos hacer esto estableciendo puntos de
quiebre para detener
inicialmente el código. Y entonces podemos
usar lo que se llama comandos de paso para entrar, overout y todas
las cosas así. Pero, ¿cuál es la diferencia
entre entrar, salir, pasar por encima? ¿Qué son estas cosas? Bueno,
considera este ejemplo aquí. Hemos ejecutado la aplicación, y estoy llamando a este
método cinco veces seguidas sin ninguna razón real que no sea
para mostrarte la diferencia. Si corremos paso en el que es 11, entonces vamos a
entrar en este método. Si golpeo F 11, puedes ver que la siguiente
línea de código a ejecutar es la rizada
abierta aquí mismo, seguida de la sentencia
switch. He entrado en un método, he entrado aquí. Lo que también podemos hacer es
pasar por encima del método. Simplemente ignora todo esto por completo. A lo mejor sabemos que este
método es perfecto, no tiene nada de malo. Entonces podemos pasar por encima de todo
este método. Y entonces la siguiente línea a
correr será esta de aquí. Porque tenemos pasos
sobre todo el método, esa es la diferencia entre
step into y step over. Podemos simplemente saltarnos
toda una sección de código. Puede que lo hayas
adivinado. ¿Qué es step out? Bueno, estamos en un
método ahora mismo. Puedo dar click en step out turno 11 y podemos salir completamente
del método. Y eso lo hacemos cuando asumimos
el resto de los métodos. Bien. Como que queremos
salir de aquí y volver a donde estábamos antes y luego meternos en
cualquier otra cosa. Entonces esa es la diferencia
entre estos comandos de paso. Normalmente es solo entrar en
algo así como un método, o una clase o
algo así, o una propiedad, o podríamos
pasarlo por encima por completo. Así que solo ignóralo y
continúa con el resto. Y si nos encontramos
en un método y ya sabes, todo se ve un poco bien, entonces podemos salir de él. Entonces estos se llaman comandos de
paso. Y el proceso de mover la ejecución de códigos se llama paso a paso de
código o paso a paso. Entonces esa es la diferencia
con los que están ahí. Entonces ahora he explicado los
puntos de interrupción. Código paso a paso, comandos de
paso a paso. Intentemos encontrar
nuestro problema aquí. Puede parecer bastante obvio, pero recuerden que dijimos que
el miércoles no estaba dando salida al
mensaje correcto. Entonces, ¿por qué es eso? Así que vamos a establecer un punto de interrupción en esta
declaración switch aquí porque sabemos que es probable que
el problema esté dentro de esta declaración
switch. Entonces voy a ejecutar
la aplicación ahora, y voy a escribir el miércoles. Voy a darle a Enter, y estamos a punto de lanzar
esta declaración de cambio. Aquí está nuestra variable aquí. Puedo pasar el cursor sobre la entrada, y puedo ver, mira el miércoles Entonces ahora lo que está pasando
es que si paso por aquí, pueden
ver que está golpeando
este caso predeterminado. Entonces ninguno de estos casos
coincide el miércoles, pero lo que me parece
raro porque tengo el miércoles
justo aquí ahora mismo, el miércoles. Entonces, si pongo el cursor sobre esta
variable, miércoles, oh, ya veo, mira, la y está en una mayúscula
ahí mismo. Es mayúscula. Probablemente por eso ahora he cambiado esta
y a minúsculas. Hago el cursor sobre esta variable aquí. Parece que coincide
correctamente. Entonces esto debería funcionar. Ahora lo que podría hacer es
reiniciar la aplicación. Ves este icono aquí
junto al botón Detener. Dice reiniciar. Lo que también podría hacer es detener el programa o
tacharlo y luego volver a ejecutarlo. Este botón de reinicio
aquí, lo que hace, reinicia el código R, pero deja el depurador
ejecutándose en segundo plano Si haces clic en reiniciar, especialmente si tienes una
gran pieza de software, es un poco más rápido
comenzar de nuevo. Esa es la diferencia entre el botón de reinicio y el botón de
detener la reproducción. Una cosa que también podemos
hacer, por ejemplo, es mover manualmente
la ejecución del código. ¿Qué demonios significa eso? Ahora mismo, estamos ejecutando
esta línea de código. Está a punto de ser ejecutado. Simplemente pasamos por encima de eso, y ahora estamos a punto de
ejecutar esta línea aquí. Esencialmente, esta sentencia
switch aquí ha terminado de ejecutarse. Lo que podemos hacer es pasar el ratón sobre esta flecha
amarilla de aquí mismo Mantenga pulsado nuestro botón izquierdo, y de hecho podemos mover la ejecución de los códigos de
vuelta al inicio de
la sentencia switch, como si nunca se hubiera ejecutado
en primer lugar. Eso es genial, ¿no? Imagínese arrastrar el ratón
aquí como usando un comando step, como step over o into Pero te permite dar un paso atrás, pero no sólo una línea,
sino múltiples líneas. Entonces es un atajo para
esos comandos de paso. Pero te permite hacerlo
en trozos grandes, por ejemplo. Ahora estamos a punto de volver ejecutar la sentencia switch otra vez, pero en realidad hemos
modificado el código aquí y ni siquiera hemos
detenido nuestro software. Se hace en tiempo real. Es bastante genial, ¿no? Ahora bien, si paso por encima de usar diez, se
puede ver que esta línea ahora
está golpeada en la línea derecha. Los miércoles son meros, así que
parece que solucionamos el problema. Fue justo, fue solo esa
mayúscula y el miércoles. Entonces ahora lo que puedo hacer
es simplemente presionar F cinco, que es la abreviatura de este botón
verde de reproducción. Entonces ahora creo que el
problema se resolvió. No quiero hacer
más depuración. Puedo quitarme mis puntos de
quiebre si quiero, y luego solo puedo presionar
este botón verde de reproducción y eso solo dejará que el
software continúe con normalidad. Entonces ahora está diciendo los miércoles
ahí, lo cual es perfecto. Eso es exactamente lo que quiero. Si lo repito de nuevo, obtenemos exactamente el mismo resultado. Entonces parece que arreglamos
el problema con nuestro software. Era solo una diferencia de un
personaje. Podría ser un cambio menor. Pero incluso cosas como una diferencia de un
personaje pueden traer, digamos, cohetes del espacio X al
suelo, sin llegar
nunca a la órbita Por lo que es muy importante que todo se
revise con puro detalle. Para
ello, un depurador es una herramienta muy útil sobre cómo
lograr cosas así Voy a introducir
un ejemplo más y un par de otras
herramientas de depuración que pueden resultarle útiles Se ejecutan para hacer clic
y correr al cursor. Entonces echemos un
vistazo a este ejemplo aquí. Si seguiste
los tutoriales anteriores, entonces probablemente
recuerdes este ejemplo. Esencialmente, a este ejemplo
se le está pidiendo un número. Se escribe el número 25, y luego dibuja una pirámide
que tiene 25 líneas de alto. Por ejemplo, porque pongo 25, tiene 25 líneas de alto. Pero se puede ver que
hay un problema con los antecedentes de esta pirámide. Este lado derecho de aquí
va demasiado tiempo. Debería verse como
el lado izquierdo aquí. Después de cada línea, se puede ver que
la pirámide se ensancha, pero el fondo
se encoge así Pero este comportamiento no se está imitando en
el lado derecho Hay un pequeño
problema con esto. Echemos un vistazo a
lo que está pasando aquí. Aquí está el ejemplo.
Aquí le estamos preguntando al usuario qué tan alto
quiere que esté la pirámide. Lo estamos pasando a un método. Estamos delegando toda la lógica de dibujar la pirámide
en este único método Aquí tenemos nuestro bucle principal de cuatro que dibuja cada línea
de la pirámide a su vez. Entonces tenemos 34 bucles, uno para hacer los
guiones a la izquierda, uno para dibujar la pirámide, y otro para hacer los
guiones a la Sabemos que tenemos un problema con
los guiones de la derecha. Esta es probablemente una
buena zona para establecer nuestro punto de interrupción y echar un
vistazo a lo que está pasando aquí Si ejecutamos el software, le
pedimos al usuario un número. Empecemos
con un número bajo. Los números bajos son más fáciles depurar porque
no hay muchos de ellos. Escribiré el número cinco. Nuestro punto de quiebre ha
sido alcanzado aquí. En este momento, no se declara H. Presionemos diez para dar un paso por encima. Y ahora hemos inicializado el
encabezado para nuestro bucle de cuatro. Ahora mismo estamos a punto de hacer la primera iteración del bucle H es uno porque ese es
su valor inicial aquí. Entonces H va a seguir
funcionando hasta que sea menor o igual a
lo que parece cinco. Y cada iteración
aumentamos en una. Para la primera línea, H va a continuar cinco veces porque ese es
el tamaño aquí mismo. Si paso por encima de eso, estamos
dando salida a un guión, luego dos guiones, Entonces ya está hecho. La
primera línea de una pirámide, que tiene cinco unidades de altura, genera cinco guiones a la
derecha ¿Eso es cierto? ¿Eso es correcto? No, porque en la primera línea, debería dar salida a cuatro. Aquí está generando
demasiados guiones. ¿Por qué es esto? Obviamente está
generando demasiados guiones, pero los guiones de la izquierda
están generando la están generando Así que puedes ver aquí,
el guión debería detenerse cuando sea tamaño menos y
Esa es la fórmula que
teníamos aquí. Esa es la fórmula que
teníamos aquí Obviamente lo hemos hecho
para este bucle de guión aquí, pero hemos descuidado replicar
la misma funcionalidad
para los guiones de la derecha
usando Se puede ver que
podemos examinar el valor de H mientras se está ejecutando el
software. Hagámoslo ahora. Puedes ver podemos
examinar los valores de H. Podemos examinar
los valores de tamaño, Podemos examinar los valores de y. Incluso
podemos examinar
los valores aquí arriba, valores que entran en
el método usando los comandos step como
step over o into, en realidad
podemos controlar la
ejecución del software. Eso es genial, ¿no? Digamos que aquí hemos
descubierto la solución, ya
hemos descubierto el problema. Ahora, mencioné un par
de cosas antes sobre run to cursor y run to
click. ¿Qué son? Bueno, corre al cursor y corre
para hacer clic en comandos de atajo. ¿Recuerdas cuando hablé arrastrar aquí esta flecha amarilla ¿Justo aquí arriba para que podamos
controlar la ejecución? Ejecute manualmente para hacer clic y ejecutar los atajos
del cursor para
controlar el flujo de código. Como paso de código. Si pongo
mi cursor aquí, por ejemplo, clic
derecho y luego
elijo ejecutar a cursor, haga clic en eso y luego la ejecución va a
donde esté el cursor de mi mouse. Es un poco atajo
y es bastante útil. Otro es run to click. Se puede ver cuando cada
vez que hago clic en una nueva línea, aparece
este misterioso pequeño botón
verde de reproducción. Pero se puede ver aquí,
éste de aquí mismo. Hago clic en esta línea,
aparece aquí mismo, es como un poco
fantasma verde. Entonces esto se llama run to click. Si hago clic aquí en este pequeño botón
verde de reproducción, la ejecución del código va
a saltar a esta línea. Así que es más o menos lo
mismo que hacer clic en esta línea derecha Al hacer clic
y elegir correr al cursor. Así que es solo un
pequeño y agradable atajo práctico. Así que puedes ver correr
para hacer clic y correr al cursor son ambos
pequeños atajos útiles. Si esta sección de código
se repite varias veces, entonces puedo hacer clic en
esto por ejemplo, y la ejecución del código continuará hasta que
llegue a esta línea. Solo son buenos atajos de
código paso a paso. Este es run to click
y el click derecho uno, puedes hacer run to code cursor, pero también hay un atajo
para eso, que es control F diez. Cuanto más uses visual studio, más vas a
aprender estos atajos. Pero cada desarrollador que conozco todos modos sabrá
entrar y salir, que es F 10.11 Y esos dos son realmente útiles para recorrer el
código Entonces ahora vamos a ejecutar
la aplicación y
parece que nuestro problema con los
guiones se ha resuelto Fue solo un problema con
ese último bucle de cuatro aquí. Y ese es el límite superior. Entonces, al depurar
código en general, tienes que hacerte
algunas preguntas Si se producía un error, ¿cuál era
la sentencia
o expresión que hacía el programa en
el momento del error? ¿En qué línea de código falló
tu programa? ¿Falló el programa? Y tenías ese tipo de línea
resaltada que decía que ahí
había un error.
¿Qué línea era? Y cuando tu programa falló, ¿cuáles eran los valores
de las variables, como los parámetros, los campos
locales, algún objeto? ¿Cuáles eran esos valores
cuando ocurrió el error? ¿Cuál fue la secuencia de sentencias ejecutadas en
el momento del error? ¿Estabas dentro de un método? De un método, por ejemplo? Entonces, ¿dónde estabas? ¿Qué
se ejecutó de antemano? Y creo que
prácticamente he cubierto este. ¿Cuál fue el resultado de la
línea de código donde falló? ¿O tal vez el resultado de la
línea de código antes del error? Entonces hay que considerar
todas estas cosas. No se puede simplemente poner puntos de interrupción en cualquier parte y
esperar encontrar un error Tienes que
hacerte estas preguntas. Tipo de apuntar el error
aproximadamente a dónde podría estar, qué clase podría estar, en qué método podría estar. Entonces, una vez que
lo hayas aislado a un método en particular, entonces puedes comenzar a trazar
puntos de interrupción y
aislarlo un
poco puntos de interrupción y
aislarlo un Para resumir, esto es
lo que es la depuración. Es el proceso de
buscar errores, pero si tienes un error, es el proceso de tipo
de aislar el error. Esto es lo que es un depurador. Entonces este es un depurador de
estudio visual. Y puedes usar
esto cuando configuras tu modo de lanzamiento para depurar. Y cuando estás depurando, puedes colocar cosas
como puntos de interrupción Y aquí es donde se detendrá la ejecución del
código. Cuando la ejecución del código se detiene, esto se llama modo de interrupción Estás entrando en modo break y
esto es cuando se
ha alcanzado un punto de ruptura para controlar
el flujo de ejecución. Usando step in para salir, rentar, hacer clic en inquilino, cursor, o incluso arrastrando el mouse
a lo largo de esta barra de punto de ruptura Entonces esto se llama paso a paso de
código. Estas son todas las,
toda la terminología que tiene que ver con la depuración
en visual studio Puede que te sorprenda, pero solo hemos raspado
la superficie de la depuración Espero que este tutorial
te haya ayudado. Gracias por ver.
55. 11-2. Ventana inmediata: En este tutorial, vamos a hablar de la ventana inmediata. Ahora bien, esta es una utilidad de depuración y es sumamente útil Si no has visto
mi último tutorial sobre depuración, puntos de interrupción, paso de
código, entonces te
recomiendo encarecidamente eso antes de
ver este tutorial, la
ventana inmediata, ¿qué es? Si bajamos aquí, puedes ver esta pequeña pestaña
aquí llamada Ventana Inmediata. A lo mejor lo has visto antes, a lo mejor te has estado preguntando de
qué se trata. Si no ves esta pestaña aquí, entonces si llegamos a la cima, podemos ir a este menú de
depuración aquí. Ahora bien, aquí es donde viven todas
las utilidades
y características de depuración . Si te lo estabas preguntando, ve a Windows y luego
ve a Inmediato. Y cuando haces eso,
volvemos
aquí abajo y esta pequeña pestaña
debería aparecer aquí mismo. Ahora, la
ventana inmediata se puede usar en diseño o tiempo de ejecución,
entonces, ¿qué significa eso? Bueno, el tiempo de diseño es cuando
nos estamos desarrollando. Ni siquiera hemos pultido el botón
verde de reproducción todavía. No hemos compilado nada. No estamos manejando nada. Pero lo que podemos hacer, en realidad
podemos trabajar con nuestro software
en tiempo de diseño, por lo que el software ni
siquiera se está ejecutando. Entonces echemos un
vistazo a este ejemplo ahora para poder mostrarte a
lo que me refiero con eso. Si siguió nuestros tutoriales
anteriores, hicimos una
calculadora de muestra donde
le pedimos al usuario un primer número, un segundo número y
luego un operador. Y luego dentro de un método
aquí, por ejemplo, toma esos números
y un operador, por
ejemplo, 54, y
luego tal vez más. Y entonces si el
operador es un plus, los suma y luego solo muestra el resultado,
que serían nueve. En este caso, lo que podemos hacer, en realidad
podemos probar este método desde la ventana
inmediata. Es una locura, ¿verdad?
El software ni siquiera se está ejecutando, ni
siquiera se está ejecutando. ¿Cómo lo hacemos?
Tomemos este método aquí. Calcular, por ejemplo.
Entonces voy a copiar eso. Vamos a bajar a esta ventana
inmediata aquí. Ahora bien, cualquier cosa en la ventana
inmediata comienza con un signo de interrogación
que prácticamente dice, bien, quiero ejecutar un comando. Entonces quiero ejecutar este método. Entonces lo que voy a hacer
es llamar a este método. Voy a llamarlo con cinco, y se necesita un personaje, y recordar personajes
en comillas simples. Y vamos a hacer un plus al trabajar en la ventana
inmediata. El punto y coma es opcional. Podemos decirlo, no tenemos que
hacerlo, realmente no importa. Ahora mira lo que pasa
cuando golpeo a Er. En realidad ejecuta nuestro software, lo compila y lo ejecuta, y luego nos da el
resultado para este método Se puede ver que en realidad
hizo esto en tiempo de diseño. Mi software ni siquiera estaba funcionando me dio
el valor nueve. Es una manera bastante buena de
probar cosas como métodos, evaluar expresiones
en tiempo de diseño, pero también tiempo de ejecución. También puede hacer esto mientras
el software se está ejecutando. Eso es bastante inteligente, ¿no? Si pongo un punto de quiebre, tal vez aquí por ejemplo, vamos a borrar la ventana
inmediata, podemos escribir, hacer clic en
eso y dar clic en Borrar. Todo eso nos
despejará la ventana. Entonces ahora aquí arriba
tengo un punto de ruptura en el doble resultado
es igual a calcular. Antes incluso de llamar al método, estoy deteniendo el programa, así que nada más
va a continuar Ejecuto la aplicación
haciendo clic en el botón verde de reproducción o presionando cinco.
No importa. Ahora estamos pidiendo el primer
número cinco y luego cuatro, y luego quiero
sumarlos juntos. Ahora el programa ha
dejado de ejecutarse. Si vengo aquí abajo, la esquina inferior, tengo esta
ventana inmediata justo aquí. Así que puedo hacer muchas cosas aquí. Puedo ejecutar ese método otra vez. Por ejemplo, mientras se está ejecutando
el código, Una característica útil es
mientras el código se está ejecutando, tenemos este Intellisense,
el En realidad nos está proporcionando todas las variables de
alcance, como el número uno. Número dos, podemos pasarle información
personalizada si queremos. Si digo 54 y más,
tal como lo hicimos antes, entonces golpeé Enter,
en realidad podemos obtener el resultado. Pero se puede ver aquí, nada
ha pasado realmente aquí. Todavía podemos continuar
con este cálculo. Eso es genial, ¿no? Lo que también puedo hacer es
usar variables existentes. Ahora mismo tengo el número
uno, el número uno. Si voy por aquí y
destaco este valor, se
puede ver que el usuario
dio el número cinco y el número dos
le dio cuatro. Y el operador
usaron un plus ahí mismo. Lo que realmente podemos hacer
es usar esas variables. De hecho, podemos ver el resultado antes de que
se ejecute el método. Bueno, a lo mejor
quiero multiplicarlos. Entonces se puede ver aquí cinco
multiplicar cuatro es 20. Así se puede ver que la ventana
inmediata
en realidad puede interceptar
varias cosas Evaluar expresiones, método
run, muchas cosas así. Todo mientras el código está
realmente en modo break. Este método ni siquiera se ha
aplicado todavía, por ejemplo. Ahora hay un
detalle fino con eso. En esta
ventana inmediata de aquí abajo, ya
he llamado dos veces al
método de cálculo. Pero imagina si calcular
hizo otra cosa, tal vez contara algo
en el fondo. Cada vez que corro
calculo mantiene un conteo, un total acumulado de
cuántas veces lo he llamado. Ahora ejecutar este método en la ventana inmediata
afectaría los resultados. Es como si este método en realidad
se estuviera ejecutando ahora que podría
causar varios problemas. Entonces, dependiendo de lo que haga
tu código, si te equivocas en la ventana
inmediata aquí, puede afectar los
resultados aquí arriba. Simplemente realmente depende de
lo que haga tu código. Para algo como
calcular,
bueno, realmente no
almacena ninguna información. No cuenta nada. No mantiene un total corriente de cuántas veces
se le ha llamado. Así que es bastante seguro correr
en la ventana inmediata. No obstante, hay
casos en los que sería inseguro, por ejemplo, por
esas otras razones. Eso es algo que
vale la pena señalar. Entonces déjenme demostrarlo. Ahora sólo para ilustrar de
lo que estoy hablando. Digamos que este
método de cálculo sí mantiene un recuento corriente de cuántas
veces se le ha llamado. Pero usamos este conteo corriente
para propósitos importantes. A lo mejor
algo más se basa en ello. Este campo sólo va
a mantener un recuento de
cuántas veces se está llamando al
método de cálculo, cuando se llama al
método de cálculo, solo
voy a incrementar este campo
local en uno cada vez Entonces, si ejecuto la aplicación ahora, solo
voy a establecer un punto de
interrupción aquí para que podamos pausar la ejecución
del software. Voy a escribir
algunas cifras de muestra, como cinco más cuatro. Y entonces voy
a venir aquí a la ventana inmediata. Esto se ciernen sobre este campo
privado de aquí. Tiempos entumecidos, se puede ver que el
valor es actualmente cero. Pero si ejecuto este método
dentro de la ventana inmediata, este tal vez lo ejecute tres veces. Por cierto, al presionar la flecha hacia
arriba en el teclado, puedo mirar a través de mis
cosas anteriores que he escrito aquí Así que eso es genial, ¿no? Entonces he ejecutado el
método de cálculo tres veces, pero solo desde la ventana
inmediata. Si vengo aquí y vuelvo el cursor sobre mi variable privada aquí, puedes ver que tiene el valor
de tres cosas en tu código se ven afectadas por cualquier cosa que hagas en la
ventana inmediata de aquí abajo Entonces es realmente importante y es algo de lo que
debes estar consciente. De nuevo, obviamente,
todo
se restablece cuando ejecutas tu aplicación Pero en lo que respecta a la depuración,
vale pena señalar esto Entonces acabo de
hablar del hecho que al usar la ventana
inmediata, por ejemplo, para llamar a métodos, puede cambiar las cosas en tu código. Ahora bien esto podría ser un comportamiento
deseado, tal vez quieras hacer esto
y eso está perfectamente bien. Pero hay situaciones
como en nuestro ejemplo anterior donde incrementamos
una variable, por ejemplo Pero necesitamos esto
aquí y no
queremos nada en nuestra
ventana inmediata para cambiar esto. Pero todavía queremos
ejecutar el método desde
la ventana inmediata. Bueno, hay algo que realmente
podemos hacer para superar este problema en la ventana
inmediata donde llamo al método, sea lo que sea que pongas aquí, ya sea llamando a un método, evaluando una expresión, averiguando el
valor de una variable, puedes simplemente sufijarlo
con un pequeño comando llamado S E que significa
no efectos secundarios Se puede ver cuando tecleo
ese estudio visual
nos da alguna buena
indicación en este momento. Si vengo aquí, puedes
ver nuestra variable aquí, número de veces es cero. Vuelvo a
la ventana inmediata y presiono Enter. Entonces puedes ver Calcular
en realidad ha corrido las cifras. Se agregaron estos
números juntos, pero he especificado esta bandera
sin efectos secundarios. Si vuelvo por aquí y harver varias veces, aún
conserva el valor
de cero especificando SE, significa
que no
van a ocurrir efectos secundarios como
resultado de que usted llame a resultado de que usted llame este método desde la ventana
inmediata Eso es genial, ¿no? Esa es una de las características
que puedes hacer con eso. Así que hemos llamado
métodos con cambios, hemos llamado métodos
sin cambios. Bueno, ¿qué más podemos hacer
en la ventana inmediata? Bueno, podemos ver
valores de variables. Entonces, por ejemplo, el número uno. ¿Qué es eso? Oh,
el número uno es cinco. Eso es genial, ¿no? Así que siempre lo prefije
con un signo de interrogación. Y obviamente, estas son
sólo variables de alcance. Entonces, por ejemplo, si estas
variables no tienen un valor, o aún no
se han alcanzado, o no
se han inicializado, entonces obviamente no se pueden
leer los valores de estas Entonces es solo lo que
se llama en alcance, lo que realmente tenemos acceso. Lo que también podemos hacer es
evaluar expresiones, por ejemplo, cinco más
siete por ejemplo. Nos va a dar el resultado y lo podemos hacer
con variables,
así que el número uno dividido
por el número dos. Es bastante genial, sobre todo
cuando estás depurando, has puesto algunos números de
muestra, pero puedes detener
la ejecución
del código y jugar
con él en tiempo de ejecución, en lugar de reiniciar
la aplicación,
probar algunos números, reiniciarlo nuevamente, reiniciarlo nuevamente Se puede ver como la ventana
inmediata agiliza ese problema Simplemente puedes poner
lo que quieras y tal vez estés tratando de
localizar un error o un problema. Te da una manera realmente rápida, fácil y dinámica de tratar de localizar estos
problemas y errores. Es por ello que la ventana inmediata es bastante genial en ese sentido. Pero no solo podemos simplemente llamar a
métodos y mirar valores, realidad también
podemos asignar
valores. Si miramos el valor
del número uno que el usuario ingresó es cinco
y ellos ingresan el número dos, que es ahí seis. Y el operador era un plus, así que vamos a conseguir 11. Lo que podemos hacer es en realidad
cambiar los valores de las variables. En lugar de
sumar cinco a seis y obtener 11, dicen que el número
uno es igual a 11. Ahora el número uno equivale a 11. Hagamos que el número dos sea
igual a 12 por ejemplo. Y dejaremos al
operador como un plus. Ahora hemos cambiado a
esas dos variables. Vamos a subir aquí ahora. Si pasamos el cursor sobre
esas variables, puede ver que el número uno es ahora 11 y el número dos ahora es 12 Hemos modificado los valores
de estas variables durante el modo
break mientras el software se ejecuta a la
velocidad de la luz, como estábamos
hablando antes, realidad
hemos modificado
las cosas en tiempo de ejecución. Es una locura, ¿
no? Es increíble. Ahora si presiono cinco y continúo con el
funcionamiento del software, se
puede ver que el resultado es 23. El usuario ingresó 5.6 pero como
que entramos ahí, modificamos algunas cosas, cambiamos este a 11 y
este a 12. Para que veas que el
resultado es el reflejo del cambio que hicimos
en la ventana inmediata. Así que eso es genial, ¿no? Así que imagina que la
ventana inmediata es como un pequeño bloc de notas
donde puedes
jugar y cambiar
las cosas y llamar cosas Ese es el poder de la ventana
inmediata en visual studio cuando se
trabaja con C shop.
56. 11-3. Locales y Autos Windows: Continuando con nuestro
tema de depuración, voy a hablar de
la ventana local y
también de la ventana de autos.
¿Qué son? Bueno, los locales y las
ventanas de autos solo están disponibles durante una sesión de
depuración Tenemos que entrar en
modo de depuración y echar un vistazo a esas ventanas y luego te
mostraré lo que
tienen para ofrecerte. Lo que voy a hacer ahora,
voy a sumar un punto de interrupción. Aquí está mi sencilla
aplicación de calculadora donde sumo, resto o multiplico
números juntos Entonces varias cosas aquí. Sólo voy a
establecer un punto de interrupción aquí sin ninguna razón
en
particular Entonces voy a ejecutar
la aplicación en modo de
depuración porque queremos
hacer alguna depuración, el software se está ejecutando, me está
pidiendo dos números Sólo voy a poner algunos datos
de muestra ahí. Ahora, el código se ha pausado, se ejecutado, y nuestro
punto de quiebre ha sido alcanzado Ahora el software
está congelado en el tiempo, y podemos hacer lo que
queramos con él. Si bajamos aquí a
la esquina inferior izquierda, en mi caso, se puede ver
que tenemos algunas pestañas
aquí, varias pestañas. Uno se llama locales y otro
se llama Autos. Justo aquí. Si no ves ninguno de estos, entonces sube aquí al menú de
depuración, ve a Windows. Y luego hay un
par de opciones aquí llamadas autos y locales. Ahora, es posible que no vea
estas opciones de menú a menos que esté en una sesión de
depuración Así que asegúrate de que actualmente estás depurando y estos
deberían aparecer También puedes usar estos atajos de
teclado, una vez que tengas estas
ventanas visibles aquí abajo. Lo que ofrecen estas ventanas
es una mirada
en tiempo real a las variables cuando miramos antes la ventana
inmediata, donde podríamos mirar valores de variables
con el signo de interrogación. Antes imaginamos que esto es una interfaz gráfica de usuario para la ventana inmediata en términos de
lectura de variables
y objetos y cosas así. De todas formas, se puede ver que he pausado la ejecución del código
dentro de este método de cálculo Aquí ya tenemos
valores para num uno, num dos, y también el operador. Nuestro resultado es actualmente cero porque no
tenemos un valor establecido. Entonces, si miramos aquí en esta ventana
local, podemos ver todos esos valores para esas variables en
una ventana fácil. Para que podamos
ver claramente lo que nos
ha dado el usuario y cuál podría ser
el resultado. No solo eso, si hacemos doble
clic en el valor aquí, realidad
podemos cambiar esta
información en tiempo real, igual que antes en
la ventana inmediata, podemos cambiar estos valores. Voy a resultado, incluso
puedo modificar el resultado antes de que se haya inicializado Y no sólo eso cambia
el operador, por ejemplo, no sólo
te da una vista de solo lectura, en realidad
puedes modificar
estas variables y los cambios se reflejarán durante tu sesión de depuración Así que eso es genial, ¿no? Así que hemos mirado
aquí
la ventana local donde podemos ver nuestras variables aquí y también
cambiar algunos de los valores. Ahora estos están disponibles
en el alcance actual. Entonces, lo que eso significa es que he
establecido un punto de quiebre aquí. Estamos dentro de este método, este es el alcance actual. Podemos acceder a estas
variables aquí, pero no podemos leer nada
fuera de este método. Son solo cosas en
el ámbito local. ¿Qué es lo local para nosotros aquí? Esto es lo que se refleja en
la pestaña local aquí mismo. Hablemos de la ventana de
autos ahora y también cómo la ventana de autos
difiere de la ventana local. Son bastante similares
en la forma en que se comportan. Se pueden cambiar
valores variables y cosas así. Se puede ver el valor de
variables y objetos, pero ¿por qué son diferentes? La ventana autos aquí
, muestra información
sobre la línea actual. Cuando digo la línea actual, el punto de ruptura actual, ve
que el software
está pausado aquí, indicado por esta parte
resaltada amarilla Podemos ver variables y
objetos en esta línea actual. Aquí mismo, tenemos el resultado. No sólo eso, también podemos ver información de la línea
anterior. Ahora podemos ver num veces, y si paso por encima de
eso usando diez. Entonces la ejecución del código
pasa a la siguiente línea, puedes ver que la información se cambia en nuestra ventana de autos. Realmente la principal
diferencia entre autos y locales es
que autos
te da la línea actual y
la anterior y los locales te dan todo
en el alcance actual. Se puede ver la
ventana de los lugareños aquí no incluye no veces porque la
hemos definido aquí arriba. Entonces puedes ver que es un campo privado
estático de nuestra clase de programa, por lo que no aparece
en la ventana local. Los lugareños son solo las cosas
locales para ti. Las cosas locales
en el alcance y los autos es la
línea actual y la anterior. Esa es la principal diferencia. Pero una cosa que aún no he
discutido es que tanto las ventanas locales como las ventanas
autos pueden
evaluar expresiones. Si voy a aquí, por ejemplo, donde dice resultado, puedo hacer lo que hicimos en
la ventana inmediata antes donde evaluamos
ciertas cosas. Podría decir que el resultado
es de cinco más cuatro, así se puede ver que el
resultado es nueve. También puedo usar variables
existentes. Número uno, por ejemplo, más 567 y eso va a ser evaluado, por lo que también podrás
evaluar expresiones tanto
en las ventanas locales como en
las ventanas de autos. He configurado una
aplicación de muestra aquí que usa algunos objetos más
complicados. Tengo una
clase de videojuegos que se pasa en algunas cosas
al constructor. Tengo una lista de usuarios, y estoy agregando tres
objetos de usuario a esa lista, y también creando una
lista de enteros. Así que aquí hay
cosas bastante complicadas. He puesto un punto de quiebre
al final. Entonces vamos a entrar en
una sesión de depuración, y luego nuestro punto de interrupción
va a ser golpeado, y luego vamos a mirar la ventana local para ver
cómo podría ser eso Sólo voy a
extender esto un
poco para que podamos ver
un poco mejor. Puedes ver aquí, esto es
prácticamente todo aquí. Ahora tengo estas
flechas Mira porque estos juegos son objetos más
complicados. Sólo puedo hacer clic en esta flecha. De hecho puedo ver
todas las propiedades y varias cosas dentro de aquí. Ahora este pequeño
tiene un candado, lo que significa que aquí es un campo
privado Pero esto tiene una
pequeña llave inglesa, lo que significa que es una propiedad. Puedo modificar los
valores dentro de aquí, así pueden ver que puedo usar un visualizador de
texto para verlo, así puedo ver los
valores del título Si hago doble clic en el valor, puedo modificar varias
cosas aquí. Podría decir que uno es
para un Macintosh, igual que antes cuando teníamos variables
simples, tipos de valores
simples Podría cambiar los valores. Pero incluso con
objetos complicados como este, también
puedo cambiar los valores y ver la jerarquía
de esos también. Para este de aquí mismo, la lista de usuarios,
puedo ampliar eso. Y luego puedo ampliar los
miembros ahí dentro y ver varios nombres y edades
y cosas así. Entonces es bastante útil
y realmente poderoso. Durante una sesión de depuración, puedes ver el estado
de todos tus objetos, ya sean tipos de valor complicados
o simples, o dentro de una
ventana gráfica aquí mismo Realmente es increíble. Y si nos fijamos en la pestaña autos, dije que la pestaña automática
muestra información sobre el punto de interrupción actual y también la línea
ejecutada anteriormente En este caso, agregamos un
punto de interrupción en esta línea roja. El último comunicado que se
ejecutó fue esta línea aquí mismo. Por lo tanto, este objeto está
disponible en nuestra ventana de autos. Si tienes una pieza de software realmente
grande, quizás con cientos
o miles de objetos y variables
en el alcance actual, entonces puedes
buscarlos también. Entonces es realmente bastante
útil cómo funciona eso. Y puedes especificar
una profundidad de búsqueda, lo que solo significa cuántas
flechas de lata donde pueden aparecer tus
resultados de búsqueda. Entonces puedes ver que también hay muchas opciones de profundidad ahí dentro. Pero ese es realmente el principio detrás de los locales
y las ventanas de automóviles. Permite ver y
también cambiar variables. Pero a diferencia de la
ventana inmediata de aquí, te da una interfaz gráfica de
usuario agradable para trabajar. Y también te da el estado de cómo son estos objetos, son estos campos privados, son estas propiedades públicas. Por lo que realmente es bastante
útil en ese sentido.
57. 11-4. Mira Windows y Quick Watch: Voy a
hablar de ver ahora, y esto vuelve a estar relacionado con la
depuración en visual studio ¿Qué es lo que está viendo específicamente? Voy a estar
hablando de reloj rápido y ver Windows.
Entonces, ¿qué son? Si ves mi otro tutorial sobre locales y autos Windows, como que funciona muy
parecido a eso. La única diferencia con una ventana de reloj es que
podemos elegir qué agregar ahí. Pero no sólo eso, podemos
evaluar expresiones. Entonces, ¿qué significa todo eso? Vamos a comprobarlo. Entonces en este momento tengo una aplicación de muestra, nuestra pequeña
aplicación de calculadora. Si has estado siguiendo
nuestros otros tutoriales, acabo de agregar un punto de
ruptura aleatorio aquí. Estoy en modo de depuración, estoy entrando en una sesión de depuración. El depurador está adjunto
a nuestro software. Es pedir dos números y un operador, cinco más seis. Ahora nuestro punto de quiebre
ha sido alcanzado, el software está congelado. Podemos examinar las
variables ahora mismo. Bajamos aquí tenemos
nuestra ventana local familiar, donde podemos observar
el valor de las variables actuales
en el ámbito actual. número uno es cinco, el
número dos es seis, el operador es más y el resultado es 11. Estos son valores de todas las variables en el ámbito actual. Ahora ve la ventana. Si venimos aquí para depurar
y luego ir a ventana, y luego se puede
ver que hay reloj 123.4 Eso significa que podemos tener hasta cuatro relojes de
Windows, cuatro sesiones Hablemos de lo que es realmente una sesión de
vigilancia. Voy a hacer clic en Ver uno. Y si bajamos aquí, puedes ver que hay una pestaña
Watch One que se
ha creado
junto a los locales, autos, y ahora
tenemos una Watch one. Y puedes ver aquí
dice agregar artículo para ver. ¿Qué significa eso? Bueno,
podemos ver cualquier cosa. Prácticamente queremos que nos
gusten las variables, los objetos. Por ejemplo, si
vengo aquí al código, aquí
tenemos estas variables. El número uno es el número dos es seis. Si hago clic derecho en el número uno, puedo bajar este menú
y hacer clic en Agregar reloj. Voy a hacer exactamente lo
mismo para el número dos. Haga clic derecho, Agregar reloj. Si llegamos a la
ventana del reloj aquí abajo, podemos ver que funciona
más o menos como nuestra ventana local. Tenemos las variables que
hemos agregado, tenemos los valores, y también podemos cambiar los
valores si queremos. Podrías preguntarte, ¿por qué no solo uso
la ventana local? Hace exactamente lo mismo. Más o menos la principal
diferencia entre la ventana del reloj y la ventana
local es ese reloj, puedes agregar lo que quieras y también puedes
agregar expresiones. Por ejemplo, podría decir número uno más el número
dos y luego presionar Enter. He agregado una
expresión personalizada aquí. Ahora a través de la vida de mi prácticamente sesión de
depuración, sé que el valor de
num uno más num dos, o he puesto el número uno
ahí más el número dos Si puedo aprender a teclear es 11. Se puede ver que puedo poner
expresiones aquí. Podría decir el número uno
multiplicado por el resultado. Puedo poner varias cosas
personalizadas aquí. Esta es prácticamente una
de las principales diferencias entre la ventana del reloj
y la ventana local. ¿Cuáles eran esos
relojes 1234 ventanas. Si venimos aquí para
depurar de nuevo, luego Windows, luego mira y haz clic en Ver
para volver aquí abajo. Ahora tenemos otra pestaña de vigilancia, entonces podemos agregar otras
variables aquí. Ahora bien, estas ventanas adicionales
son prácticamente solo útiles cuando se tiene una aplicación
realmente grande. Quieres aislar
ciertas variables de otras variables solo
para que estén más organizadas y
no te confundas. Si estás trabajando en tal vez
una aplicación de calculadora, es posible que quieras poner todas
tus variables observadas en esta ventana de vigilancia. A lo mejor la
aplicación de calculadora tiene otra característica que maneja
algo totalmente diferente. Y luego pones tus variables de
reloj aquí. Estás organizando tus
variables y expresiones. Puedes tener hasta cuatro ventanas de
vigilancia si lo deseas. Ese es uno de los beneficios y poderes de la ventanilla del reloj. No solo puedes ver y cambiar variables como las ventanas
locales, sino que también puedes agregar
expresiones aquí. Eso es bastante genial. No estás limitado solo a variables básicas. Incluso puedes llamar a métodos. Por ejemplo, tengo un
método llamado calcular. Y entonces puedo calcular, digamos cuatro más ocho por ejemplo. Y entonces puedo poner eso
ahí y eso se
evalúa también. Las expresiones no solo están
vinculadas a variables simples, sino que también podemos poner llamadas a
métodos completos aquí. Es realmente potente
y también muy útil sobre todo a la hora de depurar aplicaciones
bastante grandes. Y una cosa que mencioné
al inicio de este tutorial fue Quick
watch. ¿Qué es Quick Watch? Imagina que solo quieres ver una simple variable
muy rápidamente. Digamos que solo quieres verificar el valor de
una variable muy rápido. Ese es prácticamente el único
propósito de Quick Watch. Si escribo clic en el número
uno por ejemplo, y hago clic en Quick Watch, o turno F nueve, aparece
esta ventana. Y cuando aparece esta ventana, no se
puede seguir depurando Tú. Bastante
solo atrapado aquí. Aquí estoy rápido viendo
la variable número uno, puedo cambiar su valor, puedo volver a evaluar
lo que quiera. Y también puedo cambiar o
entrar en cualquier otra expresión. Entonces podría decir calcular. Y sí tiene autocompletar
aquí también. Entonces, si quiero decir cinco
más cuatro y presionar Enter, puedo hacer
expresiones rápidas sobre la marcha, pero obtienes este tipo
de diálogo molesto. Y para ser honesto, prefiero solo usar la ventana del reloj porque
hace todo lo que hace el reloj
rápido. Pero solo lo estoy
resaltando porque
sé que algunas personas
prefieren usar eso. No estoy seguro personalmente por qué. Pero está ahí si lo necesitas. Entonces ese es esencialmente
el mensaje que estoy tratando de transmitir. Pero la ventana del reloj hace
todo lo que hace el reloj rápido. Entonces ese es el poderoso de las ventanas de
reloj en C Sharp.
58. 12-1. El modificador de acceso protegido: Quiero hablar del
último modificador de acceso que aún no hemos
discutido, y que está protegido. Hemos hablado de
público, privado, interno, pero ahora vamos
a hablar de protegido. Ahora, protected es una
palabra clave que generalmente se usa cuando heredas
clases en C Sharp Entonces, si no has visto
el tutorial que hice sobre herencia y
mientras estamos en ello, si no has visto
el tutorial que hice sobre configuración de múltiples
proyectos en visual studio, entonces
te recomiendo encarecidamente que los revises primero. Aquí tenemos un ejemplo muy
básico. Tengo una clase principal aquí. Simplemente configura cuatro objetos
de videojuegos aquí. Si miramos aquí la clase de
videojuegos, no está pasando mucho. Tiene un campo privado
y un constructor y hereda de una clase basada en el
juego principal aquí Y llama al
constructor de juegos desde aquí. Muy sencillo, nada que no
hayamos visto antes. Si nos fijamos en la clase base, tiene tres campos privados. Tiene un constructor, tiene un método público de muestra y un par de propiedades
públicas de muestra aquí. Aquí tenemos muchas
cosas públicas pasando aquí. Ahora, la palabra clave protegida, se aplica a métodos como este y propiedades también. Si algo está
marcado como protegido, entonces solo está disponible para la clase actual, por ejemplo, juego y cualquier cosa que descienda de eso, todos sus hijos. Piénsalo. Si eres como
la madre de una familia, entonces solo quieres compartir cosas
protegidas con tus hijos o tus
nietos por ejemplo Entonces piénsalo así,
ya está protegido. Este es un método público. Aquí. Todo lo que hace, recibe el nombre y
une algunas cadenas juntas y el editor,
ahora mismo, es público. Para que podamos acceder a
esto desde cualquier lugar. Podemos acceder a él desde
nuestro programa principal. Podemos acceder a él desde
videojuego, no hay problema en absoluto. Lo que voy a hacer,
voy a hacer esto protegido, que puedan ver ahí está
la palabra clave protegida. Ahora ya lo he hecho. Si instancio
esta clase aquí, juego de la clase principal Ahora la clase principal no es un hijo de esa clase
entonces no va a hacerlo. Déjame hacer eso,
déjame demostrártelo. Ahora puedes ver aquí cuando
intento acceder al método, ni siquiera
está en
esta lista en absoluto. Y mira lo que pasa si
intento acceder a él de todos modos, ignorando el autocompletado de Visual
Studios Si pongo el cursor sobre
eso, dice que es inaccesible debido a
su nivel de protección Y eso es
porque está protegido. Por lo que solo está disponible de la clase actual o de las clases
hijas de esta clase. Por ejemplo, el videojuego, videojuego es una clase infantil porque estamos
heredando de ahí Si solo decimos base por ejemplo, entonces estamos accediendo a la clase
base que es juego. Ahora podemos ver este
método, está en la lista, y cuando intentamos acceder a eso, no
hay errores en absoluto. Ese es el poder de la palabra clave
protegida en C sharp. Pero hay un par de combinaciones que
en realidad pueden ir con protegido, y eso es protegido interno, y también protegido privado, protegido privado, y
protegido interno. Estas son un par de
combinaciones que podemos usar al tratar con el modificador de acceso
protegido. Así que básicamente podemos
duplicar los modificadores de acceso, pero solo cuando se usa protected Puedes ver aquí
podemos usarlo en tres combinaciones por sí mismo, que es lo que
ya hemos comentado. Está disponible en
la misma clase. Los métodos y propiedades
están disponibles en la misma clase o en
cualquiera de sus hijos. Ya lo hemos discutido a
continuación, privado protegido. Si algo está marcado
como protegido o privado, un método o una propiedad, entonces se puede acceder a él
en el mismo ensamblaje, pero también desde dentro de
la misma clase derivada. Si nuestra clase de juego aquí
está en el mismo proyecto, el mismo montaje que nuestro hijo, que sería videojuego. Si estos existen en
un mismo proyecto, el mismo ensamblaje, entonces podemos
hacer uso de esos métodos. Sin embargo, si este archivo de juego aquí estaba en un proyecto diferente, entonces no podemos acceder a los
métodos y propiedades de esta clase secundaria que
es privada protegida. Entonces déjame mostrarte
un ejemplo de ello. Ahora voy a marcar Editorial. Esta es una propiedad de tienda aquí. Editorial, voy a
comercializar como privado protegido. Ahora bien, si esta clase existe fuera
de la asamblea llamante, donde quiera que queramos usar esta, no va a funcionar. Echemos un vistazo a un
ejemplo de este trabajo. Podemos decir editor. Podemos acceder a esto, no hay problema. Si solo digo cadena
algo es igual a editor, no
hay problema
porque podemos acceder a ella. Ahora déjenme mover esta clase aquí. Clase pública, principal, fuera
de la asamblea actual. Si viste mi tutorial
sobre múltiples proyectos, probablemente sabrás
cómo hacerlo. Si venimos aquí
al lado derecho, obtenemos nuestra clase de juego. La clase padre,
sólo voy a arrastrar y soltar en el segundo
proyecto que he configurado. El principio es
que ya no lo quiero en este proyecto ahora,
voy a borrarlo. Ahora el juego está en este proyecto totalmente
diferente por aquí. Ahora el juego está en una asamblea totalmente
diferente por aquí. Podemos regresar a nuestra clase de
videojuegos aquí, que está en la otra asamblea. Ve por aquí ahora puedes
ver que se ha producido un error. Así que todavía puede encontrar juego porque estamos refiriendo a
los otros proyectos, así que sabe dónde está. Se puede ver que estamos
heredando de ahí. No obstante, ahora ha aparecido una
línea roja. Y si pasas el cursor sobre eso, dice que editor es inaccesible debido a
su nivel de protección Eso es porque
lo hemos hecho privado protegido. Si algo es
privado protegido, tiene
que estar dentro de
la misma asamblea, entonces el mismo proyecto. Y tiene que ser un descendiente de esta clase que está
protegida privada Ahora entendemos privado
protegido, la misma asamblea y un niño, es muy fácil explicar
qué es lo interno protegido. Que puede ser a, cualquier descendiente de la clase, pero puede ser en
cualquier otra asamblea No importa dónde se encuentre, por ejemplo, la
clase base. Podría ser en un proyecto totalmente
diferente. Pero mientras esté
protegido internamente, deberíamos poder acceder a él. Ahora mismo, tenemos este error
por el nivel de protección, porque el videojuego y el juego
están en diferentes asambleas. Vuelvo al juego, ahora
hago esta propiedad aquí, protegida, interna o
interna protegida. Entonces lo he configurado ahí
arriba vuelvo al videojuego, y ahora se puede ver que el
error se ha ido. Entonces esa es la diferencia
entre privado protegido e
interno protegido. Simplemente significa que la clase
base tiene que estar en el mismo ensamblaje
o no en el mismo ensamblaje. Entonces esos son los tres tipos de modificador de
acceso cuando se trata de protegido, por lo que la clase base
y sus hijos. Y luego podemos
doblarlo con privado o interno
dependiendo de si la clase base está en el mismo ensamblaje o en otro
conjunto diferente. Entonces ese es el modificador de
acceso protegido en tienda.
59. 12-2. La palabra clave estática: Ahora voy a
hablar de la palabra clave estática. Es posible que hayas visto
esto si has estado siguiendo nuestros otros tutoriales. Esta pequeña palabra clave aquí llamada estática,
¿qué significa eso? ¿Qué hace?
¿Y por qué deberíamos usarlo? Echemos un vistazo a
este ejemplo aquí. Solo estoy definiendo cuatro objetos de
videojuegos aquí y llamando al constructor
con tres parámetros. Si miro dentro de la clase de
videojuegos, solo tiene tres campos
privados. Aquí está el constructor que
establece los campos privados. Yo solo tengo un método de ejemplo aquí que devuelve el título. Y solo una
propiedad de ejemplo aquí que solo consigue que el editor sea muy básico. Si tengo una clase como
esta, por ejemplo, ¿cómo tal vez guardaría un recuento de la cantidad de videojuegos
que tengo en mi colección? Esto es solo un
ejemplo de lo que podría hacer cada vez que instanciara
la clase de videojuegos Podría hacer un seguimiento de un mostrador. Este contador puede mantener un recuento de cuántos videojuegos tengo. En mi colección,
inicializo un contador a cero. Cada vez que creo
un videojuego, puedo incrementar el
contador en uno Podría hacer algo
así, por ejemplo. Eso funcionaría perfectamente bien. Pero no se ve
muy elegante, ¿verdad? No sólo eso, sino que realmente
no sigue muy bien
los principios de la
abstracción. Nos gustaría mantener
este contador quizá escondido en la clase de
videojuegos, por ejemplo. ¿Cómo lograríamos esto? Cómo podríamos hacer
esto si configuramos un contador dentro esta clase de videojuegos,
por ejemplo, aquí. Entonces en el constructor
para esa clase, incremento el contador en uno No obstante, el problema es que este contador pertenecerá
a cada instancia. Entonces si voy por aquí y desde el juego uno puedo
acceder al contador, pero sólo va a tener
un valor de uno porque el contador pertenece a
cada instancia separada. Entonces, ¿cómo tengo como
un contador global, algo dentro de este
videojuego que hace un seguimiento
del número de instancias de
esta clase que creamos Ahora bien, aquí es donde entra la palabra clave
static. Cuando usamos la palabra clave static, podemos usarla en constructores, podemos usarla en campos, podemos usarla en métodos, e incluso podemos usarla
en toda la clase Por ejemplo, por ejemplo, si defino este
campo de contador como estático, entonces este campo se
compartirá entre todas
las instancias que se han
creado a partir de esta clase. Es un campo a nivel de clase. Cualquier cosa con estática dentro de
la clase pertenecerá a nivel de clase y no a nivel de
instancia como aquí. Por ejemplo. Echemos un
vistazo a un ejemplo de esto. Cada vez que creo un
nuevo videojuego aquí, quiero que dentro de mi constructor aquí tenga un contador
que incremente en uno Esto mantendrá un
recuento de la cantidad de videojuegos de
nuestra colección. Por ejemplo, lo que podría hacer, puedo simplemente hacer una
línea de muestreo aquí que escribe a la consola cuántos videojuegos tenemos en nuestra colección. Cada vez que construyo un nuevo objeto de la clase de
videojuegos, estoy incrementando el contador, que es estático, está a nivel de
clase en uno cada vez Entonces estoy emitiendo un mensaje a la ventana de la consola que simplemente expresa cuántos
juegos tengo en mi colección cuando
ejecuto este programa Cada vez. Esto se construye aquí porque estamos
creando una nueva instancia, el contador va a
incrementar en uno cada vez Echemos un vistazo a eso
Ahora puedes ver aquí, se incrementa
en uno cada vez este contador está siendo compartido
por todas estas instancias Aquí, es bastante inteligente cómo funciona
la palabra clave estática. Lo que también podemos
hacer, por ejemplo, es tener un método estático también. Por ejemplo, puedo crear un método estático que obtenga
el resultado de mi contador. Echemos un vistazo a
eso. En cambio, voy a quitar esta línea aquí. Por ahora, voy a
crear un método estático. Lo que hace este método,
simplemente devuelve el contador. Y es un método a nivel de clase, eso significa que accedemos a él desde la clase y no una instancia. Echemos un
vistazo a eso ahora mismo. Si voy al programa
principal aquí, si voy al juego uno, por
ejemplo, ahora el juego
uno es una instancia. Este método no
aparecerá en esta lista. Puedes ver que no hay ningún método
get counter aquí. Eso es porque es
un nivel de clase. En este caso, tendría que
escribir el nombre de la clase. Entonces una vez que pongo un punto después
del nombre de la clase, estos son todos los miembros de
nivel de clase aquí mismo. Entonces puedes ver este método
aquí llamado get counter. Es un nivel de clase,
no nivel de instancia. Y ahora podemos obtener la cantidad de
videojuegos de nuestra
colección, así. Si queremos sacar
eso a la consola, podemos simplemente copiar
ese método aquí, ponerlo aquí mismo, y luego
eliminar ese punto y coma. Ahora voy a ejecutar
la aplicación. Se puede ver que tenemos
un resultado similar. Es solo conseguir
el gran total
del número de los
videojuegos de mi colección. Y aprecio que acabo de deletrear
colección mal , pero
nadie es perfecto. Ese es un ejemplo
de un método estático y también de un
campo estático en C Sharp. Quizás esta palabra clave estática
que hemos estado viendo en todos nuestros tutoriales hasta ahora
está empezando a tener sentido. Ahora nuestra clase principal aquí
se llama programa. Por defecto, hay un método
llamado main que es estático. Este principal es un método a nivel de
clase. Por defecto es el
primer método que se ejecuta cuando se ejecuta
el programa. Si creo un nuevo método aquí, por ejemplo, acabo de crear
un método como este. Intento llamar a este
método de principal. Este es un método estático. Este no es un método estático. Vigila lo que sucede. Entonces puedes ver que aquí hay una línea roja. Si coloco el cursor sobre eso, dice
que la
referencia del objeto es requerida para la prueba de campo no estático o programa de
propiedad Eso es porque estamos llamando a un método no estático desde un método estático
que no está permitido. Si algo no es estático entonces es un método a
nivel de instancia. Porque estamos dentro de
un método estático. Aquí, no hay
instancia en la que operar, no
hemos creado una instancia, no
estamos dentro de un
método de una instancia. No hay nada que ver con
las instancias que suceden aquí. Estamos dentro de un método estático, pero estamos tratando de llamar a
un método de nivel de instancia. No va a funcionar. En casos como este,
tendrías que crear una instancia. Esto es sólo un ejemplo. De todos modos, no te
recomendaría crear una instancia de la clase del
programa, pero solo ayuda a mi
explicación aquí. Una vez que pongo la instancia antes de este método de
nivel de instancia, puedes ver que el error
se ha resuelto porque cualquier cosa que no sea estática
debería pertenecer a una instancia, es un nivel de instancia. Lo que también podríamos hacer en lugar de eso es simplemente burlarse de este
método como estático. De esa manera estamos llamando a
una prueba
de método estático desde otro
método estático está perfectamente bien. Otra cosa que podemos hacer con la palabra clave static es marcar
una clase entera como estática. Lo que hacemos, tomamos
la palabra clave estática y ponemos junto a la definición de
clase justo en la parte superior aquí. Cuando haces esto, todo dentro de la clase aquí también
debe ser estático. Porque si se define
esto a nivel de clase, entonces implica que todo
dentro debe ser estático. Es por ello que aquí aparecen todos estos
errores. Pero lo principal
importante de marcar la estática de
una clase
es que no podemos crear instancias
de clases estáticas. Son abstractos y
sellados implícitamente. Si recuerdas una clase
abstracta, no
puedes crear
una instancia de ella. Y si recuerdas
una clase sellada, no
puedes heredar de ella. Entonces esto es implícito, por eso tenemos
todos estos errores aquí a la hora de crear
una nueva instancia, por lo que ya no podemos hacer esto Echemos un vistazo a convertir esta clase en una clase
puramente estática. Ata y
abróchate el cinturón. Vamos. Todos estos
campos privados deben ser estáticos. Ahora nuestro constructor
en una clase estática, debe ser estática. Pero los constructores estáticos
no pueden tener modificadores de acceso. No podemos tener público ahí. Además, no puede tener parámetros. Eliminemos esos dos también. Esta palabra clave es irrelevante
porque esto solo tiene que ver con instancias
que tienen que ir también. Ahora bien, todos nuestros métodos y
propiedades también deben ser estáticos, y eso debería sobre hacerlo. Este es un ejemplo de una clase
estática aquí mismo. Ahora te estarás preguntando, bueno, si no puedo instanciar
esta clase, entonces ¿cómo se llama incluso a este
constructor, por
ejemplo, qué está
pasando aquí Bueno, por defecto, cuando ejecutas la aplicación y
accedes a esta clase, este constructor es ejecutado por el
entorno de tiempo de ejecución una vez. Esto se ejecutará
automáticamente una vez. Cualquier cosa aquí en
el constructor, el constructor estático debería inicializar cualquier variable o cualquier
cosa que quieras hacer Ese es el propósito de
un constructor estático en una clase estática. Ahora, si venimos
a nuestro archivo principal aquí, puede ver que no podemos crear instancias de la clase estática. Solo podemos acceder a
las cosas a nivel de clase. Ahora, he marcado todo
como estático, Las propiedades, los métodos, así es como nos
referimos más o menos a la clase. Ponemos el nombre de la clase como
antes y luego un punto. Entonces podemos acceder a
varias cosas aquí. Y ahora, como no hay
instancias para esta clase, todos estos miembros existirán una vez porque ese es
el punto de la estática. Podemos establecer un editor
y acceder a eso. Además, podemos conseguir que nuestro
videojuego cuente como lo hacíamos
antes. No hay problema. Sólo para demostrar que el
constructor se ejecuta una vez, echa un vistazo a este método
aquí donde consigo el contador para la cantidad
de videojuegos que tengo. Yo sólo voy a duplicar este método, así que
se llama dos veces. Voy a poner dos
puntos de interrupción aquí. El código se detiene cuando se golpea
esta línea y luego va a ir dentro del constructor y poner ahí
un punto de quiebre. Ahora voy a ejecutar
la aplicación, para que puedan ver qué pasa. Ahora el constructor no se
ha ejecutado, pero el break está
en esta línea aquí. Videojuego dot get counter. Si paso por encima de esto, se
puede ver que el constructor
aquí se llama. Si paso por encima de eso, obtenemos el mostrador,
vamos a la siguiente línea. Si paso por encima de eso, se
ve que no pasa nada. El constructor solo se llama una vez en esta primera línea aquí, y se ignora en las llamadas
posteriores a cualquier método que
exista a nivel de clase. Espero que esto tenga sentido. Es bastante para tomar, pero este es el punto de
las palabras clave estáticas para poner prácticamente cualquier cosa
que quieras a nivel de clase, el concepto de instancias en este caso son prácticamente
ignoradas En ese sentido. Te di un ejemplo de cómo funcionan también los constructores
estáticos El constructor se llama
automáticamente justo cuando tocas cualquier
método o miembro, y luego se ignora para
cualquier llamada posterior. Después de eso, espero que
esto te ayude. Este es el poder de la palabra clave
estática en tienda.
60. 13-1. La palabra clave de solo lectura: En este tutorial,
vamos a estar viendo la
palabra clave de solo lectura en C Sharp. Ahora, ¿qué hace la palabra clave de solo
lectura? Bueno, la
palabra clave de solo lectura es lo que se llama un tipo de datos inmutable.
¿Qué significa eso? Significa que una vez que
tienes un valor establecido dentro de una variable o
un campo por ejemplo, entonces no puedes modificar ese
valor una vez que se ha establecido. ¿Qué significa todo eso y qué otras condiciones están
involucradas en ese proceso? Echemos un
vistazo a un pequeño ejemplo. Aquí tengo una clase llamada Perro Perro tiene un constructor que toma un
argumento llamado raza, que es la raza del perro. Como un terrier o un
Chihuahua por ejemplo. Tengo dos campos privados aquí
mismo raza y otro que representa
solo una identificación única para cada perro que construimos. Y luego tengo una
propiedad pública que consigue y además establece la raza
del perro con los conocimientos que
hemos adquirido hasta ahora. Si queremos que
los usuarios puedan decir, obtener el valor de la raza, pero no establecer el valor que
queremos que se lea sólo entonces. Si tenemos una propiedad
como esta, por ejemplo, que expone aquí este campo
privado, entonces simplemente simplemente
eliminaríamos esta
cláusula set aquí mismo Cuando intentamos realmente poner
información en la raza, no
va a letras. Entonces si me voy de raza canina y
luego trato de darle un valor, realmente no importa
lo que
pongamos aquí. Tenemos un error. Si pasamos por encima de
eso, dice que
no se le puede
asignar, es de sólo lectura Ese es un ejemplo
de cómo hacer decir, una propiedad leída sólo en C Sharp. Pero espera. Al inicio
del tutorial, hablabas de campos y variables y
cosas así. ¿Cómo lo hago usando
la palabra clave de solo lectura? Bueno, vamos a echar un vistazo. Volvamos a
la clase de perros. Ahora lo que voy a hacer es
usar la palabra clave de solo lectura. Voy a deshacer
estos cambios y volver a
poner esta cláusula set aquí. Entonces ahora estamos estableciendo el valor, pero ahora voy a marcar
este campo aquí como leído. Sólo una vez que lo he hecho, puede ver que se
ha producido un error aquí. En realidad ya no me deja
usar la cláusula set. Si paso el cursor sobre
eso, dice que
no se puede asignar un campo de solo lectura, entonces aquí hay una pequeña
condición, excepto en un constructor podemos asignarlo dentro de
un constructor como aquí y excepto que solo setter del tipo en el que se define
el campo o
un inicializador de variables ¿Qué significa todo eso? Básicamente es decir que cuando
usas la palabra clave de solo lectura, puedes definirla una vez. Por ejemplo, podríamos
definirlo aquí e inicializarlo aquí Digamos que cada perro nuevo
es un Chihuahua, por ejemplo. No es ningún problema en absoluto. En realidad lo estamos configurando, pero lo estamos haciendo
cuando lo declaramos. Declaramos la variable aquí, pero también la estamos inicializando
que está permitido La otra cosa que también
podemos hacer es configurarlo dentro de un constructor
como dentro de perro. Y podemos hacer esto
varias veces. Siempre y cuando esté dentro de un
constructor, está bien. Podemos hacerlo mil
veces si queremos, pero no podemos poner esto dentro, por
ejemplo, esta propiedad aquí. No podemos decir, crear un método
completamente nuevo y
configurarlo aquí, por ejemplo. Esto no va a funcionar. Usted ve el punto aquí. Incluso si accedemos a esto
desde fuera de nuestra clase, solo
hago esta minúscula. Ahora para acceder al campo, se
puede ver que no se
le puede asignar a aceptar
un constructor. Entonces ese es el poder de
la palabra clave de solo lectura. Y hay un
par de razones por las que podría querer usarlos cuando se trabaja con tipos de datos
inmutables como la palabra clave de solo lectura Quieres usar estos para cosas que tal vez quieras
configurar una vez, pero entonces nunca querrás
modificar el valor de esto. Esto se debe a que, por ejemplo, si genero un ID de
perro único, por ejemplo, solo
hago esto una vez, pero luego no quiero que
este ID cambie porque
cada perro tiene un
ID único asociado a él. Si empiezo a cambiar las
identificaciones de los perros, entonces por ejemplo, si tenemos un poco de
software que rastrea a los perros, ya
conoces a los perros
que llevan el collar. Y si el perro se pierde, así pueden escanear el
collar o el microchip Y luego usa el ID de
eso para hacer referencia tal vez una base de datos y averiguar dónde está el dueño
del perro. Quizás, no hagas que esto sea
leído solo entonces podríamos tener una propiedad o alguien llame a esta aplicación podría cambiar
accidentalmente el ID, lo que podría ser desastroso Es por ello que generalmente se utilizan
tipos de datos inmutables. Queremos evitar que
otros desarrolladores, o incluso usuarios del software, modifiquen estos valores. Pero para algo así como un ID, donde generamos un ID único
para cada perro en nuestro sistema, es muy importante que hagamos campos como estos de solo lectura. Entonces realmente depende completamente de tu sistema
lo que quieras hacer. Pero es muy buena
práctica decir, si tienes variables o campos
que no quieres que
los usuarios modifiquen, entonces siempre haz que éstas sean
leídas solo por ejemplo. Entonces esa es una forma en la que
podrías manejar este problema. Otra condición que tiene que ver
con la palabra clave de solo lectura, por ejemplo,
solo se puede usar en campos. Ahora recuerden, los campos son los
que se definen en las clases, justo debajo de la declaración de
clase. Si entro en mi programa principal A aquí y lo uso dentro de un método. Si defino esto
dentro de un método, obviamente quitando privado, entonces puedes ver que
hay un problema. Si coloco el cursor sobre
él, dice que el modificador de
solo lectura no es válido para este artículo Eso es básicamente decir, bien, no se
puede usar la palabra clave
read only dentro de un método, pero podemos usarla
a nivel de clase. Por ejemplo, podemos usarlo aquí y no es ningún problema en absoluto. Eso va a funcionar bien. Pero no podemos usar
esto dentro de los métodos. Hay una palabra clave diferente que quizás
podríamos usar para eso, y esa es la palabra clave constante que también
hablaremos. Lo último de lo que quiero
hablar que ver con
solo lectura es cuando
podemos establecer el valor. Podemos establecer el valor
en tiempo de compilación, lo que significa que podemos
darle un valor en nuestro modo de desarrollo cuando
el software compila, es
decir, cuando se realiza la comprobación Le puedo dar un valor al rojo, aquí, puedo decir Chihuahua y no
hay problema. Esto es en tiempo de compilación. Nuevamente, dentro del constructor, estamos estableciendo este valor. Sin embargo, también podemos
cambiar el valor en tiempo de ejecución cuando se ejecuta el
software. Sin embargo, también podemos inicializar un campo de solo lectura durante el tiempo de
ejecución cuando nuestro software
se está ejecutando realmente Cuando construimos este objeto
perro aquí mismo, se llama
al constructor y luego se ejecuta esta línea
de código. Y esto sucede durante el tiempo de
ejecución cuando nuestro
software se está ejecutando. Si ejecuto el software, puedes ver que establece ese
valor en el constructor. No hay errores
y no hay problema. Podemos establecer un campo de solo lectura en tiempo de
compilación y en
tiempo de ejecución, dos lugares diferentes. Pero esa es la palabra clave de
solo lectura en C Sharp y por qué deberías usarla
y también cómo puedes usarla.
61. 13-2. Palabra clave const: Voy a estar hablando la palabra clave constante en C sharp. Se ve algo
así. ¿Qué es esto? Bueno, la palabra clave constante es otro tipo de datos inmutable Si viste mi tutorial
sobre la palabra clave de solo lectura, entonces entender
la palabra clave constante va a ser mucho más fácil. En este tutorial,
voy a estar explicando la palabra clave constante, pero también demostraré
las diferencias entre constante
y solo lectura ya mucha gente se
confunde entre las dos y cuáles
deben usar y cuándo. Echemos un vistazo a
la palabra clave constante. Ahora lo que voy a hacer es
usar el ejemplo anterior. Esto ayudará a ilustrar mucho mejor
la diferencia. Entonces aquí tengo mi clase de perro para cualquiera que no haya visto
el último tutorial. Tengo dos campos aquí, un constructor que los
configura y una propiedad aquí mismo que solo obtiene el valor
de la raza. Entonces es una clase de perros sencilla. Lo que voy a hacer es modificar aquí
este campo privado, que actualmente es de solo lectura, y cambiarlo en una constante. Entonces voy a demostrar el comportamiento y las
diferencias en este caso. Así que recuerda con un campo de
solo lectura aquí mismo, en realidad
podemos
establecer el valor de un constructor y también
podemos inicializarlo Permítanme cambiar esto
en una constante ahora. Ahora puedes ver que ha aparecido un
error. Si coloco el cursor sobre el
error aquí mismo, es decir que un tipo Guid no puede
declararse como una constante Ciertos tipos de datos
no pueden ser constantes. Eso es un problema. Bien, hagamos de
nuestro ID un entero. En cambio, tendremos algún sistema que genere un
entero único para cada perro único. Bien, no hay problema.
Usaremos un tipo de datos diferente. Ahora hay otro problema. Si coloco el cursor sobre
esto, puede ver un campo constante requiere que se proporcione
un valor Básicamente, eso significa que cuando
declaras una constante
como la estamos haciendo aquí, tienes que inicializarla, tienes que darle un valor
todo en una línea aquí mismo De lo contrario, no es posible. Cuando declaramos
algo como una constante, tenemos que darle un valor. Digamos que 456, por ejemplo. Ahora hay otro
problema aquí abajo. Si haror sobre eso, ya pueden ver, bueno el
mensaje de error no es muy claro Pero básicamente una vez que declaras una constante e inicializas
un valor en ella, entonces ya no
podrás modificar este campo o variable
desde ningún otro lugar No en un constructor. No se puede modificar
desde una propiedad. No se puede modificar
este valor desde fuera de la clase
en ningún otro lugar. Una vez que se ha
establecido e inicializado una constante, lo que ambos tienen que
hacer en una línea, no se
puede modificar este valor Entonces piensa en la palabra clave constante como más como una lectura más fuerte solo con muchas más limitaciones en cuanto a modificar tus datos. Esta es una gran diferencia aquí para algo así como
generar un ID único para un perro, leer solo como una buena
palabra clave para esto, porque podemos
inicializarla desde el constructor Sin embargo, generar un ID único para un perro con una palabra clave
constante, esta sería una muy
mala manera de manejar esta situación porque const no
sería una buena manera de
representar esto Quizás te estés preguntando, bueno,
¿para qué puedo usar const? ¿Cuál es un buen ejemplo del
uso de esta palabra clave constante? Parece bastante limitante y
parece que en
realidad no puedo hacer mucho con ello. Bueno, por ejemplo,
digamos que trabajamos con I. Cuando digo pastel, no me
refiero a un pastel de manzana. Quiero decir pastel R cuadrado 3.1 419. Creo que se accede a pie
en la clase estática de matemáticas. Hemos mirado la clase estática de
matemáticas antes cuando trabajamos con
números anteriormente. Y hay muchas cosas
que puedes hacer aquí. Pero se puede ver aquí, hay uno que se llama pastel. Si pongo el cursor sobre eso, se puede ver que el pastel es una
constante, 3.1 4159 Yo estaba cerca, estaba cerca. El pastel es una constante. Y eso es porque el
pastel no cambia. Pie es siempre 3.14 159265. Simplemente es ese valor. No hay razón por la
que pueda pensar dónde quisiéramos
modificar el valor de pi, porque pi es lo que es. Pi es pi. Es la relación del radio con
la circunferencia. Ahora bien, no soy matemático, pero ojalá ponga
el punto a través que nunca
necesitarías modificar pi porque es un valor establecido Este es un muy buen ejemplo
de usar una constante. En este caso, pi es constante. No modificas pi.
Es lo que es. Y cuando lo intentas, puedes
ver que aquí hay un problema. Entonces pi es un muy buen ejemplo de dónde
usarías una constante, porque este valor, una vez establecido, nunca
se cambia y
hay muchos de ellos. Mira, ahí
hay pi y toalla. Nunca he oído hablar de toalla, pero oh, tiene que
ver con el resplandor. Bien. Aquí, un recuerdo lejano
de una lección de matemáticas muy temprana. Entonces puedes ver que este es el
punto de usar constante. Es donde nunca
querrías cambiar el valor. Y una vez que se establece,
se establece ahora constante, Usted establece esto en
tiempo de compilación, no tiempo de ejecución. Cuando su aplicación
se está ejecutando constante, las variables o campos necesitan valores. Puede eliminar el valor, ejecutar la aplicación y asignarla mientras se ejecuta el
software. Esto sólo ocurre
en Tiempo de compilación. Otra cosa con constante, a diferencia de solo
lectura solo lectura la usas en campos privados de clases como
explicamos anteriormente. Sin embargo, con Constant
podemos usar estos como
campos privados de la clase, pero también podemos
usarlos dentro de los métodos. Por ejemplo, puedo simplemente declarar una variable aquí la llamo ID, le
doy el valor,
entonces puedo
usarla en el resto de
mi método aquí mismo. También podría pasarlo a otro
método, no es problema. Variables constantes,
puedes establecer y declarar e inicializar y
luego pasarlas alrededor de métodos, no
es ningún problema en absoluto Sin embargo, si esto se leyó solo
como
lo mostramos anteriormente, no es posible porque
solo lectura está restringido
a campos privados. Otra cosa que voy a mencionar sobre la palabra clave
constant es que es implícitamente
estática por defecto Básicamente eso significa
que es estático por defecto. Si ves mi tutorial
anterior donde
hablamos de la palabra clave
static, recordarás que
static es un nivel de clase Aquí es donde creamos
una nueva instancia de perro. Luego usando la instancia
que hemos creado, podemos acceder a nivel de instancia, campos, métodos, propiedades. Pero cuando accedemos a
las cosas a nivel de clase, usamos el nombre de la clase, luego accedemos a cualquier cosa
a nivel de clase. Las cosas a
nivel de clase son estáticas, Al
igual que la constante aquí. Lo que voy a hacer,
voy a hacer pública
esta identificación constante. Eso significa que podemos acceder a él
desde fuera de la clase. Vuelvo
aquí afuera, me pongo un punto. Ahora puedes ver la identificación está aquí. Esto se debe a
que los campos que están marcados como constantes son implícitamente
estáticos, estáticos Si utilizo DG la instancia
a nivel de instancia, verá que el ID no está aquí. No está aquí en absoluto. Pero a nivel de clase,
aquí es donde vive. Esto se debe a
que cualquier cosa definida
como constante es implícitamente estática Está disponible a nivel de clase. Se puede ver que no es estático
en absoluto, es solo constante. Eso es porque esto tiene un
valor y no establecería. No podemos modificarlo. ¿Por qué querríamos que
cada instancia tuviera un poco de área en la memoria
donde se define este ID? Realmente no tiene sentido. Si tienes 1,000
perros en tu sistema, entonces parte de tu memoria
tendrá que estar disponible para agregar esta identificación constante para cada
perro en tu software. Ahora bien, esto no tiene sentido
porque una vez que está establecido, está establecido, eso es todo. Entonces tiene sentido realmente
tener esto
a disposición de la clase. Entonces, si tenemos 1,000
instancias de perro en nuestro sistema, no
tenemos 1,000 copias de una variable que
no se pueda modificar. Entonces esa es la
razón
de esto y tiene sentido cuando lo
piensas de esa manera. Eso es realmente un poco difícil que
ver con campos constantes, es que están a nivel de clase Espero que en este tutorial haya resaltado lo que hace la palabra clave
constante, lo que significa, y lo que es
más importante, la diferencia entre constantes y leer solo en C sharp
62. 14-1. Memoria de pila y pila: Al desarrollar
aplicaciones con C Sharp y Visual Studio, y estás creando cosas
como variables como enteros,
boolenes, tal vez
instancias de clases, objetos, matrices y
cosas así Es importante
entender lo que está pasando con los que están
en la memoria de la computadora. ¿Y si te dijera esto? Dependiendo del
tipo de datos que elija para sus variables determina dónde y cómo se
almacena en la memoria. ¿Qué quiero decir con eso? Si usa una
variable entera o una variable bolen, o una doble por ejemplo, entonces estas se
almacenan y se accede manera
muy diferente a
diferentes tipos de datos Y cuando digo
diferentes tipos de datos, me refiero a cosas como cadenas, matrices y objetos personalizados. Pero, ¿por qué es eso importante? Bueno, hay un par
de razones por las que quizás quieras aprender sobre la memoria de
pila y montón Uno, para el rendimiento, tu
aplicación puede ejecutarse y funcionar mucho más rápido cuando
entiendes estos conceptos. Pero no solo eso, sino que si te dijera que, por ejemplo, si pasas un objeto
a un método, potencialmente
podrías perder datos o sobrescribir los datos existentes ¿Qué pensarías de eso? Ahora bien, estas son dos
de las muchas razones para aprender sobre la memoria de pila
y montón, y este es el propósito de
este tutorial en este momento Ahora por experiencia,
y créeme, tu desarrollador promedio
no tendrá mucho conocimiento sobre lo que está sucediendo en la
memoria con estas variables. No obstante, el solo hecho de tener un
poquito de conocimiento sobre esto te permitirá
destacar del resto de ellos. Entonces hablemos de
memoria de pila por un momento. La arquitectura de la memoria de
pila es como una pila de pizzas
o algo así. Sigues agregando
pizzas a la pila, una encima de otra, y luego
las quitas secuencialmente. Entonces el de arriba primero, seguido del
siguiente no se puede acceder, por
ejemplo, pizzas
en pedidos aleatorios. Se tiene que añadir a la pila. Así se agrega a la pila de pizzas
o se retira de la parte superior. Entonces así es como funciona
la memoria de pila. Es secuencial, así que agregas cosas a la parte superior y
eliminas de la parte superior, mantenemos
artículos de corta duración en la pila. Ahora, ¿qué es un artículo de corta duración? Bueno, a estos generalmente se
les llama tipos de valor. Cosas como enteros, Boo
inclina personajes, flotadores, dobles, cosas que
son un poco rápidas, cosas
simples que se
consideran no complejas Tipos de datos simples como esos, no cosas como objetos complejos. Y cuando almacenamos cosas en la memoria de
pila, se
recuperan rápidamente. Es un área de memoria muy rápida, solo por la forma en que se
articula secuencialmente. Ahora bien, el área de montón de
memoria es bastante diferente. Imagínate esa pila de pizzas, pero en lugar de una bonita pila
organizada, tíralas todas al piso, así que hay pizzas
por todas partes en memoria de montón, no
hay pedido de los
artículos en la memoria per se Sin embargo, debido a la disposición
natural de los elementos en el montón, la
recuperación de la memoria es más lenta porque el proceso es más complicado
al acceder a los datos Por lo tanto, se considera
más lento que la memoria de pila. Generalmente, mantienes artículos de
larga duración en el montón, objetos tan complejos, pero también cosas que
estarán disponibles durante mucho tiempo,
durante una larga duración de la
ejecución de tu aplicación, mientras que las cosas en la pila se
considerarían de corta Entonces tal vez un cálculo rápido
como cuatro más cuatro, por
ejemplo, ¿qué tipo de tipos de datos y elementos se almacenan en el
área de montón de memoria Son cosas como
objetos, clases. Cuando instanciamos una clase,
las cadenas, las cadenas
pueden ser elementos enormes,
matrices, cualquier cosa
que sea global, disponible
globalmente en toda
su aplicación Por ejemplo, aunque un entero simple se
considere un tipo de valor. Sin embargo, si hiciste esto global como estático o
algo así, y está disponible para
todas las clases del sistema, entonces aquí es donde cambian
las reglas. Esto se almacenaría en
el área de la memoria del montón porque necesita estar
disponible por más tiempo, por lo que los artículos de larga duración en el montón Cosas como cadenas, clases, como todos se consideran tipos de
referencia,
esa es la palabra clave. Es posible que escuche mucho en el
futuro cuando cree un nuevo tipo de referencia que se almacena en el
área de montón de memoria Lo que también sucede
es que algo llamado puntero se
crea en la pila. Entonces, lo que sucede
es que el puntero en la pila apunta a un área de la memoria de montón donde viven
sus datos de objeto Cuando crea un tipo de referencia como una matriz, por ejemplo, se agrega
un puntero
a la pila y la carne real de la
operación se agrega al montón La pieza de información en
la pila más o menos dice, bien, puedes encontrarla aquí mismo en esta
ubicación de memoria en el montón Eso es lo único
que se agrega a la pila cuando se
crea un tipo de referencia, como algo complicado,
como una matriz, por ejemplo. Aquí es de donde
viene el tipo de referencia de
nombre porque nos estamos refiriendo de la pila
al montón donde vive el enlatador de
datos Y es por esto que cosas como
enteros, Boulen, shahs, tipos
simples se llaman tipos de valor porque el valor
se almacena directamente en el área de
pila de la Ahora aprecio que esto sea bastante para
entender y asimilar, pero no te
preocupes por entender cada cosa que he
esbozado en este tutorial. La principal conclusión es
conocer y comprender que ciertos tipos de datos se almacenan en el
área de pila de la memoria. Y el área de pila de la memoria tiene sus propias características
y beneficios, y otros tipos de datos se
almacenan en el montón, nuevamente, con sus propias características
y cosas así En el siguiente par de tutoriales, estaré usando algunos ejemplos para que puedas
entender esto más a fondo. Así que no te preocupes por entender
todo ahora mismo, pero ahora mismo
voy a hablar algo llamado desbordamiento
de pila. Ahora, es posible que haya oído hablar
del desbordamiento de la pila del sitio web, o tal vez haya escuchado
del término antes. Realmente no importa si
has oído hablar de él o no, pero lo que vamos
a hacer es
provocar intencionalmente un
desbordamiento de pila en C Sharp. Y creo que será
un ejemplo bastante divertido de simular, porque puedo mostrarles que memoria de
pila tiene limitación de
tamaño. Y es por ello que en el montón
se almacenan objetos grandes y
complicados en el montón
se almacenan Entonces intentemos desbordar
el área de pila de la memoria. Ahora con un ejemplo rápido. Estoy por aquí en Visual Studio. Ahora tengo una aplicación muy
sencilla desde el método principal. Aquí estamos llamando a
un método de desbordamiento. Y el método overflow es simplemente escribir hola a
la ventana de la consola. Entonces no está pasando mucho aquí. Ahora una manera fácil de causar un desbordamiento de pila es
tener un método llamado a sí mismo. Quizás te estés haciendo
la siguiente pregunta, ¿cómo causa esto
un desbordamiento de pila? No estoy definiendo ningún entero,
booleanos, nada ¿Qué es lo que realmente está
desbordando la pila? Bueno, cuando llamas a un método, la referencia del método
también se agrega a la pila. Este es otro ejemplo
de memoria de pila. Así podemos lograr un
desbordamiento de pila así también. De igual manera, podemos crear
algunos millones de variables, los enteros, quizás
eso también funcionaría A lo mejor hay muchas
maneras de lograr esto, pero este es un ejemplo rápido de una manera muy fácil de hacerlo. Entonces voy a ejecutar
la aplicación ahora y vamos
a ver qué pasa. Ejecuto la aplicación
, prácticamente se bloquea. Dice en visual studio, excepción de desbordamiento de
pila. Cuando miro aquí la ventana de la
consola, se
puede ver que dice desbordamiento de
pila repetido 24,109 veces antes de que la pila esté completamente llena y empiece a
desbordarse Si miramos este diagrama aquí, puedes ver cómo crecen la memoria de pila
y montón,
pero la memoria de pila es limitada El punto de la
memoria de pila es almacenar valores
reales para
tipos de datos como enteros. Realmente
almacenará, por ejemplo, 15 en la pila, lugar de si tenemos un tipo de
referencia grande como una matriz, entonces esto se almacena
en el montón porque estos pueden crecer muy, muy grandes Sin embargo, con el área
de pila de la memoria, es limitada. Es finito. Sólo puedes poner
tanta información aquí. Y como puedes ver aquí, podemos almacenar una referencia a
nuestro método llamar 24,109 veces Entonces así de limitado es y por eso
no todo se almacena en la pila. Sí, la pila es rápida, pero su espacio es limitado. El montón es más lento, pero es mucho más grande Entonces ves estos pros
y contras de cada uno, y es por eso que
ambos existen y también por qué es importante
entender ambos. Entonces quiero
hablar de una cosa más, y esa es la pila de llamadas. ¿Qué es la pila de llamadas? Si vuelvo a visual
studio aquí y me desplazo hacia abajo, se
puede ver que
aquí hay
una pequeña ventana llamada pila. Si no ves esta ventana, entonces sube a la parte superior, ve a bug, luego windows, y luego call stack. Y esto debería aparecer en
la parte inferior justo aquí. Lo que hace la pila de llamadas, te da una
representación visual de tus
llamadas a método, por ejemplo. Entonces puedes ver aquí
empezamos con el método principal. Aquí llamamos desbordamiento, y repetimos esto 24,106 veces antes de
terminar finalmente en un desbordamiento de pila Te da una bonita representación
visual de tus llamadas a método. Y se puede ver la arquitectura
aquí es más o menos como el ejemplo de pizza del que
estaba hablando antes, siendo la primera llamada la pizza de fondo. Y estos se
agregan lentamente a la pila. Pero la razón por la que estoy hablando la pila de llamadas en este momento es
que los desarrolladores principiantes, ¿puedo confundirme un
poco entre memoria de
pila y la pila de llamadas? La pila de llamadas te da una
buena representación visual de tus llamadas a método. Pero no es memoria de pila. Esto no es lo que
ves en la memoria de pila. La pila de llamadas no te
muestra tus variables y asignaciones y
cosas así. Solo te da
como las
llamadas al método mientras están
vagamente relacionadas, la pila de llamadas
no es memoria de pila Puedo ilustrar eso ahora con un mejor ejemplo
de la pila de llamadas. Echa un vistazo a
este ejemplo aquí. Es bastante sencillo. El
método principal aquí llama al método uno. El método uno llama al método 22, llama a 33 llama a cuatro. Por último, en cuatro, solo
saludamos a la ventana de la consola. Es muy sencillo, pero este
ejemplo te mostrará cómo funciona
la pila de llamadas y cómo estas referencias de métodos
se agregan a la memoria de pila. Básicamente, la arquitectura de la
pila, la arquitectura de la pizza. Echemos un vistazo a un ejemplo. Ahora mismo, he añadido un punto de quiebre aquí en
la primera línea. Así que vamos a
entrar en modo break tan pronto como esto sea golpeado. Entonces voy a compilar y
ejecutar la aplicación ahora, ahora estamos en modo break aquí. Si acabo de abrir esta ventana
con la pila de llamadas, puede ver que se ha
agregado un elemento a la
pila de llamadas que es principal. Ahora voy a meterme en esto presionando 11 en el teclado. Ahora puedes ver que estoy
dentro del método uno. Ahora esto se ha agregado
a la pila de llamadas aquí. Esta es nuestra primera
pizza en nuestra pila. Esta es nuestra segunda pizza. Ahora, voy a
presionar F 11 otra vez. Ahora tenemos nuestra
tercera pizza encima. Voy a volver a
meterme en esto. Tenemos nuestra cuarta pizza. Se puede ver cómo funciona esto. Entonces, la pila de llamadas te brinda
una buena representación visual de dónde te encuentras en tu aplicación durante
una sesión de depuración También es semi interactivo. Puedes hacer doble clic en estos y
podrás ver dónde estás, desde
dónde
se llamó a este método, lo cual es realmente útil cuando
tienes múltiples archivos, soluciones, proyectos,
cosas así. Puede navegar directamente a donde se llamó a
esto. Pero esta es una
representación similar a cómo funciona la memoria de pila. Aquí tenemos nuestro primer valor, luego se apilan, y luego los hacen
estallar en orden así No se puede
acceder al azar. Entonces es como primero
en entrar, primero en salir, que es la terminología ahí, memoria de
pila y la pila de llamadas usan la arquitectura de pila. Y si bien están relacionados, no son exactamente
lo mismo. Espero que eso tenga sentido. Ahora bien, si luego voy al método cuatro, se
puede ver que es el último agregado a la pila de llamadas. Y luego paso por encima de eso, y ahora se puede ver que
poco a poco van saliendo de la pila El método tres
será el siguiente en
estallar porque
apenas estamos saliendo de ahí. Después dos, luego uno. Ahora estamos de vuelta en
el método principal. Puedes ver que es el último elemento queda en la pila de llamadas. Entonces eso es lo que es la pila
central,
y eso es también lo que es la arquitectura de
pila. Y verás la arquitectura
stack en muchos lenguajes de
programación diferentes, pero tampoco se limita
a la programación. Una última cosa de la que voy a
hablar es una palabra clave que
quizás oigas en el futuro
llamada recolección de basura. Entonces, ¿qué es la recolección de basura? Bueno, cuando hablé crear
tipos de referencia, por ejemplo, cosas que se almacenan en
el área de montón de memoria, como clases,
instancias de clases, cadenas, matrices, y
cosas así También dije que se crea un
puntero en la pila y esto apunta a
la información sobre el montón Es como un puntero.
Lo que puede suceder es el puntero se elimina
del área de pila de la memoria, pero los datos reales se
dejan atrás en el montón Ahora, nuestra aplicación ya
no tiene idea de dónde está esta
información. A lo mejor ya ni siquiera
necesita los datos. Pero aún podría existir en
el área del montón de la memoria. Pero debido a que el
puntero ya no le está apuntando en el área de
pila de la memoria, estos datos en el
montón son inútiles No se puede usar, no
se puede encontrar. Simplemente puede llenar tu memoria hasta que no
quede ningún recuerdo. Este es un problema bastante grande. Esto generalmente se conoce
como una fuga de memoria. Entonces hay algo
llamado recolección de basura que en realidad
pasa por el montón Área de memoria, funciona si hay un puntero apuntando
a ella en la pila, y si no,
elimina, libera la memoria Y esto es lo que hace la
recolección de basura. Y en un lenguaje como C shop, no
tienes que
preocuparte por la recolección de basura. Pero pensé que
sería un
poco interesante para contarte. Pero si trabajas con
otros idiomas, tal vez como C plus plus, entonces sí necesitas
preocuparte por la recolección de basura. Entonces tal vez sea
algo a considerar, pero es agradable saberlo. Y cuando tu aplicación
se cierra o termina, entonces generalmente la
memoria se libera.
63. 14-2. Parámetros de método - Pasando por valor: Antes de ver este tutorial, te
recomiendo que veas el tutorial anterior sobre memoria de
pila y montón De lo contrario, esto podría no
tener mucho sentido a menos que esté familiarizado
con la memoria de pila y montón Ahora echemos un
vistazo a este ejemplo. Aquí estamos
viendo algún método pasando ahora algunos
parámetros a un método. Entonces vamos a
modificar algunos valores. Basta con considerar este ejemplo
aquí. Es bastante sencillo. En el método principal de
la aplicación aquí, estoy definiendo aquí dos variables
de tipo de valor. Ahora estos se almacenan
en la pila, el área de pila de la memoria,
son tipos de valor. Entonces estoy sacando los valores para estas variables a
la ventana de la consola Entonces estoy llamando a un
método llamado reset. Y estoy pasando ambas variables de tipo de valor
a este método aquí mismo, estoy reiniciando estas
variables que se están
pasando a cero y luego estoy sacando a
la ventana de la consola Una vez finalizado el método, control de
ejecución se vuelve a
pasar aquí arriba. Y luego vuelvo a dar salida a los valores de estas
variables. Y luego mantengo abierta la ventana de la
consola. Pregunta, ¿cuál
crees que sería el resultado? Bueno, echemos un vistazo a
cuál es realmente la salida. Ahora voy a ejecutar
el programa. El valor de num uno es el
valor de num dos es cuatro. Y entonces el valor dentro del método es cero porque los
estamos reiniciando. Y entonces después de que se ejecute el método 6.4 ¿es eso lo que esperabas? Quizá así, pero ahora
miren este otro ejemplo. Echemos un vistazo a
este ejemplo aquí. Es muy similar
al ejemplo anterior, pero en lugar de usar un tipo de
valor simple como un entero, estamos usando un tipo de referencia. Y los tipos de referencia, como
hablamos antes, se almacenan en el
área de montón de la memoria, y un puntero a esos datos
se almacena en la pila Lo que estamos haciendo,
estamos instanciando
un objeto de videojuego Si voy a la clase de videojuegos, se
puede ver que es bastante sencillo. Tiene un
campo privado aquí llamado título y una
propiedad pública llamada título, que controla la obtención y
configuración de este campo aquí. Muy sencillo. Aquí estamos estableciendo
el título para el
videojuego, un World of Warcraft, y luego
lo estamos sacando a la ventana Estamos obteniendo el título
antes de que se llame a un método. Ahora estamos cambiando
el título aquí. En este método, toma un objeto de videojuego y luego estamos sacando
algo a la ventana Lo estamos sacando a la
ventana dentro del método. Pero antes de cambiar el título del juego dentro de este método, estamos cambiando el título del juego para cambiar algo diferente. Entonces, una vez que el método
haya terminado de ejecutarse, volvemos a sacar el título del
juego Ahora, ¿qué crees que
va a pasar esta vez? Bien, echemos un
vistazo al resultado. Si ejecuto la aplicación, puedes ver aquí el título del juego antes de que el método sea
World of Warcraft El título del juego dentro del
método es World of Warcraft. Recuerda dentro del método, esto es antes de que se haya producido el
cambio, pero después de que el método
haya terminado de
ejecutarse, volvemos a Maine
y sacamos esto. Aquí sin embargo, puedes
ver que está conservando el valor
al que lo cambiamos dentro del
método. ¿Por qué es esto? ¿Por qué
persisten estos cambios a partir de los cambios dentro de los métodos para los
tipos de referencia pero no los tipos de valor ¿Qué está pasando aquí? Bueno, permíteme explicarte. Estoy volviendo
al ejemplo anterior ahora donde teníamos dos tipos de valores
simples aquí, dos enteros, y
los pasamos a un método aquí Ahora en C Sharp, al
pasar objetos, ya sean tipos de valor o tipos de
referencia como
parámetros a métodos, por defecto, estos
se pasan como valor. Se pasan por valor, a menos que se indique explícitamente, deben
pasarse por referencia. Vamos a hablar de
pasar por referencia más adelante. Pero considere el valor por defecto que se está pasando por valor aquí. ¿Qué significa pasar por valor? Bueno, por defecto, cuando llamas a un método y pasas aquí estos
dos parámetros, se crea
una copia, una copia de
estos datos. Aquí tenemos un valor de seis en el número uno y un valor
de cuatro en el número dos. Estamos llamando a este método aquí. Dentro de este método, recibe una copia de
estas variables. No está apuntando a la misma
zona que la memoria de éstas. Estos son literalmente copiados. Entonces el método
realmente funciona con una copia duplicada de
estas variables. Esto es lo que significa al
ser pasado por valor. Cualquier trabajo que hagamos
dentro de este método aquí se realiza con una copia
de estas variables. Y cuando el método ha terminado ejecutar y aquí
se devuelve el control, perdemos todo dentro de
aquí porque esta es una copia duplicada y solo
existe dentro del método. Una vez terminado el método, no
tenemos conocimiento
de esto a menos que devolvamos específicamente
algo de aquí. Ese es un ejemplo de
pasar un tipo de valor a un método y está
siendo pasado por valor, no
afecta nada
fuera del método. Volviendo a nuestro otro
ejemplo aquí donde cambiamos el nombre
del objeto del videojuego. Si estoy pasando datos por valor, entonces ¿por qué
persiste este cambio fuera del método Seguramente esto no tiene sentido. Bueno, esto es porque
estamos pasando un tipo de referencia por valor. Como dije, cuando
pasas parámetros a métodos por defecto
es por valor. Sin embargo, estamos pasando
un tipo de referencia. Recuerda antes
hablábamos de tipos de referencia, que son objetos complicados. Pueden ser arrays, listas, todas las cosas así. Y esto se almacena
en el área
de montón de la memoria, pero como dije, hay un puntero que se
almacena en el área
de pila de la memoria que apunta a
estos datos en el montón Cuando se llama a este método, sí, se copia al método, pero no
se copia la memoria de montón Sólo se copia
el puntero de la pila. Ahora bien, esto parece
contraintuitivo realmente porque, sí, estamos pasando este objeto de
referencia por valor. Sin embargo, debido a que es
un objeto de referencia, solo
estamos simplemente copiando el
puntero dentro de este método. Aquí estamos trabajando con una copia del puntero que se
almacena en la memoria de pila. No obstante, todavía apunta a la misma área de
memoria en el montón En este método principal, estamos apuntando al área
de memoria en el montón, pero también dentro de este método A pesar de que estamos trabajando con una copia del puntero
en la pila, sigue apuntando a esa
área de memoria en el montón Es por ello que el título sigue cambiando porque a pesar que
estamos trabajando con una
copia del puntero, todavía apunta a esa
misma área de memoria. Es por ello que el título sigue
cambiando dentro del método. Y podemos ver aquí, una vez que se ha llamado
al método, los cambios aún persistieron
después de la ejecución del método Aquí, aprecio que esto
sea bastante para asimilar, pero si miras
el tutorial anterior y también este un
par de veces más, lo
entenderás
y lo vas a conseguir,
lo prometo cuando dije una copia del puntero se
pasa a este método aquí, por ejemplo, si ahora trabajo
con esta copia del puntero. Entonces este juego de aquí, puedo inicializar un nuevo
objeto, una nueva instancia Lo que eso hace, asigna
una nueva área de memoria. Aquí, estoy trabajando con la copia del
puntero aquí mismo, pero estoy diciendo, bien, ahora crea un nuevo objeto en
esta copia del puntero. Entonces, qué va a hacer
esto, esto va a funcionar con una copia
completamente nueva de los datos
y poner esto en el montón Lo que estamos haciendo aquí, una vez que se ha llamado
el método, estamos dando salida al título del
juego aquí De hecho, pongamos esto aquí. Ahora tenemos una nueva
instancia de juego. Estamos estableciendo el título de
esta nueva instancia en cambiado, y luego lo estamos emitiendo. Y todavía estamos sacando el título después del método aquí ¿Qué crees que
va a pasar ahora? Bueno, vamos a echar un vistazo.
Vamos a ejecutar el programa. Se puede ver ahora algo ligeramente diferente que ha sucedido. Tenemos nuestro
título original al inicio aquí. Después dentro del método,
se ha cambiado. No obstante, después del
método ahora todavía conservaba su
título original de antes. ¿Por qué es esto lo que
está pasando aquí? Como mencioné, este
es un tipo de referencia. Por defecto, se pasa
por valor dentro del método. Tenemos una copia de este puntero de tipos de
referencia, que se encuentra en la memoria de pila. Ahora le estamos dando una
nueva ubicación de memoria y configurando esa nueva
ubicación para que cambie. Sin embargo, fuera del método, esto no tiene conocimiento de
esta nueva ubicación de memoria. Esto sólo está dentro del método
que esto está sucediendo. Sólo dentro de este método
tiene el conocimiento de esta nueva área de memoria en el montón y
que estamos apuntando a ella Sin embargo, este cambio
no se persiste fuera
del método en lugar de trabajar con una
copia existente del puntero, lo que de nuevo,
afectará al montón Al igual que fuera de aquí, en realidad
estamos asignando
una nueva área de memoria en el montón y apuntando nuestra
copia del puntero a eso, y es por eso que esto sucede Echemos un vistazo a
un ejemplo más aquí. Nuevamente, esto va
a tener prácticamente la misma salida que nuestro tipo de referencia
anterior, que era una instancia
de un objeto de videojuego. Pero aquí tenemos otro tipo de
referencia, una lista. Nuevamente, podría ser
cualquier tipo de referencia, podría ser una matriz, podría ser un diccionario, podría ser muchas cosas
diferentes. Esto, nuevamente, se almacena
en la memoria de montón. Una lista con cuatro enteros, estamos emitiendo el
conteo de la lista, y luego estamos pasando
la lista a este método Ahora, por defecto se
pasa como valor, pero este es un tipo de referencia. Una copia del puntero se
copia al método. Ahora el método puede funcionar con
una copia del puntero que apunta convenientemente
a la misma área en la memoria de montón
que esta. Fuera del método. Luego estamos agregando dos
números a la lista, luego emitiendo el recuento de listas Una vez finalizado el método, estamos emitiendo de nuevo el recuento
de listas ¿Cuáles crees que serán
los resultados? Bueno, vamos a echar un vistazo. Se pueden ver los recuentos de 466. Eso es porque el método
es sumar dos números. Y una vez que estemos aquí afuera, está apuntando a la
misma área de memoria de montón, va a retener ese conteo Ahora en el método, si acabo de modificar la
lista ligeramente aquí. Ahora dentro del método, esta lista se está
pasando de nuevo como valor. Pero es una copia del puntero. Con la copia
del puntero y ahora apuntándolo a una
nueva área de memoria de montón, y luego agregando dos números
a esta nueva lista ¿Cuál crees que será
la salida? Ahora vamos a ejecutar el programa. Se puede ver que
tenemos de cuatro a cuatro. Puedes ver nuestra lista inicial
tiene cuatro. Eso es correcto. Dentro del método, estamos
creando una nueva lista. Sólo tiene dos números en su interior. De ahí vienen los dos. Ahora el método está terminado, todavía
tenemos acceso
a esta zona original. En memoria de montón, está
dando salida a los cuatro. Así podrás ver que funciona con todos los diferentes tipos
de tipos de referencia. Y este es el comportamiento por defecto
de los métodos en C Sharp. Entonces voy a dar el círculo
completo ahora. Al inicio del tutorial
anterior, dije, ¿por qué necesito saber sobre la memoria
stack y heap ¿Por qué es importante? Bueno, puedes ver si
no tienes ningún conocimiento de memoria
stack y heap y variables de tipo de valor
y variables de tipo de referencia, entonces pueden suceder
cosas inesperadas Las cosas inesperadas son un problema
bastante grande en el software por razones obvias. Por eso es importante, y aquí hay un ejemplo
de esto en la práctica.
64. 14-3. Parámetros de método - Pasando por referencia (palabra clave ref): La referencia, palabra clave pasando parámetros del
método por referencia. Si no has visto mis dos tutoriales
anteriores sobre este tema donde
hablamos de stack
y heap memory pero también de pasar por valor, entonces te recomiendo encarecidamente que los
veas antes de
continuar con este tutorial ya que se vinculan los conceptos descritos
en este tutorial En el tutorial anterior, hablamos sobre cómo diversos tipos de objetos
diferentes al ser pasados como
parámetros a métodos. Por defecto, se
pasan por valor, eso significa que se
crea una copia
del valor real o una copia del puntero una copia del puntero y el método
funciona con la copia. Ahora voy a hablar de
pasar por referencia. Ahora, pasar por referencia
no es un comportamiento predeterminado e incluye hablar de
una nueva palabra clave
llamada palabra clave ref. Entonces, ¿cómo funciona esto? Justo como un pequeño repaso aquí,
estamos configurando dos enteros,
dando salida a sus estamos configurando dos enteros,
dando salida Luego dentro de este método, los
estamos pasando como parámetros,
restablecemos los valores a cero, volviendo a generar las variables Entonces, cuando se termina el método, estamos dando salida al valor
de las variables originales Y se puede ver que los estamos
pasando por valor. El método sólo funciona
con una copia de ellos. Por lo tanto, los datos nunca se cambian una vez que el método
ha terminado de completarse. Ahora lo que voy a hacer
es cambiar esto ligeramente. Voy a pasar
estos tipos de valor. Recuerde que el tipo de valor es entero, booleano, tipos simples
almacenados en la pila Ahora voy a pasar
estos por referencia. Para pasar algo por referencia, simplemente
prefije las
variables aquí con la palabra clave ref en los parámetros del
método. Aquí hacemos lo mismo, solo
agregamos la palabra clave ref. Ahora, ¿cuál crees que será
la salida? Bueno, vamos a echar un vistazo. Entonces puedes ver que está exhibiendo el comportamiento
del tipo
de referencia del tutorial anterior. ¿Recuerdas cuando
modificamos el valor de un tipo de referencia y lo recordaba después de haber llamado al
método? Bueno, esto es lo que
se llama pasar un tipo de valor por referencia. Y podemos hacer esto
agregando la palabra clave F aquí. ¿Cuál es la ventaja de esto? Bueno, al pasar un
tipo de valor dentro de un método, ya no crea una copia
del valor, por lo que no se está creando ninguna copia. Es más o menos decir,
bien, oye método. Te voy a pasar
estas dos variables aquí, son tipos de valor,
pero quiero que te pases la referencia
a ellas en la memoria. Quiero que trabajes con estos. Y cualquier cosa que les hagas, los cambios se verán reflejados. Entonces esto es pasar
una referencia al área en
la memoria de pila
para estos tipos de valores, y ahora se están
pasando como referencia. Podemos trabajar con estos
directamente dentro del método, y cualquier cambio
que hagamos a estos
será persistido una vez que el método
termine de ejecutar Entonces pueden ver aquí los
acabo de cambiar, ahora el cambio
ha persistido. Así que puedes ver ahora entendemos el comportamiento por defecto en el último tutorial que
está pasando por valor. Es más fácil entender la otra terminología que
se está pasando por referencia, y que es usar
la palabra clave Ref. Bien, hemos visto pasar tipos de
valores como
enteros por valor Hemos visto pasar tipos de
referencia como objetos
complicados por valor. Ahora hemos analizado los tipos de
valores pasantes por referencia. Y ahora para completar
la cuadrilogía, vamos a ver pasar tipos de referencia por
referencia Aquí está el ejemplo.
Aquí tenemos nuestra lista de enteros que
vimos antes Sólo tenemos cuatro
números ahí dentro. Y luego dentro de este método, estamos agregando dos
números a la lista. Y luego afuera, solo estamos
sacando el conteo de
la lista en el camino Miramos esto antes y puedes ver aquí está
la salida aquí, porque por defecto estamos
pasando una copia del puntero, pero apunta a la misma
área en la memoria de montón Para que pueda ver que los cambios persisten una vez que este método
haya terminado de ejecutarse Pero recuerda cuando
hablamos del hecho realidad
podemos
configurar una nueva ubicación en memoria de
montón y tomar una copia de nuestro puntero y
darle una ubicación completamente nueva, y eso cambia el resultado Puedes ver aquí el cambio no
se persiste en este caso Ahora voy a calificar
esto con la palabra clave ref. Lo agrego aquí cuando
llamamos al método. Y lo agrego aquí en
los parámetros aquí. ¿Qué crees que
va a pasar ahora? Bueno, vamos a echar un vistazo. Voy a ejecutar
la aplicación. Se puede ver ahora que el
cambio realmente se ha persistido una vez que el método
ha terminado de ejecutarse ¿Por qué es esto lo que está
pasando aquí? Bueno, quizá
ya lo hayas adivinado. Cuando pasamos algo por referencia usando la palabra clave
reference, tal como
hablamos antes, ya
no creamos una copia, ya ni siquiera estamos creando una
copia del puntero. Estamos
pasando prácticamente el puntero en la memoria de
pila a estos
datos en la memoria de montón Estamos pasando el puntero
mismo al método. El método ahora está
trabajando directamente con el puntero original
a esta información. Ahora estamos configurando un objeto completamente
nuevo aquí, una nueva lista. Pero no estamos trabajando con
una copia del puntero, es el puntero original. Estamos prácticamente creando una nueva lista sobre la parte superior de la original y luego
agregándole dos números. Si ejecutamos la aplicación ahora, tal como vimos anteriormente, puedes ver aquí que se
está persistiendo. Esa es la diferencia aquí. Al usar la palabra clave ref, ya no
estamos
copiando nada. No estamos copiando
los tipos de valor, pero tampoco estamos copiando los punteros cuando
usamos tipos de referencia ¿Por qué es útil esto? Bueno, entonces nuestros métodos pueden
funcionar con nuestros datos originales, ya sean tipos de valor o
tipos de referencia, y los cambios pueden persistir una vez que el método
haya terminado de ejecutar Ese es el poder de la palabra clave
ref en tienda. Esto completa estas tres series de
tutoriales sobre
pila, memoria de pila y tipos de referencia
y valor en la tienda C.
65. 15. La palabra clave struct: En este tutorial,
voy a estar hablando de estructuras en C. Las estructuras de Sharp usan
la palabra clave struct, pero ¿qué son y
cómo funcionan? Bueno, las estructuras son
muy similares a las clases, y este tutorial
supone que sabes un poco sobre cómo funcionan las clases,
cómo funcionan la herencia,
quizás interfaces y también tipo de
valor y referencia variables de tipo de
valor y referencia y también la palabra clave de solo
lectura. He hecho tutoriales sobre
todos esos anteriormente. Si lo has visto
todo hasta ahora, comprenderás completamente este tutorial y vas
a comenzar a correr. ¿Qué es una estructura? Echemos un
vistazo a este ejemplo. Aquí mismo tengo
una clase cuadrada, echemos un vistazo a eso ahora. Tiene aquí dos campos privados, el ancho y la
altura de la plaza. Tiene un constructor que
configura esos campos. Tiene un
método de muestra aquí que simplemente calcula el área en
base a esos. Y también dos propiedades públicas aquí que exponen el
ancho y la altura. Entonces es bastante sencillo.
Entonces, lo que estoy haciendo aquí, estoy instanciando un nuevo objeto, y estoy sacando algunas cosas de
muestra a Si ejecuto la aplicación ahora, un cuadrado con altura cuatro y ancho cinco tiene un área de 20. Así que en realidad
no hace tanto. Entonces, permítanme introducir una
estructura ahora y lo que es. Entonces esto va a la clase
cuadrada aquí. Y sólo voy a modificar esta palabra clave de clase y voy a poner
estructura así. Entonces, si ves mi
tutorial sobre interfaces y enumeraciones donde creamos una clase completamente nueva y solo
modificamos la palabra clave class Es bastante similar
en ese sentido. Y ahora tenemos una estructura. Esta plaza es ahora una estructura. Ya no es una clase. Pero se puede ver que aquí
no hay errores. No hay líneas rojas onduladas. Cómo es que acabo de modificar toda
esta clase
y no hay errores. ¿La aplicación incluso se ejecuta? Bueno, parece que corre. Y tenemos exactamente
la misma respuesta, ¿qué está pasando aquí? Ahora bien, aquí es donde las estructuras y las clases confunden a
nuevos
desarrolladores o desarrolladores que
realmente
no comprenden los tipos de valor y
los tipos de referencia Las estructuras y clases pueden parecer muy similares
en cómo se comportan. Puedes ver aquí, he
hecho una estructura, Tiene campos privados, tiene un constructor,
tiene métodos, propiedades. ¿Cuál es la diferencia aquí entre una estructura y una clase? ¿Puedo simplemente usar estructuras
ahora en lugar de clases o debo ignorar las estructuras por completo
y solo usar clases? Bueno, la respuesta es
que puedes usar ambos. Una de las principales diferencias
entre estructuras y clases es que las estructuras
son tipos de valor. Ahora bien, ¿cómo funciona eso? Bueno, ya platicamos anteriormente que las clases son tipos de
referencia. Si vuelvo a poner esto aquí, cuadrado es ahora una clase. Simplemente descomento
este método aquí. Ahora bien este método aquí, estoy
pasando en la plaza, que ahora es una clase,
a este método. Y estoy modificando
algunas propiedades aquí. Ya hablé de esto anteriormente. Cuando pasas un
tipo de referencia como este de aquí, este es un tipo de referencia, vive en el área
de montón de memoria a un método, luego se pasa por referencia Eso significa que el método puede
acceder a la memoria en el montón. Funciona con el objeto
original cuando se termina el método. Aquí todavía tenemos
acceso a los cambios realizados desde dentro este método si ejecuto
esta aplicación, ahora vamos a
ver estos cambios reflejados en la salida aquí. Echemos un vistazo a
eso. Se puede ver aquí 2,020.400 para la zona Es una
variable de tipo de referencia aquí mismo. Vive en el montón.
Ahora cambiemos esto de nuevo a una estructura
y veamos qué pasa. Ahora bien esta es una estructura
que mencioné anteriormente. Las estructuras son tipos de valor
y no tipos de referencia. Estos cambios no se
reflejarán en la salida. Eso es porque el
método funciona con una copia del tipo de valor. Cualquier cosa cambió aquí, solo se refleja en la copia. Los cambios no persistirán. Vamos a ver 5.4
como lo hicimos anteriormente. Como puedes ver ahí,
esa es una de las principales diferencias
entre clases y estructuras es
que las clases son tipos de
referencia y
las estructuras son tipos de valor. Esa es una
característica principal de las estructuras. Echemos un vistazo a
algunas otras diferencias entre estructuras y clases, ya que son bastante similares y parecen operar igual. Hablemos de
las diferencias. Creo que eso te permitirá
entender mejor qué pueden hacer
las estructuras, las ventajas y también
las desventajas. Con las estructuras, no podemos
usar clases de herencia, por ejemplo, podemos
heredar de una clase base Pero cuando tratamos de hacer
eso con estructuras, y pasamos el cursor sobre esto, su forma en la
lista de interfaces no es una interfaz ¿Qué significa eso?
Bastante críptico, ¿no? Eso es porque con
las estructuras realmente se pueden
implementar interfaces. Se puede trabajar con
interfaces, No hay problema. Este error aquí, es esperar una interfaz
porque eso es prácticamente lo único en ese sentido que se puede
hacer con una estructura. Pero cuando trato de
heredar de una clase, una clase base, no
me deja hacer eso porque no
es posible Todo el concepto de herencia no
existe con las estructuras. Esa es una ventaja que una clase
tendría sobre una estructura. No podemos heredar
de una clase base, pero la estructura
misma tampoco puede ser una clase abstracta
o una clase base Y eso significa que no podemos tener métodos
virtuales, por ejemplo. Puedes ver aquí cuando
intenté hacer eso, ni siquiera
es válido, es porque está
dentro de una estructura. Entonces no podemos usar la
palabra clave virtual, lo que significa que no podemos anular, que significa que no podemos hacer
ningún comportamiento polimórfico Y recuerda, ese es el
concepto de método primordial. Por ejemplo, no
podemos usar virtual, no
podemos usar abstract. Así que no podemos
prácticamente usar nada con respecto a la herencia
o nada por el estilo. Con las estructuras, hay tipos
mucho más simples que clases, así que piénsalo de esa manera. Una estructura es más
simple que una clase. Hablemos de tal vez una
ventaja de una estructura aquí, o tal vez por qué incluso
usaríamos una. ¿Por qué siquiera molestarse? ¿Por qué no solo usamos las clases para todo? Bueno, las estructuras no tienen una huella de memoria pesada como lo haría un objeto
de tipo de referencia. Por ejemplo, tengo
un objeto de videojuego aquí mismo, clase de videojuegos. Dentro de aquí tiene campos
privados enlazando a otros
tipos de referencia como una clase de juego, una lista de enteros, algunas cadenas, una enumeración Esta es una huella bastante pesada y esto vive en el montón Por esa razón, no lo
ponemos en la pila. Pero si usas, por ejemplo, una estructura para una clase
muy simple, por
ejemplo esta
clase cuadrada de aquí mismo, solo
tiene
tipos de valor simples como solo algunos dobles. Aunque tuviera booleanos y
enteros, cosas así,
va a operar
mucho más rápido que las
asignaciones y
asignaciones en el montón asignaciones y
asignaciones Entonces, cuando se trabaja en el área de
pila de la memoria con tipos de valor simples
e incluso estructuras, entonces va a
operar mucho más rápido. Y las asignaciones, de nuevo, son mucho más rápidas y también más
baratas Entonces esta es una ventaja
de usar una estructura. Entonces puedes pensar, bien, ¿y si tengo un tipo de referencia dentro
de un tipo de valor? Por ejemplo, una lista de enteros es una variable de
tipo de referencia Y luego sigo adelante y pongo
esto dentro de mi estructura, que es un tipo de valor. Sí, es posible. Se
puede ver que no hay errores. La aplicación se va a ejecutar, pero esto se considera una
mala práctica. No debes hacer esto. Este tipo de derrota
el punto de usar una estructura
en primer lugar, lo que me lleva de vuelta
a mi siguiente punto Solo usa una estructura si tienes un contenedor para tipos de valor
simples. Por ejemplo, esta plaza aquí. Tiene un ancho
que es un doble. Tiene una altura
que es doble. Si tiene un color, tal vez podrías representar
esto por un entero. Y ese entero podría hacer
referencia
a algo que ver con un color. Por ejemplo, el blanco
podría ser cero, negro podría ser uno, el
rojo podría ser dos. Estos están trabajando con tipos de valor
simples. Aquí, una estructura en
esta instancia
sería perfecta porque en
sí misma es un tipo de valor. Pero también estoy usando tipos de
valor dentro. Nunca planeo
usar herencia, nunca planeo
usar polimorfismo Nunca planeo otras estructuras o cosas que hereden de esto Por lo tanto, una estructura
sería una buena opción para ello. Es simple, rápido, usa tipos de valor. Nunca quiero expandirlo para
que tenga que ver con la herencia. Si todas esas casillas están
marcadas, usa una estructura. Pero en cuanto empecemos a
pensar cosas como, bien, creo que este cuadrado debería heredar de una forma de clase base Y a lo mejor el color
podría ser una enumeración
, a lo mejor tendría una lista de píxeles y cosas así Y empezamos a
introducir campos
heredados y de
tipo pesado y de referencia aquí, entonces no, no
queremos una estructura, queremos usar una clase. Entonces, básicamente, en pocas palabras, usa una estructura si
tienes un objeto barato, pero usa una clase si
quieres
expandirlo y usar objetos pesados de tipo de
referencia Esa es básicamente
la diferencia y por qué deberías usar uno
y no el otro. Entonces una de las principales ventajas tiene sobre ser
un tipo de valor y todo lo que tiene que ver con
eso es que se puede marcar toda la
estructura como de solo lectura. Ahora bien, si ves mis
tutoriales en Solo Lectura, entenderás lo que hace. Es un tipo de datos inmutable. Una vez que hayas establecido un valor, no
puedes cambiarlo. Y hay muchas
razones para eso. Si trato de marcar
toda esta clase como solo lectura haror sobre esto puedes decir que no
es válido para este ítem Pero si hago una
estructura de solo lectura como esta por ejemplo, entonces no hay ningún problema en absoluto. Obviamente, hay un par de
temas que ver con eso. Por lo que puedes ver los campos de
instancia de estructura de solo
lectura
deben ser de solo lectura. Estos sí necesitan ser
leídos solamente también. La otra cosa, por supuesto, no
podemos usar el modificador set
si las cosas son de solo lectura. Tenemos que inicializar en la declaración de campo aquí, así que inicializamos aquí o
dentro del constructor Si miras mi
Tuchoil en solo lectura, lo recordarás
y entenderás eso, pero pensé que lo volvería a
mencionar Con las estructuras, se puede marcar toda
la estructura
como de solo lectura. Lo que realmente no se puede hacer en
una clase usando esta palabra clave. Y verás tal vez
avanzando con tus emprendimientos de
programación, verás que esta es una práctica
bastante común también cuando se trabaja
con estructuras. Esta es una
cosa poderosa que
también puedes hacer cuando trabajas
con estructuras. Pero creo que la principal
comida para llevar de esto es que no tengas miedo de usar
estructuras y experimentar, sino solo usarlas para contenedores
simples. Entonces cosas como cuadrados donde
tienes tipos de valores simples. Tan pronto como empieces a
hablar de tipos de
referencia cargados pesados, entonces en ese caso, usa una clase. Pero las estructuras son muy
buenas para trabajar con aplicaciones como el
despilfarramiento rápido
o cosas simples como estas Espero que este tutorial te haya ayudado.
66. 16-1. Tipo de datos del objeto - Boxeo y Unboxing: En este tutorial,
vamos a hablar sobre el tipo de datos del objeto. Y se ve
algo así. Es posible que haya encontrado
el tipo de datos del objeto al escribir en la consola. Por ejemplo, cuando
escribimos en la consola, hay muchas sobrecargas de
métodos diferentes que podemos usar aquí Pero puedes ver uno
de los parámetros aquí es objeto por ejemplo. ¿Qué es eso? ¿Cómo funciona? Bueno, echemos un vistazo a
cuál es el tipo de datos del objeto. Si viste mis tutoriales sobre herencia y también tipos de valor y
tipos de referencia, entonces entender
el tipo de datos del objeto será bastante fácil para ti. Ahora, el tipo de objeto es la clase base definitiva
para todos los tipos de datos, todos los tipos definidos por el usuario, ya sea que creamos
instancias de objetos, tipos de
referencia como matrices
y cosas así, y también
tipos de valores simples como enteros, bolenes, caracteres
y cosas así Es la clase base definitiva
para todos estos tipos. Es un
tipo de referencia lo que significa
que está almacenado en el área de
montón de memoria Además, es como una tecnología
más antigua. Ahora vino algo
llamado genéricos. Y en general, los genéricos
son una mejor práctica, aunque todavía se encuentra el tipo de datos del objeto en estos días Y usar el tipo de
datos del objeto puede presentar algunas cuestiones y problemas de los que también
hablaremos. Este es el proceso de
boxeo y unboxing. Echemos un
vistazo a un ejemplo ahora, cuando acabo de decir que
el tipo de datos del objeto es el último tipo base,
¿qué significa eso? Recuerda antes cuando
hablé de interfaces y podemos pasar la interfaz
a métodos, luego cuando implementamos
la interfaz, entonces podemos pasar
nuestros objetos alrededor. Si tenemos varias clases
extendiendo la misma interfaz, podemos simplemente pasar esos
objetos libremente. Esto es bastante similar a cómo funciona la clase
basada en objetos. No te preocupes si no viste
esos tutoriales sobre
clases abstractas e interfaces. Voy a
explicarlo ahora mismo. Aquí, solo estamos
llamando a un método y estamos pasando una cadena. Simplemente dice hola mundo. El parámetro es una cadena. Lo cual es genial
porque estamos pasando una cadena y luego la estamos
sacando a la ventana Una aplicación muy sencilla. Ahora imagina esto. Voy a cambiar esta cadena a la palabra clave object,
así como así. Ahora vamos a ejecutar la aplicación. Nuevamente, se puede ver que tenemos
exactamente el mismo resultado. ¿Por qué sucede esto? Bueno, es simplemente
porque una cuerda como esta de aquí satisface, esa es una relación Y es un objeto
igual que una instancia de una clase. Por ejemplo, una clase de videojuegos,
una clase de perros, una clase de animales. También hay clases, pero también son objetos. Esta palabra clave objeto aquí puede representar prácticamente cualquier tipo de
datos en el sistema. Bouls, cadenas
e incluso enteros. Por ejemplo, 3456. El resultado será el mismo, y no hay
problemas para compilar el proyecto Aquí tenemos un entero aquí, 3456, ya hablamos de ello antes Enteros simples,
cadenas, caracteres, boolenes,
todos son tipos Viven en la pila, en el área de pila de la memoria. Sin embargo, los objetos,
son tipos de referencia, estos se almacenan en el montón Lo que pasa aquí, aquí está ocurriendo
una conversión implícita Este entero que
estamos
pasando se está convirtiendo en
un tipo de objeto. Este proceso se llama boxeo. Si luego convertimos este valor de objeto de
nuevo en un entero, entonces esto se llama unboxing Si no me crees,
te lo demostraré. Ahora bien, si trabajas con un tipo de
objeto como valor aquí, ofrece algunos métodos
que podemos usar, uno de ellos se
llama get type. Lo que eso va a hacer, obtendrá el tipo subyacente de
este valor de objeto aquí. Ahora mismo estamos pasando
un entero aquí. Si ejecuto el programa, puedes ver que está dando salida al tipo subyacente
del objeto, que es un int 32, un entero de 32 bits Del mismo modo, si
paso en una cadena, di hola, entonces vamos
a conseguir una cadena por ejemplo. Puedes ver que este es
el tipo subyacente del objeto aquí mismo, y podemos obtenerlo usando
el método get type aquí. Hablemos de boxeo
y unboxing ahora mismo. Hablemos primero del
boxeo. ¿Qué es el boxeo? Tenemos un entero
aquí llamado entumecido, y lo estamos inicializando a
1234 Ahora lo que estamos haciendo es poner
este entero en una caja, ahí el nombre boxeo. Básicamente estamos diciendo, bien, quiero crear un objeto
completamente nuevo. Recuerda que esta es la clase
base definitiva para todos los tipos. Quiero darle a esto
el valor de num. Ahora OBJ debería ser igual a 1234. Ahora quiero cambiar el valor
de este num aquí a 100. ¿Crees que este valor
cambiará con él? Lo que estoy haciendo, estoy sacando dos de los valores aquí mismo Si ejecutamos la aplicación, el valor de num es 100, lo cual es cierto porque la
cambiamos. Pero se puede ver que esto no se refleja en nuestro
valor objeto aquí mismo. ¿Qué está pasando aquí? Pensé que el objeto era
un tipo de referencia. Cuando algo es
un tipo de referencia, tenemos una referencia a
esa área de la memoria. Bueno, este es el
penal del boxeo. Lo que sucede aquí
cuando cajas algo, prácticamente
estás poniendo este entero dentro de
una caja de objeto. Pero debido a que
el objeto es un tipo de referencia, todos los objetos se almacenan en
el área de montón de la memoria Tipos de valores simples como enteros
se almacenan en la pila. Lo que sucede aquí
cuando estamos creando un nuevo objeto y lo estamos
configurando en entumecido, aquí, estamos prácticamente copiando todo
este objeto completo, asignando algo de memoria extra
en el área de la memoria de montón, poniendo ese valor Y luego también creando el puntero sobre la
pila para apuntarlo. Muchas cosas están pasando
cuando haces esto aquí. Ahora bien, esto es implícito, lo que significa que sucede
automáticamente detrás de escena No tienes
control sobre esto. Boxeo, una operación muy
cara cuando miramos
nuestro ejemplo antes donde pasamos un entero
al método y teníamos
un parámetro de objeto. Todo esto sucede
detrás de escena. Todo un área de memoria en el montón se asigna
solo porque estamos pasando un entero y se convierte implícitamente
a un Este es el penal del boxeo. También es algo que debemos
considerar muy fuertemente, especialmente a la hora de crear aplicaciones a
gran escala. ¿Hay una mejor
manera de hacer esto? A lo mejor deberías considerar sobrecargar el método en su lugar Al igual que cuando tenemos
la línea derecha de la consola, tenemos todos estos diferentes encabezados de
método aquí. Podemos tomar en una matriz de caracteres, un decimal, un doble a flote Pero una vez que tenemos todos estos valores
posibles sí, entonces hay una opción
para tomar en un objeto. Pero no es obligatorio. Hay cosas de diseño a
tener en cuenta al usar objetos
aquí, así, cuando boxea ciertos tipos de datos, podríamos boxear una cadena, podríamos boxear un carácter, pero en principio, este
proceso se llama boxeo. Ahora bien, lo contrario de eso, como
habrás adivinado, es unboxing ¿Qué es unboxing? Bueno, unboxing es
más o menos lo contrario. Y eso es convertir
un tipo de referencia, como objeto almacenado en el montón, recordar el área de montón de
memoria de nuevo en un tipo de valor, luego almacenado en la Esto es lo contrario del
boxeo, y eso es unboxing. Es hacer el
proceso a la inversa. Echemos un vistazo a un
ejemplo de unboxing ahora. Ahora voy a desempacar
este objeto aquí. Recuerde, el proceso
de unboxing es convertir un tipo de referencia en un
tipo de valor Echemos un vistazo
a eso. Ahora, quiero convertirlo de
nuevo en un entero. Si lo convierto
a otro tipo, entonces va
a haber un error. Vamos a tener un problema de conversión de
tipos. Quiero un entero fuera de toda
esta operación. Ese es el punto en el que estoy boxeando el objeto de nuevo en
su tipo original. Configuré un entero
llamado resultado. Ahora lo que quiero hacer es convertir el objeto al tipo de datos
esperado. Este es el
tipo esperado que quiero, esta es la conversión. Quiero convertir este
objeto en un entero. Y este es el proceso de desempacar objetos
almacenados en el montón Quiero convertirlo
a un tipo de datos simple, y ahora va a vivir
en la pila aquí mismo. Este resultado entero aquí. Ahora bien, si emito el resultado
a la ventana de la consola, echemos un vistazo al resultado. Puedes ver como tengo mi valor
original aquí, 1234. Ahora tal vez notes una cosa sobre este tutorial,
y es decir, oye, estoy introduciendo esta palabra clave
objeto aquí, este tipo de datos de objeto, pero realmente no deberías
usarla tanto. Sí, agradezco que ese sea el tema general
de este tutorial, pero es bueno
estar al tanto de esto. En los primeros días de C Sharp, era bastante común convertir varios tipos de datos de esta manera. Entonces lo convertimos a
un tipo de referencia y volvemos a un tipo de valor. Y eso nos permite pasar diferentes tipos de datos como el último tipo de objeto de clase
base. Entonces fue bastante útil, pero luego se introdujeron cosas
como genéricos y otras cosas
que empujaron toda
esta
notación objeto del boxeo y boxeo fuera de práctica
y fuera de moda Pero es algo
a tener en cuenta, es
decir, porque quizás
podrías estar trabajando con sistemas
más antiguos o podrías estar trabajando con sistemas
que se vinculan con los tuyos. Como se llama
interoperabilidad, donde tu software se vincula
con otra pieza de software y te encontrarás con
este tipo de datos de objeto Como puede ver,
todavía está en uso hoy en día. línea derecha de la consola
toma
un objeto como parámetro y
muchos otros métodos y clases también lo usan. Pero es bueno conocer
el principio del tipo de datos de objeto y
el costoso proceso
de boxeo y desencajado, que es
convertir implícitamente tipos de datos, tipos de
valor a tipos de referencia
y luego de nuevo
a tipos y luego de nuevo
a Entonces hay una sobrecarga bastante
grande con el boxeo y el unboxing en C sharp
67. 16-2. La palabra clave dinámica y comprobación dinámica de tipos: En este tutorial,
vamos a estar viendo la palabra clave dinámica. Y la palabra clave dinámica
se ve algo así. Pero antes de hablar de
la palabra clave dinámica, solo
demos un paso
atrás. Si ves mis tutoriales
anteriores donde hablé de C Sharp, el hecho de que es un lenguaje fuertemente mecanografiado y también estáticamente
mecanografiado Entonces déjame
hablar de eso por un segundo. Un lenguaje de tipo estático
es donde los tipos de variables, por
ejemplo, un
entero por ejemplo, se conocen en tiempo de compilación Ahí es cuando hago clic en este pequeño botón
verde de reproducción aquí mismo. El software compila. Y si hay algún problema, el compilador me alertará, el software no compilará Y este es un lenguaje estáticamente
mecanografiado como C sharp. Este proceso se llama comprobación de tipo
estático. Comprobación de tipo estático, sin embargo, ¿y si te dijera
que también había algo llamado comprobación
dinámica de tipo? ¿Qué es la comprobación dinámica de tipo? Aquí es donde se
conocen los tipos de
variables, por ejemplo, en tiempo de ejecución. Si hay algún problema con los tipos o algo por el estilo, podemos compilar bien el
software. Sin embargo, si hay un error, no lo
sabremos hasta que el
software esté realmente funcionando. ¿Qué quiero decir con todo esto? Bueno, echemos un
vistazo a un ejemplo aquí. Aquí tengo un número entero de muestra. Lo estoy inicializando
al valor de 55. Entonces solo lo estoy sacando
a la pantalla. En realidad no está haciendo mucho. Sin embargo, ¿y si
quiero quizás ahora asignar un valor de cadena
a este entero? Si solo escribo hola, por ejemplo, puedes ver que aquí
hay un error obvio. No puede convertir implícitamente
la cadena en un int. Eso es porque el tipo de
esta variable es un entero. Pero lo que estamos tratando de hacer aquí es meterle una cadena. No va a letras. No sólo eso, sino que nuestro
programa no compilará. Puedes ver que hay
un error aquí. Este es un ejemplo de la comprobación de tipo
estático. Sabe que es un entero, entonces es un tipo entero. Pero ahora estamos tratando de
poner una cuerda ahí dentro. Pero en realidad estamos alertados este problema en estos
momentos en desarrollo Entonces esto se conoce como comprobación de tipo
estático. Sin embargo, con algo
así como la comprobación dinámica de tipo, entonces no se le
alertará de este error Todo se verá bien, el software
compilará bien. Pero a menos que haga algo sobre este
error en particular aquí, le alertará sobre
este error durante el tiempo de ejecución Entonces, hay otros
lenguajes de programación por ahí, por ejemplo Python o Ruby. Ahora bien, estos son lenguajes
mecanografiados dinámicamente. Eso significa, por ejemplo, podemos hacer esto y el software compilará
muy bien, no es problema. Sin embargo, se le
alertará sobre este error durante el tiempo de ejecución mientras
el software se esté ejecutando Esto se llama runtime y
aquí es donde el error puede presentarse
en tiempo de compilación. Aquí es donde C Sharp puede detectar estos posibles errores
relacionados con los tipos, y eso se llama comprobación
estáticamente de tipos Sin embargo, en tiempo de ejecución en
lenguajes como Python, Ruby, entonces serás alertado
sobre estos errores de tipo Por ejemplo, durante el tiempo de ejecución, y eso se llama comprobación
dinámica de tipo. Ahora he hablado sobre la comprobación de tipo
estático y la comprobación
dinámica de tipo
y las diferencias. va a ser más fácil explicar la palabra clave dinámica. Entonces, bajo el capó,
la palabra clave dinámica se comporta prácticamente como
el tipo de datos del objeto Si viste mis
tutoriales anteriores donde hablé sobre el tipo de datos del objeto y es canal considerado como la clase base para
todos los tipos, por
ejemplo la clase base de bolen
de doble entero Pero no sólo eso,
sino cosas como listas y objetos personalizados
y cosas por el estilo. Entonces, si recuerdas
y entiendes ese detalle sobre el tipo de datos del
objeto, entonces vas a
comenzar a funcionar con respecto a la palabra clave
dinámica. Ahora echemos un
vistazo a un ejemplo. Entonces lo que voy
a hacer ahora es hacer un ejemplo con el tipo de datos del
objeto. Entonces esta variable
aquí llamada test, va a ser un objeto tipo. Lo que estoy haciendo es
almacenar un valor aquí, 35.5 que podría ser un doble Por ejemplo, me
parece un doble, pero aquí no hay
problema porque objeto es como una clase
base aquí, va a aceptar
ese valor muy bien. Pero ahora estamos tratando de
incrementar este valor de prueba, que es objeto de tipo de datos por 7.5 Parece que estamos
agregando a a un double Lo cual debería estar bien cuando antes lo
teníamos como doble. Funcionó sin problemas. Entonces puedes ver aquí, no
hay problema. Pero ahora he convertido esto en un tipo de datos de objeto,
hay un problema. Entonces si destaco esto, dice operador plus
no se puede aplicar a objeto y doble cuando se
trabaja con objeto, hablamos de
boxeo y unboxing Lo que estoy haciendo aquí, tengo
un tipo de datos simple aquí, 35.5 que es como un doble, y estoy metiendo esto
en un tipo de datos de objeto Ahora bien, si recuerdas de antes, este es un tipo de referencia, por lo que se almacena en el área de
calor de la memoria. Lo que estamos haciendo es poner
a prueba el valor aquí. Cuando intentamos incrementar el valor, aquí hay
un problema Aquí no podemos agregar 7.5 a
este valor. Lo que tenemos que hacer aquí al incrementar el
valor, por ejemplo, es convertir explícitamente
este tipo de datos de objeto a un tipo con el que podamos trabajar Lo que estamos tratando de hacer es
agregar 7.5 que es un doble, así que tengo que convertir
esto en un doble. Podemos convertirlo
a un doble usando la
clase estática convert que hemos estado usando todo el tiempo en
los tutoriales anteriores. Y eso va
a funcionar bien. Lo que estoy haciendo aquí es
desempacar el valor aquí. Aquí estoy boxeando, estoy desencajando. Aquí hay un poco de carga útil de
rendimiento cuando hacemos el boxeo y desempaque como
hablamos antes Pero funciona bien convirtiendo
el objeto en un doble. Entonces le estoy agregando un doble, luego estoy almacenando el valor
nuevamente en el objeto, así que lo estoy volviendo a boxear así que lo estoy volviendo a boxear y luego estoy
emitiendo el valor Si ejecuto el programa, ahora ves tengo el valor 43, que se ve bien. Se puede ver que
funciona. No hay problema. De hecho puedo sumar
valores juntos. Incluso puedo agregar cinco aquí, por ejemplo, y
va a funcionar bien. Esto es un poco de una
ventaja de usar algo como esto sobre los tipos de datos
individuales, Pero hay un costo de rendimiento. Pero el punto que estoy
tratando de hacer es cuando usas el tipo de datos del objeto y
deseas modificar los valores, necesitas hacer este
desempaque aquí Tienes que hacer una conversión
explícita aquí. Ahora, con la palabra clave dinámica
que estoy a punto de introducir, dije que está muy estrechamente ligada
al tipo de datos del objeto. Se comporta de manera muy similar. Pero no necesitamos hacer esta
conversión explícita aquí mismo. Y esa no es la
única diferencia. Una de las principales diferencias
es que proporciona comprobación
dinámica de tipo en
un entorno C Sharp. Así que comencemos con
la palabra clave dinámica. Entonces
lo primero que voy a hacer, que
lo entiendas un poco mejor, es convertir este ejemplo
usando la palabra clave dynamic. Entonces lo que hago aquí, aquí defino esta variable
como dinámica. Y debido a que no es
el tipo de datos del objeto, y no necesitamos emitir nada
explícitamente, no
necesitamos ese
elenco ahí mismo. Entonces si ejecuto el programa ahora puedes ver que está funcionando
igual que antes. No se queja de agregar un valor a un tipo de datos de
objeto Entonces puedes ver que aquí hay una
ventaja considerable. No necesitamos
lanzar explícitamente nuestras variables, por ejemplo. Entonces eso es bastante bueno. Y
como mencioné antes, funciona como el
objeto bajo el capó. Entonces es casi como, ya sabes, la clase base magistral
que trabaja con enteros, bouleenes y todas
las cosas Entonces esa es la primera
ventaja de usar dynamic. No necesitamos lanzar nada
explícitamente, así que no necesitamos
decir explícitamente,
bien, hacer de esto un entero. Entonces, por lo tanto, ahora podemos agregarle un entero o
hacer de esto un doble. Entonces podemos agregarle un doble. No necesitamos hacer nada de eso. Se ve perfectamente bien. Mira, entonces lo hemos definido
como un doble, ahora le estamos agregando
un entero. Todo el boxeo de
casting de conversión
y boxeo hecho se realiza
detrás de escena. No tenemos ninguna
visibilidad de eso. Todo está hecho por nosotros. Entonces esa es una ventaja de esto, esa complejidad
se nos quita. Mira lo que Als también puede hacer. Por ejemplo, inicializamos, esto es como un doble, y luego queremos
agregarle un entero Ahora bien, ¿y si digo prueba
equivale a hola, por ejemplo? ¿Qué crees que va a pasar? Ahora vamos a ejecutar la aplicación, cómo se ve,
estamos dando salida hola Entonces lo que voy
a hacer, voy a agregar algunos puntos de interrupción aquí Vamos a entrar en modo break cuando ejecutemos la aplicación. Y luego vamos a analizar esta prueba de variables aquí abajo. Entonces, vamos a sacar esto a colación para que
podamos tener una mejor mirada. Ahora mismo, se puede ver que tenemos un objeto dinámico
aquí mismo, que es prueba. Y aún no tiene
valor porque no
hemos ejecutado
esta línea de código. Una vez que paso por encima de eso, podemos ver que la prueba es ahora, porque le hemos puesto un
doble valor,
ahora estamos incrementando
el valor en cinco, lo que parece bastante bien Entonces puedes ver que sigue
siendo un doble. Ahora, tratando de poner un valor de
cadena aquí, si pasamos por encima de esto, se
puede ver ahora que tenemos
una cadena dinámica aquí. Entonces puedes ver que es bastante
flexible en la forma en que funciona. Prácticamente simplemente arroja todo
el concepto de tipos o al menos te oculta el concepto
de tipos de variables. Entonces, al desarrollar
aplicaciones, puede
parecer que
se te quita
toda esa complejidad . No necesitas preocuparte por
si es una cadena, es un entero. Quizás programadores Python, o si has hecho
algún script Java, puede
que esto te resulte
realmente útil Pero sin embargo, los errores pueden
ocurrir durante el tiempo de ejecución, y aquí es cuando su
aplicación realmente se está ejecutando. Entonces hay algunos
problemas asociados con la palabra clave dinámica con los que hay que
tener cuidado. Entonces la palabra clave dinámica
, probablemente te suene
bastante bien. No tenemos que
preocuparnos por los tipos, no
tenemos que convertir
a diferentes tipos. Sólo podemos usarlo
para todo. Ya sabes, ¿por qué no? Y a lo mejor hay una ligera
actuación aquí, pero por lo demás parece
bastante buena, ¿verdad? Bueno, hablemos de la desventaja de usar
dinámica ahora mismo Pero primero voy a introducir un ejemplo donde trabajamos
con algunos objetos personalizados. Entonces lo que tengo aquí, tengo una clase de videojuegos,
es bastante simple. Tiene cuatro campos privados, un constructor, un método de muestra y solo una muestra de
propiedad pública aquí mismo que acaba de obtener el
título del videojuego. No hace mucho. He instanciado a la clase. Aquí tengo un
objeto de videojuego llamado Game One. Si has seguido mis 00
tutoriales de antes, cuando hacemos uso
de esta instancia. Aquí podemos ver varias cosas. Podemos ver nuestro método get
publisher. Y podemos ver nuestra propiedad aquí
mismo, el título. Podemos ver esto cuando esta
ventana aparece aquí, esto es como Visual
Studio ayudándonos. Y otra palabra de eso
se llama Intellisense. Y lo que hace el sentido de Intel, solo nos da algunas características agradables de
autocompletar Nos salva de escribir. Por ejemplo, podemos
hacer doble clic a esto y luego tenemos acceso al
método número uno. Sabemos que el método está ahí. Número dos, sabemos que
podemos acceder al método, no
es privado ni
nada por el estilo. Número tres, si hacemos
doble clic en él, no
tenemos que
preocuparnos por la corrección
ortográfica de errores tipográficos , así que
es bastante buena También nos da tipos de
parámetros que
podemos usar y también nos permite
conocer los tipos de retorno. Entonces Intel sense,
también conocido como visual studio, ayudarnos es una
muy buena característica y recomiendo encarecidamente usarlo. Sin embargo, cuando se usa
la palabra clave dinámica, Intellisense no está disponible Ahora bien, hay una buena
razón para esto, pero es una de las
grandes desventajas
sobre el uso de la palabra clave dinámica. Echemos un vistazo a eso ahora. Ahora mismo, sólo estoy
montando un juego aquí. Entonces quiero conseguir
el editor, por ejemplo, vamos a
almacenar eso en una cadena. Lo guardaré en una
cadena llamada Pub. Y luego solo quiero
sacarlo a la ventana. No está pasando mucho aquí. Debería dar salida a
Blizzard, por ejemplo. Ejecutemos el software ahora, y ya podemos ver a Blizzard Parece que está
funcionando bien. Ahora vamos a convertir esto
en un tipo dinámico. Ahora tengo un
objeto dinámico llamado Game One. Tiene el valor de la nueva instancia de
la clase de videojuegos. Como dije, no tiene que
ser un doble un entero. Podría ser un tipo complejo,
podría ser una matriz, una lista, o incluso una clase personalizada, como la clase de videojuegos. Absolutamente, no hay problema en
hacer eso en absoluto. Totalmente soportado por
la palabra clave dinámica, Y nuevamente, esto es como el
objeto detrás de escena. Todo está bien hasta el momento. Y si ejecuto la aplicación, obtenemos exactamente el mismo
resultado, no hay problema en absoluto. Pero mira lo que pasa. Ahora pongo punto tras juego uno. Se puede ver que hemos perdido todo
eso en sentido contundente. Visual Studio ahora se
niega a ayudarnos. No sabemos qué
métodos tenemos disponibles a menos que en realidad, ya
sabes, veamos esto y tal vez copiarlos y
pegarlos. No obstante, tiene muchos problemas
de esta manera. El caso es que se basa en
la Tierra para no cometer errores. Número uno, como dije antes, mejor este es un método privado, así que ni siquiera podemos acceder a
él fuera de esta clase. Entonces, ya sabes, aquí
podríamos crear todo un
gran problema. Entonces, si ejecuto la aplicación, ahora está diciendo que es inaccesible debido a
su nivel de protección Bueno, ¿y si cometí un error tipográfico? ¿Y si pongo F aquí? Se puede ver que no lo está
resaltando en rojo. Ejecute la aplicación y
no contenga una definición. Bueno, eso es porque lo deletreé mal y es un accidente Pero no tengo visual
studio ayudándome. Tengo cero Intellisense. Entonces esta es una de las desventajas de usar la palabra clave dynamic No tienes absolutamente ningún
intellisense en absoluto. Y intellisense
es realmente útil, y mucha gente lo da por
sentado Pero te da
todos los métodos y propiedades que
realmente puedes usar en un objeto. Entonces tal vez te estés preguntando ¿qué
era esa brujería antes donde escribías mal al editor
y no había línea roja ¿Por qué fue eso? ¿Qué está
pasando aquí? ¿Por qué el programa te
pudo ejecutar? Eso normalmente no está permitido. Bueno, sí, eso es
cierto porque si vuelvo a convertir esto en
un objeto de videojuego, puedes ver que obtenemos la línea roja. Y eso es porque
al inicio de este video, dije que C Sharp era un lenguaje
estáticamente mecanografiado Y eso solo significa que todo
está atrapado en tiempo de compilación. Así que ni siquiera puedo compilar la aplicación porque aquí es donde se capturan los errores. Sin embargo, cuando se usa
la palabra clave dinámica, entonces todo esto se va. Nada que sea dinámico
se captura en tiempo de compilación. Entonces el error se ha ido. El programa puede compilar. El programa compila cuando aparece
la ventana negra,
como puedes ver ahí Pero ahora el error es
realmente captado en tiempo de ejecución. Y este es el error
que se lanza. Se llama
excepción de carpeta de tiempo de ejecución, aquí mismo. Así que ejecute la excepción de carpeta de tiempo. Entonces esto sucede en tiempo de ejecución mientras tu software
está realmente funcionando. Entonces, en pocas palabras, cuando usas la
palabra clave dinámica como esta, Visual Studio simplemente te
da rienda suelta Literalmente dice, bien, haz lo que quieras. Si algo es dinámico,
llama a cualquier mensaje que quieras, llama a cualquier propiedad que quieras. Ya sabes, no importa. No
te voy a dar líneas rojas. Te voy a dejar
compilar tu software, puedes hacer lo
que quieras hacer. Se puede introducir el error humano, más o menos Tienes reinado libre. Entonces esa es una ventaja, o tal vez una gran desventaja, de usar la palabra clave dinámica. Entonces la elección es
suya en ese sentido. Pero lenguajes de programación
como Python, Ruby, incluso Java Script, estos son lenguajes mecanografiados
dinámicamente Sin embargo, C Sharp es un
lenguaje de tipo estático. Entonces tal vez te estés preguntando, bueno, ¿por qué un lenguaje estáticamente
mecanografiado admite esto en primer lugar Ya sabes, ¿
por qué tenemos esto? Pensé que este era un lenguaje
estáticamente mecanografiado. Bueno, ¿y si quieres crear un software que funcione
con software Python? Por ejemplo, si Python y Ruby son lenguajes mecanografiados dinámicamente, entonces tal vez mi software
necesite trabajar con ellos. Y una manera elegante de decir esto se llama interoperabilidad, o interrumpir para abreviar Si quiero crear
software que funcione con el software de
otra persona, pero usaron un lenguaje
diferente, entonces aquí es donde la
palabra clave dinámica es realmente bastante útil incluso trabajando con
el modelo de objetos de documento. Ahora bien, esto es algo que usan
HTML y XML cuando se usan cosas así. Simplemente no sabes
qué métodos y propiedades están disponibles
hasta el tiempo de ejecución. Por eso es bastante útil. No todo se sabe
a la hora del compilador. Cuando tu software se compila, a veces solo se pone a tu
disposición en tiempo de ejecución Entonces es por eso que la
palabra clave dinámica es realmente útil. Entonces un par de elegantes pedacitos
de terminología para ti. Si tenemos nuestro simple objeto de
videojuego como ya
hablamos antes
y queremos decir,
llame a un método llamado
get publisher, entonces este es un ejemplo de
lo que se llama early binding. Y eso solo significa, bien, este método está disponible para nosotros, lo
estamos usando aquí mismo. Cualquier error será
capturado en tiempo de compilación. Cuando hacemos clic en este
pequeño botón gris y la encuadernación se hace temprano, todo funciona, No
hay error. Por ejemplo, si hice esto, entonces hay un
ejemplo de error de vinculación temprana. No obstante, si esto era dinámico e intentamos
hacerlo ahora mismo, no
tenemos idea de si este
método está disponible. No tenemos idea
si este método es público, privado,
interno protegido. No tenemos idea si lo
deletreé correctamente. Sin embargo, cuando ejecuto
la aplicación, entonces el enlace se
realiza durante el tiempo de ejecución. Ahora mismo, ¿de acuerdo? Sí, el método está disponible. Lo acabamos de llamar,
tenemos un resultado. Este es un ejemplo
de unión tardía, unión temprana antes de
unión tardía durante el tiempo de ejecución. Un par de cosas que
quizás oigas en el futuro, pero pensé en
sacarlas a colación ahora. Otra cosa que no
mencioné fue dinámica. Si defines una variable, por ejemplo un entero simple
o algo así,
lo que realmente quieras,
el tipo no es importante. No es necesario inicializarlo. Puedes si quieres. No hay daño en hacer eso, pero no es obligatorio. No hace falta decir,
bien, esto equivale a cinco. Puedes resolverlo más adelante. Eso es otra cosa que puedes
hacer con la palabra clave dinámica. Otra cosa que puedes
hacer con dynamic es incluso pasarla a métodos y
devolverla fuera de métodos. Acabo de configurar un
método de muestra llamado Echo. Simplemente va a hacerse eco del
valor del editor. Por ejemplo, sé por un hecho juego un editor
que va a conseguir eso para mí, no
tengo Intellisense Asumo que está deletreada correctamente. Entonces sólo vamos a
sacar eso a la pantalla. Comentemos esa salida y luego llamaremos
al método real. Esto se ve bastante bien. Estamos pasando el objeto de
juego en el que es dinámico como parámetro
al método y
haciéndonos eco del resultado
del método get publisher.
Vamos a ejecutar el programa. Parece que está funcionando. Puedes ver aquí, pero no
solo como mencioné, también
podemos devolver la palabra clave
dinámica. Entonces aquí estoy llamando al método aquí que ahora
no toma parámetros. Estoy inicializando un nuevo objeto de
videojuego, y lo estoy devolviendo instantáneamente. Pero estoy devolviendo
la palabra clave dinámica porque no quiero
un objeto de videojuego. Y luego estoy captando
el resultado aquí en un nuevo objeto de juego dinámico, y luego estoy consiguiendo
el editor. Así se puede ver igualmente funciona como un retorno también, dinámico. Se puede pasar por ahí
sin ningún problema. Así que vamos a resumir la palabra clave
dinámica ahora mismo. La palabra clave dinámica,
no tenemos que
preocuparnos por los tipos, no
tenemos que
preocuparnos por los tipos de casting. Toda la
conversión de boxeo y boxeo está hecha por nosotros. Eso es genial. Sin embargo,
hay un impacto en el desempeño. Nuevamente, tenemos que
preocuparnos por deletrear nuestros métodos correctamente si
realmente son accesibles. Un montón de cosas diferentes. En pocas palabras, la dinámica no se usa en una aplicación típica de C
Sharp Si solo estás
haciendo una calculadora o algo bastante simple, realmente no
deberías usar
la palabra clave dynamic. Sin embargo, si estás trabajando
quizás con otras piezas de software que han sido desarrolladas
en lenguajes dinámicos, o tal vez algo
llamado un objeto com o el
modelo de objeto de documento para HTML. Aquí es donde
brilla la palabra clave
dinámica y aquí es donde
debes usarla, porque en instancias
como esa no
tienes acceso a estos métodos
en tiempo de compilación de todos modos Es posible que solo tengas acceso
a ellos en tiempo de ejecución. Entonces aquí es donde usarías la palabra clave dinámica
en este sentido. Por lo que no se usa en aplicaciones
comunes de tienda. Entonces es uno de esos
con escenarios que nunca te preguntas
realmente, debo usar la palabra clave
dynamic. Por lo general se te presenta. Bien, sí, esto definitivamente
parece que debería usar
la palabra clave dynamic. Y eso es lo que generalmente
sucede cuando estás arquitectonando una nueva pieza
de software, por ejemplo Entonces la palabra clave dinámica, ofrece verificación dinámica de tipo, y es básicamente
el tipo de datos del objeto, pero en esteroides.
Gracias por ver. Espero que haya sido útil.
68. 16-3. La palabra clave var e inferencia de tipos: Basado en todo lo que
hemos aprendido hasta ahora. ¿Y si te dijera que ya
no necesitamos tipos de datos? Por ejemplo, no necesitamos un tipo de datos de objeto de
videojuego. No necesitamos un tipo de datos de lista. No necesitamos un tipo de datos de
matriz de cadenas, ni
siquiera un Interble
o un carácter Y todo está bien y
el software compilará. ¿Qué demonios está pasando aquí? Bueno, déjame presentarte
algo completamente diferente. Ahora en este tutorial
voy a estar hablando de
la palabra Varki en Do sharp Se ve algo así. Si no has visto
mis tutoriales anteriores sobre la palabra clave dinámica donde
hablé de verificación dinámica de
tipo y también de verificación de tipo estático, todas esas cosas buenas,
entonces
te recomiendo que las veas antes de
continuar con este tutorial. De lo contrario, vas
a tener más dificultad entender los conceptos
resaltados en este tutorial. Entonces, ¿qué es la
palabra clave Var? ¿Cómo funciona? Bueno, podemos usar la palabra clave Var hora de definir algo
así como una variable. Por ejemplo, tenemos
una variable entera aquí y la establecemos en 55. Podríamos igualmente
establecer esto como una v, lo que parece un tipo de datos Var. Sin embargo, Va no es un tipo de datos. La palabra clave Var es la
taquigrafía de bien. Averigua qué
tipo de datos es realmente este cuando compilas tu
aplicación, por ejemplo. Así que todas las comprobaciones que utilizan la palabra clave Var
se realizan en tiempo de compilación. Ahora recuerda en nuestro último
tutorial donde hablamos sobre la palabra clave dinámica y cómo se resolvió todo lo que
tenía que ver con
una palabra clave dinámica todo lo que
tenía que ver con
una palabra clave dinámica en tiempo de ejecución. Por ejemplo, ¿existen
los métodos? ¿Existen las propiedades? Y luego, como que lo
vincula en una encuadernación tardía. En tiempo de ejecución, bueno, el Va se hace en tiempo de compilación. Entonces, por ejemplo,
si intento llamar a un método en una variable var, por ejemplo, entonces va a error si el
método no existe. Pero vamos a
cubrir eso más tarde. Echemos un
vistazo a un pequeño ejemplo usando la palabra clave var y
luego iremos a partir de ahí. Echemos un vistazo a un par de ejemplos
simples en este momento. Aquí tengo una
variable local aquí llamada test. Pero en lugar de darle, digamos, un entero o una cadena
o algo así, estoy usando la palabra clave var aquí. Y como mencioné antes, depende de Visual Studio y del compilador averiguar
qué tipo de datos es este Digo Visual Studio porque acabo de definir
la variable aquí. Y si pongo el cursor sobre
él aquí mismo, puedes ver que piensa que
es un entero Si cambio esto a una cadena, realmente no importa lo que haya
ahí dentro. Puede estar vacío. Puso el cursor sobre la prueba, y ahora es un tipo de datos de cadena Lo que hace, resuelve el tipo de datos en función de
lo que se inicializa Lo he inicializado a una cadena. Aquí puedes ver cuando
coloco el cursor sobre
él, es un
tipo de datos de cadena, igual que antes Podría ser un entero
o incluso un doble, por ejemplo, ahora es un doble. Ahora cuando realmente
compila la aplicación, aquí es donde
funciona si algo es válido o no válido
en función de lo que hayas hecho. Este es el proceso de compilación
y aquí es donde
realmente se da cuenta de
qué tipo de datos es el tiempo de compilación. Ese es un ejemplo sencillo ahí de cómo Var no es un tipo de datos. Pero puedes ver
que en realidad basa su tipo de datos en
lo que lo inicializas ¿Qué pasa si
no inicializo? Bueno, eso no es posible. En realidad no se puede
definir algo con la palabra clave var y
no darle un valor porque entonces el
sistema no puede elaborar un tipo de datos a partir de
esto siempre que use la palabra clave var siempre
debe
inicializarla a partir de eso puede
averiguar qué tipo de datos es, por
ejemplo, una cadena El proceso de elaborar el tipo de datos basado en
el valor de inicialización, bueno, hay una
palabra elegante para eso y se llama inferencia de tipo Tal vez oigas eso en el futuro. Se llama inferencia de tipo, y ahí es donde adivinamos el tipo de datos basado en
el valor inicial aquí Ahora nuestra variable local
aquí, el tipo, es una cadena porque
esta se
basa en el
valor de inicialización aquí Lo que no podemos hacer entonces
es simplemente convertir esto a un
tipo totalmente diferente. Se puede ver aquí. No se puede convertir el tipo en cadena
una vez que esto se inicializa. Por ejemplo, esto
es ahora una cadena. Es más o menos una
cuerda para toda su vida. No podemos simplemente entonces, bien, convertirlo en un entero,
convertirlo en un booling No podemos hacer eso
con la palabra clave Var. Echemos un vistazo a un ejemplo con algunos objetos más
complicados. Ahora, por ejemplo,
definamos un objeto de juego. Esta es nuestra clase de
videojuegos donde acabamos de pasar en
algunos valores de muestra. Aquí, puedes echar un vistazo a la clase aquí.
No está pasando mucho. Campo privado, un constructor
y un método de muestra. Lo que voy a hacer es simplemente
llamar a este método de muestra aquí llamado get publisher
back out here. Estoy configurando un nuevo objeto de
videojuego, pero estoy almacenando esto
en un juego aquí mismo, que usa la palabra clave Var. Entonces ahora usando este objeto de juego, puedes ver que tengo Intellisense
completo aquí tengo la ayuda completa del estudio
visual A diferencia de la palabra clave dinámica, porque recuerda en
el último tutorial cuando hablé de dinámica, todo está
resuelto en tiempo de ejecución. Entonces no tenemos
Intellisense en absoluto, porque todo esto se resuelve en
tiempo de compilación Entonces tengo acceso completo
al Intellisense. Entonces no voy a hacer
errores tipográficos, adivinando métodos, llamando a métodos que quizás sean privados y
los estoy llamando fuera de
la clase actual No voy a cometer
esos errores como quizás lo haría usando
la palabra clave dinámica. Entonces si ejecuto la aplicación, ahora se puede ver que estoy consiguiendo
el editor no hay problema, y tengo acceso completo
al Intellisense disponible Entonces hablemos de
algunas trampas de usar la palabra clave Var ¿Qué no puedo hacer con él? ¿Y por qué es malo? ¿Por ejemplo? Bueno, a diferencia de la palabra clave
dinámica, Var realmente no tiene
tanta desventaja ni mucho impacto negativo. Sin embargo, hay
algunas desventajas. Por ejemplo, no podemos usar
la palabra clave var con métodos. Entonces aquí tengo un método
de prueba aquí. Si trato de devolver
algo de tipo var, no me va a dejar. De igual manera, si lo uso como parámetro y solo
le doy un nombre, otra vez, tampoco me va
a dejar. Esto es simplemente porque Visual Studio no
tiene suficiente información disponible para adivinar el tipo en
función de un retorno
o un parámetro. O al menos eso es lo que
me hacen creer. Pero no se puede usar
la palabra clave var como parámetro de un método, o incluso devolver una
v de un método. Simplemente no es posible. Pero con la
palabra clave dinámica por ejemplo, eres capaz de, no puedes
con la palabra clave var. Echemos un vistazo a una desventaja potencial
más de usar la palabra clave Var. Ahora vamos a limpiar algunas
de estas cosas aquí. Lo que voy a
hacer, digamos por ejemplo, quiero crear algún software
financiero. Quiero que calcule dinero, pero quiero un alto grado
de precisión decimal. No quiero
perder dinero debido a mi software de no permitir
suficientes decimales. Es bastante fácil de hacer. En una instancia como esta, necesito un tipo de datos decimales. Si recuerdas
mi tutorial temprano donde hablé de decimales, hablé de carrozas y
hablé Si recuerdas, decimal tiene el mayor
grado de precisión, por lo que muchos decimales. Los dobles están
en algún lugar en el medio. Y los flotadores tienen la
menor precisión, el menor número
de decimales Quiero un decimal porque
estoy trabajando con dinero, no
quiero que
se pierda nada. Voy a crear
una nueva variable. Va a estar usando la palabra clave var y
voy a llamarlo dinero. Ahora, voy a
inicializar esto. Que realmente no importe
qué valor por ejemplo, pero voy a poner tal vez
algo como esto. En realidad, no, vamos
a hacer que sea cero. Así que lo he inicializado como cero y ahora si me
harver sobre esto, se
puede ver que se supone que
el tipo de datos es doble Ahora el doble es como un grado medio de precisión,
pero no hay error. Ya sabes,
no hay nada malo esto sintácticamente.
Es perfecto. La aplicación se ejecuta. Estoy sacando cero aquí mismo. Ahora el sistema no conoce mi intención, el
sistema no sabe. Quiero crear una
aplicación basada en el dinero. En realidad quiero un alto
grado de decimales. Quiero que esto sea un
decimal detrás de escena. Entonces, ¿cómo hago eso? Bueno, a la
hora de definir un decimal, solo hay que
poner m ahí mismo. Y si me dudo sobre el dinero, se
puede ver que ahora es un
decimal, no un doble Pero se puede ver que eso es
solo un error humano. Fácilmente podría olvidarme escribir esa m y ahora
tengo un doble. Entonces tal vez si
compila mi software, se lo
doy a mis clientes, ellos empiezan a usarlo por ejemplo. Entonces notan que falta un
poco de dinero debido al redondeo porque
se supone que este es un doble Así que estoy perdiendo mucho grado de precisión al cometer
ese pequeño error. Este software se
encarga de perder dinero, y eso no es bueno. Y nuevamente, tal vez
no estés perdiendo dinero. Podrías estar ganando dinero, pero el hecho es que está mal. Así que fácilmente podría olvidarme de usar esta M aquí y obtener un decimal. Entonces es algo con lo que debes tener mucho cuidado de hacer. Entonces solo te voy
a resaltar esto ahora si acabo de establecer este valor monetario a un alto
grado de precisión decimal, porque estamos
trabajando con dinero, cuando ejecuto la aplicación, puedes ver que toda esta
precisión se ha truncado, por lo que falta bastante
información Y eso es solo por el hecho
de usar una m aquí mismo. Entonces, ya sabes, es
bastante fácil de hacer. Mientras que si tuviera que encontrar esto como decimal para empezar. Y luego hago
algo como esto, entonces se puede ver que
hay una línea roja, así que el software ni siquiera
compilará. Hay un error. Y es
más o menos decir, bien, si necesitas un decimal tienes que
usar el sufijo M aquí Nunca cometeré ese error. Si defino explícitamente esta variable dinero como
un tipo de datos decimal, Ese es un escenario en particular donde usar una palabra clave Var
podría crear problemas. En el futuro, quiero
mostrar otro ejemplo ahora que ver con la palabra clave Var y una posible desventaja
de usarla. Aquí tengo mi clase de
videojuegos aquí mismo. Tiene algunos
campos diversos aquí. Lo que voy a hacer, solo
voy a copiar estos campos y moverlos al método principal
aquí mismo para que pueda
ilustrar algo. Lo que tengo, aquí tengo estos
diversos tipos. Tengo enteros, cadenas, lista de enteros, y también
un objeto de juego también Lo que voy a hacer, en
lugar de tener estos tipos de datos aquí, voy a sustituir a
todos por la palabra clave Var. Y notarás algo cuando cambie la información del juego
para usar la palabra clave Var, ahora tenemos que darle un valor antes de que podamos
dejarlo así. Lo que se llama null,
no tiene valor, y hablaremos de null
en un tutorial posterior. Pero ahora realmente necesita un valor porque
necesita calcular
el tipo de datos a partir de cuando
instancias el objeto Entonces ahora no podemos dejar
esto vacío así. Tenemos que darle un valor. Eso es una
cosa importante a tener en cuenta. Al usar la palabra clave var, tenemos que inicializarla. Lo que voy a hacer, sólo
voy a
cambiar estos a la palabra clave Var. Así podemos ver una cosa
más también. Ahora bien, la otra desventaja, tal vez desventaja potencial, o al menos la conciencia es que al mirar aquí
las variables declaradas, es
difícil saber qué tipo de
datos son estas. Tal vez podamos
averiguar que la consola es una cadena y el título es
una cadena, etcétera Pero podemos ver el cero
y saber que es un entero. Pero usando esto, especialmente en
cualquier otro lugar de
la aplicación, tendríamos que pasar
el cursor sobre la variable cada vez y averiguar que es un entero mirando este nombre solo Obviamente, hay
var al lado, así que tampoco vemos el tipo de datos
int. No está un poco claro a primera vista qué tipo de
datos es este. Quizás podamos tener
más cuidado con nuestros nombres de variables y
tal vez llamarlo calificación int, o quizás número de calificación. Y entonces sabemos desde
un primer vistazo que, bien, es un número. Es especialmente útil a la
hora de depurar, pero es solo algo a
tener en cuenta al usar la palabra clave var, especialmente
al declarar las variables Aquí, este tipo de información
explícita
con respecto al tipo de datos
ha desaparecido. Realmente solo podemos tener el valor
inicial para mirar. Tenemos que pasar el mouse sobre cada uno solo para obtener claridad
sobre qué tipo de datos es Entonces, cuando tienes piezas de software grandes y
complicadas, y estás tratando de
depurar, ya sabes, cientos de variables,
puede llevar bastante
tiempo calcular, ya
sabes, qué tipo es
la variable, y tal vez haya un problema de tipo. Tal vez estás tratando de alimentar una cadena en un
entero, por ejemplo. Si ese es un error potencial, entonces puede tomar, ya sabes, un poco más de tiempo resolverlo cuando aquí no tenemos tipos
explícitos. Y estamos
teniendo que pasar mouse sobre cada uno para
averiguar cuál es el tipo Y de ninguna manera es
un factor decisivo, solo te obliga a tener un buen hábito de nombrar
tus variables correctamente Por ejemplo, una variable llamada número de
calificación podría ser un nombre
mejor que solo calificación. Da un poco más de información sobre los datos que estás
almacenando en esta variable. En todo caso, te enseña
a ser un mejor desarrollador. Lo último de lo
que quiero hablar es ¿cuándo debo usar
la palabra clave Var? ¿Debo ignorarlo
por completo y simplemente
conservarlo como un poco de conocimiento o
debo usarlo todo el tiempo? ¿Hay alguna caída? ¿Hay alguna razón práctica? Bueno, mucha gente realmente usa la palabra clave Var
para todo. He mirado el software y ni siquiera
usan tipos de datos, o al menos casi nunca
todo tiene la palabra clave Var. Quiero decir, no hay nada
realmente malo en eso, especialmente si usas tipos de variables
descriptivas. Eres bastante
cauteloso al
definir decimales y
flotadores, Entonces no hay nada realmente malo en usar
la palabra clave Var. Puedes usar la palabra clave Var
para prácticamente todo, o puedes usar tipos de
datos estándar. Depende de ti. Pero hay un par de
situaciones en las que la palabra clave Var sí
tiene algunas ventajas. Entonces déjame mostrarte esos ahora. Entonces aclaremos algo
de este ejemplo aquí. Digamos por ejemplo, estamos creando una
pieza de software que administra un montón
de tiendas de videojuegos. Tenemos nuestra clase de
videojuegos aquí. Cada tienda que
venda videojuegos tendrá una lista de
videojuegos en su colección. Se verá
algo así. Sin embargo, queremos
gestionar múltiples tiendas. Cada tienda tendrá una
lista de videojuegos, pero quizá queramos
catalogar lo que
cada tienda tiene. En una situación como esta, tendríamos una lista de
una lista de videojuegos. Y eso será como la Colección
Ultimate Game, por ejemplo. Entonces en este caso,
mira este tipo de datos aquí. Es bastante largo, es
bastante molesto escribir, es bastante complicado de
mirar parejo. Incluso podrías ampliar
eso diciendo, tengo una lista de
una lista de una lista. Entonces ya sabes que el tipo de
situación continúa. Se puede ver lo grande que es eso. Pero en una situación como esta, podrías usar la palabra clave var. Y eso simplemente
simplifica todo eso. Se ahorra mucho mecanografiar. Y puedes ver que tienes un bonito atajo práctico ahí
en los casos en los que tienes tipos de datos
bastante grandes aquí y no quieres escribir todo
y por cualquier razón, en decir sentido no te lo está
ofreciendo. O tal vez quieras
recorrerlo y
no quieres escribir todo
este tipo de datos. Es bastante fácil solo
usar la palabra clave Var. Ya sabes, no es ningún
problema en absoluto. Y, ya sabes, en casos como
este no estás definiendo decimales o dobles y existe riesgo de que tal vez pierda la precisión
decimal, entonces algo como
esto está perfectamente bien Es una manera bastante fácil de hacerlo. Y puedes ver lo
rápido que fue escribir sólo tres caracteres en el teclado versus
todo esto aquí. Sólo un ejemplo
ahí, también hay un par de
ejemplos más, que aún no hemos cubierto, pero vamos a
cubrir uno de ellos. Entonces uno de los dos ejemplos es algo llamado consultas de enlace. Y otro ejemplo es la
creación de objetos anónimos, que
hablaremos pronto. Y la palabra clave var es muy buena para crear objetos anónimos. Pero para resumir, y
la comida para llevar de este tutorial es var no
es un tipo de datos Var es solo una buena
manera de decir, bien, descubramos el tipo de datos en
función de la inicialización Y a este proceso se
le llama inferencia de tipos. Entonces esta es la
palabra clave var en C sharp.
69. 16-4. Tipos anónimos: En este tutorial,
voy a estar
hablando de tipos anónimos en tienda C. Si no has visto mi
tutorial sobre la palabra clave Var, entonces
te recomiendo que veas eso primero antes de ver
este tutorial. Entonces tipos anónimos,
¿qué son? Echemos un
vistazo a un ejemplo aquí. Aquí tengo una clase
llamada videojuego, y estoy creando cuatro objetos. Realmente no
importa lo que haya aquí, pero hay un constructor, algunos campos, varias propiedades
y cosas así. Así que puedes ver en este ejemplo, estoy configurando cuatro
objetos aquí prefijándolos con nuestras
clases como un tipo de datos Entonces estoy instanciando
un nuevo objeto con todos estos parámetros Pero para hacer esto, tengo que crear una clase. Ahora, mi clase tiene que
tener un constructor. Bueno, no tiene
que tener uno, pero yo sí tengo uno
y sí quiero uno. Tiene todos estos campos privados, algunos métodos, y propiedades
y cosas así. Entonces tiene todas esas
cosas en esta clase aquí, solo
para crear para objetos aquí mismo. Pero con algo
llamado tipos anónimos, no
tenemos que definir una clase. Ves esta clase aquí
donde definimos el videojuego. No necesitamos ninguna
de esta definición. No necesitamos este archivo. No necesitamos esta clase per se. Entonces, ¿cómo funciona eso? ¿Por qué
nos beneficiaría no tener una clase pero necesitamos
instanciarnos de la Eso no tiene sentido para mí. Por favor, explique los tipos anónimos, son útiles por un
par de razones. Una de las principales razones
es algo que se llama Link. Ahora, no hemos
hablado de Link, así que no voy a hablar de eso ahora. Pero otra situación,
por ejemplo, digamos que estás prototipando
una pieza de software Quieres hacer un
software rápido para asegurarte de que
algo funcione. O tal vez no
quieras crear una clase entera con muchos
métodos y cosas. Porque lo que estás creando es algo bastante
sencillo y rápido. Entonces hay un par de
razones realmente. Pero uno de los
beneficios es la velocidad, y otro beneficio
es si no estás creando algo
particularmente complicado, tal vez solo tiene dos propiedades y no estás
haciendo mucho con ella. Entonces puedes usar lo que
se llama tipos anónimos. Entonces, ¿cómo creo una instancia de una clase
que no existe? Bueno, esa es una muy
buena pregunta. Y empieza con
la palabra clave var. Entonces lo que voy
a hacer, voy a simular este objeto de
videojuego aquí, pero en lugar de usar
la clase de videojuegos, voy a usar
un tipo anónimo. Entonces hay eliminar
todos esos y solo
vamos a usar
este como ejemplo. ¿Cómo puedo crear una instancia de una clase que no existe
usando tipos anónimos Bueno, porque la
clase no existe, por lo tanto es
anónima,
realmente no podemos iniciarla con
un nombre de clase aquí. Aquí es donde
usamos la palabra clave var que hemos hablado
en un tutorial anterior. Ahora queremos darle un nombre, sólo
voy a
llamarlo juego. Ahora necesitamos instanciar
un nuevo objeto anónimo. ¿Cómo lo hacemos?
Usamos la nueva palabra clave, pero ahora usamos llaves Ahora dentro de estas llaves, vamos a configurar nuestras
propiedades para nuestra clase Esta línea aquí prácticamente
imita esta línea aquí. La única diferencia es que
no tenemos que definir una clase. Esta clase no
tiene por qué existir. A estos los podemos llamar como
quisiéramos. No importa porque
es de tipo anónimo. Si uso mi objeto aquí, si pongo un punto aquí mismo, puede ver que puedo acceder a todas las propiedades que
he definido aquí. he deletreado usando personajes
locos como Gampd, pero puedes ver que
eso aparece en la lista y de hecho puedo
acceder a esto como Aquí mismo tenemos una consola
aquí, editorial y calificación, se
puede ver que no
importa cómo los llame, no
importa
qué valores le dé. Esto es puramente anónimo
porque no tiene nombre, no tiene clase. Debido a que es anónimo,
lo almacenamos usando la
palabra clave var en un objeto. Aquí mismo, se puede ver que
esto es bastante poderoso. No necesitamos una clase, es completamente
anónima, y para ello solo usamos
la nueva palabra clave aquí. Pero hay un par
de excepciones con esto. Cuando creamos un tipo anónimo como este de aquí, solo
podemos crear propiedades de solo
lectura. No hay constructor, no
hay métodos, no
hay campos privados. Imagínese si esta
clase aquí llamada videojuego fuera un objeto
anónimo, entonces lo único
que puede tener aquí son las propiedades de solo lectura, título, por ejemplo, calificación del
editor,
y su solo lectura. Solo puedes obtener los valores, solo
puedes establecerlos una vez. Y es entonces cuando se
define el tipo anónimo, aquí
mismo, el objeto
anónimo, pero detrás de escena, esto es lo que se
generaría cuando se crea
un tipo anónimo. Entonces lee solo propiedades, sin constructores, sin
campos, sin métodos Entonces son las limitaciones de
usar algo como esto. En realidad no se detiene ahí. Al crear tipos anónimos. Aquí lo que
realmente podemos hacer es poner un tipo anónimo dentro de
otro tipo anónimo. Podemos crear una variedad
de tipos anónimos. Así que muchas cosas diferentes
podemos hacer con ellos. Déjame mostrarte un
ejemplo ahora mismo. En este ejemplo, tengo
un tipo anónimo
aquí dentro de otro tipo
anónimo. Si uso mi tipo de animal
aquí y voy a punto, puedo ir a especies
que también es tipo
anónimo y acceder al ruido que pueda hacer
el animal. La especie podría ser un perro, en el que el nombre del
animal sería un perro, y luego el ruido
sería un bar. Por ejemplo, se puede ver que
en realidad tengo tipos
anónimos en cascada Son bastante poderosos
en los que trabajan. Y puedes ver al igual que usando la palabra clave Var como antes, tienes control total
sobre el sentido de Intel. Puedes ver claramente todo lo
que especificaste aquí. Eso es bastante genial. Una cosa
que realmente no deberías hacer, pero puedes hacer es pasar estos tipos
anónimos a métodos. Echemos un vistazo a un ejemplo. Ahora bien, cuando antes hablé de
la palabra clave var, no se
puede tener var como parámetro para un
método, no funciona. Lo que necesitarías es la palabra clave dinámica en
la que esto funcionaría. Si entonces llamo aquí al método de
prueba, paso en nuestro animal aquí mismo. Y entonces podemos acceder a
él desde dentro de aquí. Pero porque estamos usando dynamic, si ves mi
tutorial dynamic, aquí no
tenemos acceso
al sentido Intell, pero podemos usarlo Sin embargo, de nuevo,
realmente no deberíamos usar dinámica
cuando no necesitamos hacerlo. Realmente solo se
recomienda usarlo cuando
absolutamente tienes que hacerlo. No veo mucha
situación en la que puedas estar pasando un
tipo anónimo a un método. Realmente, solo deberían usarse dentro de los métodos,
están definidos. Pero si necesitas hacer eso, entonces sí puedes hacer uso de la palabra clave dinámica
para sortear ese problema. Así se puede ver ahora
estoy usando dinámica. No tengo acceso
al sentido de Intel, pero ahora puedo pasar esto
a este método aquí. Así que vamos a comprobar y
ver si funciona. Así que puedes ver aquí
dando salida a ladrar, Parece que
funciona bastante bien Este es un ejemplo de tipos
anónimos en tienda
C porque es un
tipo anónimo y no tiene tipo. Por lo tanto, ahí es cuando
usarías la palabra clave Var. Y puedes ver aquí
puedes pasarle dos métodos, pero tendrías que usar la palabra clave
dynamic para pasarla. Pero no
recomiendo hacer eso. Por último, al crear tipos
anónimos, estas son solo propiedades, y una vez definidas,
se consideran de solo lectura. Y no puedes modificarlos, como puedes ver aquí mismo, esos son
tipos anónimos en tienda C.
70. 17-1. La palabra clave null: En este tutorial,
vamos a estar hablando de la palabra clave null. La palabra clave null se
parece a esto. ¿Cuál es la palabra clave null
y cómo se usa también? ¿Por qué deberíamos usarlo? Si viste mi tutorial
anterior cuando hablamos de memoria stack
y heap, y tipos de referencia
y tipos de valor, entonces vas a entender este tutorial muy rápidamente Aquí hay algunos objetos
de tipo referencia aquí, como listas, cadenas, matrices, objeto de
videojuego por ejemplo. Es una clase personalizada. Todos estos son tipos de
referencia, y están almacenados en el montón, que es el
área de pila de la Para contrastar eso, estos
son tipos de valores simples, entonces enteros, boolings y
caracteres Ahora bien, ¿alguna vez te has preguntado
cuándo declaras una variable, así que no la estamos inicializando, no les
estamos dando valores Se puede ver que el
software compila, funciona, No hay problema Los hemos declarado,
todo se ve bastante bien. Pero, ¿alguna vez has
pensado en cuáles podrían ser los valores predeterminados
para estos? Si en realidad no les
damos un valor, ¿cuál sería el
valor predeterminado? ¿Sería cero? Lo sería, ¿qué sería? Bueno, vamos a echar un vistazo. Voy a agregar un
punto de quiebre al final de aquí, y luego voy a mirar por la ventana
de los lugareños. Ejecutemos la aplicación. Ahora bien, si bajamos aquí a
la pestaña de locales aquí mismo, podemos ver varias
cosas que hacer con nuestras variables que
acabamos de definir. Aquí puedes ver nuestros tipos de
referencia. Tenemos nuestra lista aquí, tenemos nuestro objeto personalizado aquí, nuestra matriz de cadenas aquí mismo,
notarás algo. El valor actual es no. Pero si nos fijamos en estos tipos de
valores como el entero, el booleano y el carácter, o sus valores predeterminados
son ligeramente Por lo general, un tipo de valor
tendrá un valor predeterminado de cero. Si representas a Bolen como
cero, entonces sería falso. Un boolen como uno sería cierto. Se puede ver que Bolen también tiene
un valor predeterminado de cero. Incluso esta variable de carácter aquí tiene un
valor predeterminado de cero. Puedes ver un patrón aquí. Parece que los tipos de
referencia tienen un valor predeterminado de null o lo que sea null es los tipos de valor tienen un valor predeterminado de
lo que parece cero. En este ejemplo aquí, ¿qué está pasando aquí? ¿Recuerdas cuando
hablamos de tipos de referencia? Cuando tenemos un tipo de referencia, se crea
un puntero sobre la
pila. Pero la carne real
de la operación, los datos viven en el montón El puntero en la pila apunta
a los datos en el montón. Ahora hemos declarado un tipo de
referencia aquí. Por ejemplo, esta lista y
su valor predeterminado es nulo. Ahora lo que null está diciendo aquí
es que es una referencia nula. Tenemos nuestro puntero
en la pila de llamadas. Esto está en el
área de stack de la memoria, pero aún no tenemos
nada en el montón, no
lo hemos instanciado Eso significa usar
la nueva palabra clave. Cuando instanciamos algo
usando la nueva palabra clave, estamos creando algo en
el área de montón En esta parte estamos creando
el puntero sobre la pila. Esta parte en realidad estamos
creando los datos en el montón y por lo tanto
el puntero apunta a él. Sin embargo, en estos momentos no estamos instanciando
nada. Tenemos nuestro puntero
en la pila, pero no está apuntando a ninguna parte. No hay ninguna referencia a
los datos en la memoria de montón. Por lo tanto, el
valor predeterminado es null, lo que significa
una referencia nula. No va a ningún lado. Sin embargo, en cuanto
usemos la nueva palabra clave, entonces el valor cambiará de nulo y apuntará
a los datos en el montón Piense en nulo
como nada o un puntero nulo o
una referencia nula Realmente no va a ninguna parte, pero tal vez más tarde lo hará. Por ejemplo, puedes ver aquí, esto solo se aplica a objetos de tipo de
referencia, objetos complicados como los que
hablábamos antes. No se aplica a objetos de tipo
valor. Sin embargo, ahí hay un poco
de condición. Se aplica a los objetos de tipo
valor si
están marcados como anulables Ahora, vamos a
hablar de nullable más adelante. No te preocupes por eso. Pero para el propósito de este ejemplo, null se aplica al declarar objetos de tipo de
referencia porque necesitamos un puntero, pero no
tenemos uno El valor inicial es
nulo, que no es nada. Echemos un vistazo a un par de ejemplos que ahora trabajan
con la palabra clave null. Entonces lo que voy a hacer,
voy a dar salida a una propiedad, o tal vez tratar de usar uno de estos métodos aquí de
estos tipos de referencia. Sólo voy
a escribir en la ventana de la consola, voy a sacar una
propiedad aleatoria de esta lista. Por ejemplo, voy
a decir lista de conteo de puntos. Echemos un vistazo a
lo que está pasando aquí. Ahora tengo una línea roja. Se puede ver el uso de la lista de variables
locales no asignadas. Ni siquiera me deja usar este objeto
porque no está asignado Pero espera, pensé que
era nulo por defecto. Bueno, null por defecto
ocurre en tiempo de ejecución, no en tiempo de compilación. Esto es tiempo de compilación. En realidad estamos haciendo el
desarrollo aquí mismo. Esto es tiempo de compilación. Ni siquiera me deja
compilar la aplicación. Lo que tenemos que hacer
en tiempo de compilación, es simplemente inicializar
esto a null De esa manera el error
desaparece y de hecho podemos
ejecutar el programa. Pero el compilador nos está
ayudando aquí. Es decir, mira, esto es nulo. Realmente no deberías estar usando
propiedades en un valor nulo, de
lo contrario
va a caer. Pero al engañarlo, hemos hecho desaparecer ese error Entonces te puedo mostrar un ejemplo de usar algo
que es nulo. Ahora, la lista es nula. Estoy tratando de acceder a una
propiedad aquí llamada count on the null object list. Veamos qué pasa. Ahora un error ha surgido aquí y dice referencia nula, referencia objeto de
excepción, no establecida en una instancia
de un objeto Ahora verás mucho este
error en tus emprendimientos
avanzando con C Sharp. Es sólo una de esas cosas. Pero básicamente puedes ver aquí, nuestro tipo de referencia es nulo. Si algo es nulo, no
podemos usar métodos en él. No podemos usar propiedades en
él porque no tiene valor, no tiene memoria
almacenada en el montón Es más o menos
un puntero vacío de un objeto. Ahí
no hay nada. Es nulo, no podemos usarlo. Todo lo que tenemos que hacer es instanciarlo y realmente
darle algo. Ahora bien, si ejecuto la aplicación, puedes ver aquí el error se
ha ido porque hemos instanciado el objeto
y ya no es nulo Eso es algo para ser muy cauteloso cuando se
trabaja con null Creo que entiendes
el punto de nulo. Ahora, por ejemplo,
si tengo una cadena, eliminemos algunas
de estas cosas aquí. Si tengo una cadena, la
voy a llamar prueba. Voy a
inicializarlo a una cadena vacía. Y lo que estoy tratando de
decir es una cadena vacía, por ejemplo, no es lo
mismo que null. Hemos hablado de nulo. Sabemos que es una referencia nula. Lo que mucha gente hace, se confunden un poco con null. Piensan que es solo
un valor vacío, como una cadena vacía. Esto no es cierto en absoluto. Y te lo puedo demostrar si
acabo de montar un bolen por ejemplo Y tengo una condición
que compara esta cadena vacía de
aquí mismo con el valor nulo, y verás
que es falsa. Lo que estoy diciendo aquí es que
si test es igual a null, si una cadena vacía
es lo mismo que null, incluso
puedo escribirla así, ni siquiera necesito una variable. Entonces imprime el valor de
true si es lo mismo, lo contrario false si no lo es. Entonces puedes ver ahí, null no
es una cadena vacía. Un error de principiante,
quizás pensando eso. Pero pensé, había
mencionado que null no es lo
mismo que una cadena vacía. Nulo es simplemente una referencia nula. Una cadena vacía es solo
eso, una cadena vacía. Espero que esto
aclare qué es null y cómo es puede un usado
y por qué aparece En nuestro día a día haciendo desarrollo
de software.
Gracias por ver.
71. 17-2. Tipos de valores anulables: En este tutorial,
vamos a estar hablando de tipos anulables ¿Qué son los tipos anulables? En nuestro último tutorial, te
recomiendo que veas eso. Donde hablamos de
la palabra clave null, mencioné brevemente
que
los objetos de tipo de referencia como listas y
objetos y cosas, si no los
inicializan, obtienen el
valor predeterminado de null, que es un puntero nulo Sin embargo, para los tipos de valor, estos tienden a tener el valor
predeterminado de cero. Pero si tratamos de usar la palabra clave null con
un objeto de tipo valor, no
va a
funcionar porque realmente no
podemos darle
un puntero de referencia. Debido a que es un tipo de valor, almacena un valor como
3,456 por ejemplo, o true En realidad, almacena el valor de un tipo de valor en el área de
pila de la memoria. Entonces, ¿qué es un tipo anulable? Bueno, un
tipo de valor nulo como estos es una instancia en la que un
tipo de valor puede almacenar nulos Entonces, ¿por qué querríamos hacer
eso y cómo lo hacemos? Entonces, por ejemplo,
cuando antes intenté establecer esto como nulo, no
funcionó. No obstante, si agrego un signo de interrogación después del tipo de
datos aquí mismo, se
puede ver que el error
se ha ido, se ha resuelto. ¿Qué está pasando aquí? Bueno, para convertir un
objeto tipo valor como un en bola, un personaje, tipos simples. Si agregamos un signo de interrogación
al final aquí mismo, entonces esto representa un tipo de valor
nulo Ahora bien, esta variable es un
tipo de valor nulo. Ahora puede tomar un valor, o puede tomar la palabra clave null. ¿Por qué querrías hacer esto? ¿Cuál es el punto de esto? Bueno, imagina que tienes, por ejemplo, un registro de clases. Tienes un poco de
software y marca la asistencia de los alumnos
en tu salón de clases. Ahora digamos que tiene una base de datos adherida
dentro de la base de datos, tienes todos los nombres
de los alumnos, Nombre, apellido, todas esas cosas buenas. Y entonces tienes un booleano en la base de datos y el valor en
la base de datos se llamaría algo así como está presente Ahora bien, si los niños
ni siquiera han llegado todavía
al salón de clases, entonces no sabemos si
están presentes. Realmente no podemos decir verdad
porque no lo sabemos. En realidad no hemos
hecho el registro, en realidad no
hemos
verificado para ver qué alumnos
se presentaron a la clase. Pero si guardo el valor de caídas en la
base de datos por defecto, entonces simplemente puedo cambiar esto a true si están
presentes en la clase. Bueno, quiero decir, esto es decir
que no están presentes,
pero en realidad todavía no estoy
segura
porque no han llegado
al aula. En casos como este, es posible que
desee un tercer valor para un
Bolen, por ejemplo Quizás quieras nulo
si aún no lo sabemos. Si llega el alumno y
está aquí, podemos decir verdad. Pero si el estudiante está ausente, tal vez esté enfermo,
podemos decir falso. Entonces, en casos como este, podríamos querer un tercer valor. Y una palabra clave como null representa algo
así como un valor predeterminado, como no conocer
todavía el resultado, o algo así. Entonces, si no estamos seguros de
si están aquí todavía, entonces podríamos usar algo así como un tipo de datos anulable aquí,
que es el Y no sabemos si
están en la clase, así que sólo podemos
inicializarla a null Y en la base de datos para esto tal vez este campo estaría vacío. O incluso podría decir
nulo. No importa. Pero el punto es que
cuando los niños empiezan a llegar a la clase, entonces podemos
establecer esto en verdadero y falso. Y ese es algo así como el
principio detrás de esto. Te da una tercera
opción, por ejemplo. Y nuevamente, esto es
similar con los enteros. Podemos establecerlos como
nulos si no tenemos un valor específico para cualquier
número que queramos modelar. Entonces, algo así,
hay muchas razones
diferentes por las que hay muchas razones
diferentes por las podríamos querer un tipo de valor
nulo cuando trabajamos con tipos de
valores anulables
simplemente agregando un pequeño signo de
interrogación después del Sí te da algunas
opciones más. ¿Y por qué es eso? Bueno, tomemos aquí
esta variable, por ejemplo. Esto es anulable Ahora bien, si pongo un punto después, tengo acceso a un par
de propiedades aquí. Si elimino ese signo de interrogación, así tengo un simple bolen, se
puede ver que esas
propiedades han desaparecido. ¿Qué
está pasando aquí? ¿Por qué tengo estas propiedades
adicionales para un tipo de valor nulo Eso es porque detrás
de escena es una estructura muy
similar a una clase. En lugar de tener un
boolene simple como antes, donde solo podemos tener un
boolen y Podemos sacarlo a la ventana, podemos pasarlo a un método,
todas esas cosas buenas. Tenemos una estructura.
Piénsalo como una clase. Lo que
hace la clase en este caso
, solo expone dos propiedades Uno es el valor real de
nuestro tipo de datos anulables. Este ahora es el valor stop de
asistencia
sería valor stop de
asistencia
sería lo mismo que tener un tipo de datos
no anulable y usando eso podemos usar
la propiedad value aquí para obtener el valor subyacente
que sería verdadero o falso Por ejemplo, tiene otra
cosa
así llamada tiene valor. Ahora realmente podemos usar esta propiedad booleana aquí para
averiguar si tiene un Lo que normalmente
harías por algo como esto es tener una
declaración if y decir, bien, ¿tiene un valor? Bien, sí tiene un valor, por lo tanto podemos acceder
al valor e imprimirlo en
la consola, por ejemplo. Entonces algo como esto y hacer las cosas de esta manera y
tener estas propiedades disponibles para nosotros
evita cosas como excepciones de referencia
nulas o simplemente incluso comprobando nulos
por ejemplo. Es por ello que cuenta con estas
propiedades disponibles. Queremos comprobar que tiene un valor y luego podemos
utilizar el valor. Es por ello
que estos son bastante útiles. Y es por eso que cuando
defines un tipo de datos anulable, expone estas propiedades extra
para que las uses, porque te da esta
tercera opción que Si te preguntabas
si tienes un objeto de tipo valor nulo
y no lo inicializas, entonces el
valor predeterminado sería nulo, no cero en Debido a que es anulable,
el valor predeterminado es nulo en pocas palabras Ese es un ejemplo de tipos
anulables en tienda C.
72. 17-3. Los operadores de fusión nulo: Operadores de coalescencia nulos en C sonido agudo súper complicado.
Pero, ¿qué son? Bueno, uno de ellos se ve
así, dos signos de interrogación, otro se ve así, dos signos de interrogación
seguidos de n iguales. Pero, ¿qué son estos
caracteres aleatorios que estás escribiendo? Te escucho preguntar,
Permítame explicar los operadores de coalescencia
nulos
le permiten trabajar con tipos de
referencia como esta
lista aquí, Que podría ser nulo pero
podría no ser nulo. Además, los
tipos de valores anulables que podrían ser nulos o podrían ser
algo completamente diferente Echemos un
vistazo a un ejemplo aquí. Entonces aquí estoy creando una
lista de cadenas aquí, y esto se llama lista de
compras. Y esto va a contener todos los artículos de
mi lista de compras. Entonces voy de compras a continuación, tengo este tipo aquí, que es un entero y este
es el costo de mis compras. Ahora bien, voy a poner esto
por defecto a nulo porque aún no he
estado comprando. Ahora puede que encuentre el
tiempo para ir de compras, pero puede que no encuentre el
tiempo para ir de compras. Si voy de compras, entonces el costo representará
el valor de mi tienda. No obstante, si no puedo
molestarme en ir de compras, entonces va a
retener el valor de null porque aún no he
estado comprando. Por lo tanto,
no hay costo para mi tienda. Más adelante en la aplicación, ya sea que fui de compras o
si no fui de compras, eso realmente no importa. Pero quiero dar salida a
un mensaje que diga que mi costo de compra era entonces
el valor de la tienda. En un mundo normal con un tipo de datos
simple como este, quizás
lo inicializas a cero y luego, o podría tener otro valor Por ejemplo, ejecuto el programa, me
dice el costo de mi tienda. Sin embargo, si creo
un tipo de valor anulable como este y lo
inicializo a nulo, entonces normalmente uso la propiedad value para
acceder al No obstante, si esto
no tiene valor, quizá no encontré
tiempo para ir de compras, entonces si ejecuto el programa, aquí
tengo un error. Ya hemos hablado de esto antes. El objeto anulable
debe tener un valor. Puedes ver que estoy accediendo a
esta propiedad de valor, pero en realidad no estoy verificando para asegurarme de que tenga un valor. Lo que normalmente hago en este caso es solo tener
una declaración if aquí y verificar la propiedad tiene valor de este
tipo anulable aquí mismo Ahora digo que si
tengo un valor, entonces quiero sacar el valor. Esto parece que debería funcionar. Ahora parece que
no tengo nada. Pero no se está estrellando Al menos se ve bastante bien. Pero se puede ver cada vez
que intento acceder a este valor, estoy teniendo que hacer
una condición aquí. Tengo que hacer una
declaración if y
verificar que haya un valor ahí antes de que
finalmente pueda usarlo. Si quiero
sacarlo a la ventana, si quiero pasar
el valor a un método,
o a un método de una clase
o a otro lugar. Entonces básicamente tengo que
verificarlo antes de que realmente lo use. Pero, ¿y si te dijera que
hay una manera combinar estas
dos cosas en una sola? Ahora aquí es donde
presento a uno de los operadores coalescentes nulos, que son los dos Echemos un vistazo a cómo
puedo simplificar esto aquí. Voy a quitar el cheque
tiene valor ahí, y después voy a
quitar el valor de punto aquí. Entonces voy a
introducir uno de los operadores coalescentes nulos, que son dos Yo solo voy a usar
cero como ejemplo aquí, y voy a poner
paréntesis alrededor todo
el asunto para que
no arroje un error ¿Qué crees que
va a hacer esto ahora? O quizá no lo sabes, porque no lo he
explicado lo suficiente. Ejecutemos el software y veamos
realmente qué sucede. Yo ejecuto el software ahora, dice
que el
costo de compra era cero. Se puede ver, bueno,
el costo es nulo, pero por la razón que
sea, está dando salida a este cero aquí No obstante, si cambio el costo de 4567 y ejecuto la aplicación, ahora en realidad está
dando salida ¿Qué está pasando aquí? Bueno, este
operador de coalescencia nulo básicamente dice, si esto es nulo, entonces no hay valor, entonces evalúa lo que esté en el lado derecho de
estos dos signos de interrogación No obstante, si esto tiene un valor, cualquier cosa que no sea nula. Por ejemplo, evalúe este lado de los signos de interrogación e
ignore este lado por completo. Ni siquiera evalúes este lado. Entonces así es como funciona uno de los operadores no
coalescentes. Y se puede ver que ahí no
necesitamos esa condición. Está envuelto en una pequeña
declaración ordenada de dos caracteres aquí mismo, que son dos signos de interrogación. Entonces déjame ilustrarlo
un poco mejor, si acaso no lo
conseguiste la primera vez. Así que permítanme crear un método aquí. Y yo sólo voy a
llamarlo obtener costo por defecto. Entonces, lo que
va a hacer este método, va a devolver
un valor predeterminado para el costo si no se especifica ningún
valor. Simplemente va a devolver
cero con este operador de aquí. Solo estoy agregando una cadena al resultado de lo que sea que
esto evalúe O va a
evaluar hacia el lado izquierdo, que es el costo, o el lado
derecho que es cero. Sin embargo, no
sólo tiene que ser un cero o una simple variable. Podría ser el resultado de
todo un método, por ejemplo. Ahora bien, si esto es
nulo, lo que es, va a evaluar
lo que sea que esté de este lado. Podría ser de un tipo simple, podría ser un método. Ves que aquí hay
muchas opciones. Se llama evaluar. Si ejecuto la aplicación, ahora está dando salida a cero Y sólo para demostrar
que en realidad está ejecutando el método,
vamos a ejecutarlo. Nuevamente, se puede ver
que se está
evaluando el lado derecho porque
el lado izquierdo es nulo. Ese es el poder de los
dos signos de interrogación aquí, también
conocido como un operador de
coalescencia nulo Aquí está la sintaxis aquí, los dos signos de interrogación aquí. El uso es,
tienes un tipo anulable,
ya sea un tipo de datos
simple anulable,
o incluso podría ser
una lista, por ejemplo, porque los tipos de referencia pueden ser
nulos, como puedes nulos, como puedes Y luego en el lado derecho, tenemos algo que evaluar
si el tipo anulable, que es este del lado
izquierdo, es Hemos hablado de todo esto, pero esta es una buena visualización si no la
obtuviste la primera vez. Este es uno de los operadores de
coalescencia nulos Aquí mismo. Quiero introducir
ahora un operador coalescente
nulo más que se vea
algo así Se trata de dos signos de interrogación
seguidos de un signo igual. Y es bastante similar
al último ejemplo, pero tiene que ver también con la
asignación. Entonces, ¿qué significa todo eso? Bueno, echemos un
vistazo a este ejemplo aquí. Tengo una lista de enteros aquí. Y esta lista totalizará
todos estos gastos. Entonces todas las facturas que
pagué este mes, todo el costo de las
compras que he hecho este mes, y todo el costo total de gastar mi dinero
en cosas inútiles. Entonces todos estos
se agregarán a estos totales aquí como líneas de pedido
separadas Es una lista, así que quiero
agregar cada uno de estos
totales a esta lista Entonces podemos hacerlo con bastante facilidad. Podemos hacer uso del método ad que agrega esto a la lista, y luego podemos simplemente poner
los totales aquí, pero recuerda, es un tipo anulable, así que necesitamos usar
el valor aquí,
que se ve bien, pero oh, espera, Ahora tenemos que verificar,
tiene un valor. Tenemos que hacer uso
de esta propiedad. Oh, sí. Pero eso tiene que ir en una condición aquí para
asegurarse de que tiene un valor. Por ejemplo, entonces
podemos agregar el valor en. Esto debería funcionar, pero recuerda cuando dije que los operadores de
coalescencia nulos son atajos para todo No necesitamos todo
esto para nada. En casos como este, podemos hacer uso del otro operador de coalescencia
nulo, que son los dos signos de
interrogación y el ¿Qué hace eso y
cómo funciona eso? Digamos por ejemplo, estos se definen como nulos aquí, por cualquier razón
durante nuestro software, realmente no
estamos dando a estos ningún valor, permanecen nulos. Bueno, tal vez uno de
ellos tenga un valor, pero por cualquier razón algunos
de ellos aún pueden ser nulos. Llegamos a agregar
estos a la lista, solo
queremos agregar los
valores donde no sean
nulos porque no podemos agregar cosas
nulas a una lista. Aunque lo intentemos,
no va a letras. Lo que quiero hacer es si estos
tienen un valor como este, por ejemplo, entonces quiero
agregarlo a la lista. Este tiene un valor de 4567, así que quiero agregarlo. Sin embargo, si son nulos, entonces quiero agregar cero en su lugar o algún
otro valor predeterminado. Básicamente, no quiero
agregar null porque no puedo. En realidad hay una
manera rápida de hacer esto. Lo que puedo hacer es usar este
operador de coalescencia nulo seguido este
operador de coalescencia nulo seguido
de un cero. Reiniciemos eso. Qué hace eso, si esta
variable aquí es nula, entonces va a asignar
cero a esta variable, luego agregarla a la lista. Si esto es, si el lado
izquierdo de este operador
evalúa como nulo, lo
que hace porque es nulo, entonces esta variable recibirá el valor de lo que
esté en el lado derecho Recuerda, esto podría
ser un valor simple, podría ser un método
que tenga un retorno. Básicamente puede ser cualquier
expresión que pueda ser evaluada. Así que vamos a poner cero aquí. Lo que podamos hacer, podemos hacer
esto por todos estos. Queremos sumar todo nuestro costo
de las facturas, por ejemplo. Queremos, por supuesto, sumar el costo de gastar nuestro
dinero en cosas inútiles. Ahora mira lo que pasa si ejecuto el programa y agrego
un punto de quiebre aquí. Ahora baje a mis totales
aquí y amplío eso. Puedes ver que la lista
tiene todos los ceros aquí, que es el valor predeterminado
como puedes ver aquí No sólo eso, se puede ver esto reflejado en las propias
variables, ahora
tienen el valor de cero. Para ilustrar ese punto, sólo
voy a cambiar
uno por algo así. Voy a ejecutar el
software una vez más. Si llego a la
ventana local de aquí abajo, se
puede ver que esta variable en realidad
ha
conservado este valor. Se le ha asignado, ahora tiene un nuevo valor, 4567, y esto ahora se
refleja también en la lista Este operador de coalescencia nulo a signos de interrogación Si el lado izquierdo es nulo, entonces el lado izquierdo
recibirá el valor en
el lado derecho. Así es como
funciona este operador. Justo como antes. Escribiré un código de comentarios, para que pueda ver esto
ilustrado aquí mismo. Si el tipo anulable
se evalúa como nulo, por
ejemplo, el costo de compras es nulo y
es nulo en ese punto Luego evalúe lo que esté
en el lado derecho de este operador y
asígnelo al tipo anulable Obviamente, si el tipo
anulable es nulo, recibe el Esos son dos
operadores coalescentes nulos en C Sharp, cómo funcionan y también
por qué son útiles No es nada que ya
no puedas hacer con una condición para
verificar el valor, pero es un bonito atajo para minimizar el código y también
el tiempo de desarrollo.
73. 18-1. Parámetros con nombre y opcionales: Voy a introducir un
par de consejos ahora que puedes hacer al llamar a
métodos en C Sharp. Esto tiene que ver con pasar
los parámetros en. Voy a
hablar de lo que se llama parámetros con
nombre y también parámetros
opcionales en C sharp. Veamos este ejemplo aquí. Realmente no hace mucho. Tengo un método de muestra, toma varios parámetros, todos de diferentes tipos. Tenemos un objeto de videojuego, un par de números, una cuerda y también un booling Dentro del método, solo
estamos emitiendo la propiedad title
de este objeto de juego, que especificamos aquí arriba
en el constructor A continuación estamos sumando
los dos números juntos y
mostrando el resultado. Por último, tenemos una condición. Si el valor de esta variable
booling es verdadero, entonces estamos emitiendo
el Es un poco
guantelete de tareas. Realmente no tiene ningún
propósito en el mundo real. Es sólo para el
propósito de este ejemplo. Cuando llamamos al método, puedes ver que estamos
configurando un nuevo objeto aquí. Y luego estamos
llamando al método pasa en ese objeto y también el resto
de los parámetros cuando ejecuto el programa. Se puede ver que
prácticamente hace exactamente lo que dice hasta ahora al
llamar a métodos. Hemos estado llamando a
estos métodos con los parámetros en orden en
que aparecen. El objeto del juego es Primero
pasamos en el juego primero, seguido del número
uno. Número uno. Número dos, se puede ver
todo en el orden en que se
especifican mediante el uso de algo
llamado named parameter. No necesitamos especificar
los parámetros en orden. Echemos un vistazo a un
ejemplo de eso ahora mismo. Digamos que quiero cambiar la posición de estos
dos parámetros aquí,
Hola, y también
el booleano true Ahora quiero especificar primero
el bolen. Lo que hacemos, tomamos el
nombre del parámetro aquí y lo prefijamos con
dos puntos, así como así. Vamos a
especificar eso primero, ahora vamos a
especificar el mensaje. Después, hacemos
exactamente lo mismo. Tomamos el parámetro, agregamos los dos puntos,
y luego su valor. Ahora he intercambiado el orden
de estos dos parámetros. Para ello, tengo que
especificar el nombre
del parámetro sólo para decirle
al sistema cuál
pertenece a cuál. Nosotros solo arreglamos eso
con dos puntos aquí. Cuando ejecuto la aplicación, ahora tenemos exactamente
el mismo resultado. Estos se denominan parámetros. Se puede ver que solo cambiamos el orden de los dos
últimos parámetros. Los tres primeros permanecen
en el mismo orden. Que no necesitamos darles un nombre
a estos porque están en
el mismo orden. Sin embargo, si quiero nombrar mi primer parámetro y ponerlo en algún lugar
completamente diferente, entonces voy a tener que
nombrar cada parámetro único. De lo contrario, aquí vamos
a obtener un error. En este caso, no
necesito nombrar a los
tres primeros porque están exactamente en el mismo orden
desde el principio. Pero si muevo este juego hasta el
final, por ejemplo, y le doy a eso un nombre que se vea
algo así, entonces voy a
obtener este error. Y eso es porque necesito
prefijar todo lo
demás con el nombre. Ahora puedes ver que
el error se ha resuelto porque el juego se
ha movido fuera de posición. Y esa fue la primera. Por lo tanto,
no hay ningún pedido en absoluto. Entonces todos necesitarán un nombre. En este caso, ese es el
poder de los parámetros nombrados. Pero, ¿por qué es útil? Bueno, se podría argumentar que
mejora la legibilidad. Se podría decir a partir de la propia llamada
real, asumiendo que este método
estaba encerrado en una clase diferente
o en un archivo diferente, solo
tienes esta
visibilidad de tu parte, puedes ver claramente que la
mirada número uno tiene el valor de
este número dos, ya que esto
te da un poco más de información
sobre la llamada. Sin embargo, sí crea un poco más de código en
tu aplicación. Otra razón,
tal vez un desarrollador esté trabajando en este método. Aquí, el método aún no está terminado del
todo. Tienen quizá cinco
parámetros por ejemplo, pero quizá pronto
van a agregar un par más. Tu trabajo como tester
es probar el método. Estás probando el método
con estos cinco parámetros, pero no sabes
si el desarrollador va a agregar
más de ellos más adelante. Entonces, lo que puedes hacer, puedes usar parámetros con
nombre aquí para realizar cualquier prueba
que desees hacer. Cuando el desarrollador luego
agrega dos más en cualquier orden, realmente no importa, Entonces sabes que tus
parámetros no van a pasar a
otros diferentes por accidente. Por ejemplo, si
el desarrollador luego agrega dos parámetros
enteros más, entonces sabemos que el número uno y número dos serán
5.3 en este caso. Si el desarrollador agrega
3.4 por ejemplo, no
vamos a poner accidentalmente estos números en esas ranuras. En casos como ese, es bastante útil cuando
no estás
pasando accidentalmente parámetros
del mismo tipo a
diferentes parámetros. Literalmente estás diciendo, bien, este parámetro llamado esto
recibirá este valor. Eso es bastante útil. No se trata sólo de métodos. Esto se puede hacer en constructores y un par de otras
cosas también Si voy a esta clase de
videojuego donde hemos especificado este parámetro
al constructor, puedes ver que el constructor solo toma un argumento,
que es title. Al igual que al llamar a
métodos, por ejemplo, puedo prefijar esto con título y va
a compilar muy bien. No estamos limitados
a llamadas a métodos con parámetros nombrados
como estos. También podemos utilizarlos en constructores y otras
cosas así Entonces hablemos ahora de parámetros
opcionales.
¿Qué significa eso? Si tiene un parámetro
opcional, puede darle al parámetro un valor predeterminado si no se especifica ningún
parámetro. Por ejemplo, veamos
este mensaje de visualización Bolen. Aquí mismo, estamos pasando
en el valor de la verdad. Digamos que no
tenemos que pasar un valor. Pero podemos, si queremos, lo que podemos hacer aquí,
podemos decir, bien, si este parámetro no
se pasa a este método
display message, entonces vamos a configurarlo a
un valor predeterminado de true. Si se
omite el parámetro, no está ahí. Entonces cuando
luego se llama a este método, solo
va a
inicializar esto a true Si esto es cierto aquí, va a dar
salida al mensaje. Podemos echarle un vistazo a eso ahora mismo para ver si eso funciona. Se puede ver los
mensajes que se están emitiendo. Del mismo modo, si cambio este valor
predeterminado a false, entonces no vamos a
ver este mensaje en absoluto. No va a decir hola, lo
cual no lo hace. Al especificar
parámetros opcionales en C Sharp, tienen que ir tras
los parámetros requeridos. Por ejemplo, si hago del mensaje
un parámetro opcional, simplemente lo inicializo a un valor predeterminado de una cadena
vacía como esta Puedes ver que tengo
un pequeño error aquí cuando intento
compilar la aplicación. Por ejemplo, si acabo de
establecer esto en true, se
puede ver que hay un error. Si bajamos aquí, podemos ver este error aquí. Los parámetros opcionales deben aparecer después de todos los parámetros requeridos. Todos los parámetros opcionales
deben venir al final. Aquí puedes tener
tantas como quieras. Por ejemplo, podemos hacer de
message un valor predeterminado como una cadena vacía y también mostrar message como un valor
predeterminado de true. Entonces en realidad podemos
eliminar estos valores. Incluso podemos llegar a decir, bien, inicialicemos
estos dos números a cero si
no se especifican Así que ahí se puede ver, entonces no
necesitamos estos por ejemplo. Pero realmente depende de
tu propósito y de lo que
pretendes lograr si
ejecutamos la aplicación. Ahora podemos ver sumando los
dos números juntos, un cero porque los estamos
inicializando a cero, porque no estamos
especificando los parámetros Más o menos lo único que estamos haciendo es sacar el título
del videojuego aquí cuando en realidad llamamos a
este método aquí Si miramos la lista de
parámetros ahora puedes ver que aquí hay un poco
más de información extra. Se requiere un videojuego porque este es un parámetro
requerido. Sin embargo, puede ver que los parámetros
opcionales ahora tienen estas
llaves cuadradas alrededor También te da el valor
por defecto 00, una cadena vacía y también true. También te da algunos
comentarios sobre lo que se requiere cuando intentas
llamar a este método. Puedes ver cómo se
representan estos parámetros
opcionales al intentar llamar
a tus métodos. Nuevamente, no estás
limitado a llamadas de método. Con esto, igual que antes, se pueden
utilizar estos en
constructores y otra vez, algunas otras cosas también Índices delegados. Si configuro mi parámetro
al constructor como
un valor predeterminado, como una cadena vacía, entonces ya no necesito este
valor porque es opcional. Cuando ejecutamos la aplicación, solo
vamos a
obtener una cadena vacía. Puedes ver ahí, no
hay título de juego porque el valor predeterminado
es una cadena vacía. Este es el poder de los parámetros
nombrados y también
los parámetros opcionales En C sharp. Abre las cosas a un
nuevo reino de posibilidades. Espero que este tutorial
te haya ayudado y feliz codificación.
74. 18-2. Palabra clave out: Voy a hablar
sobre la palabra clave out en C sharp y por qué es útil. Considera este
ejemplo aquí mismo. Este método, lo que
hace, toma en cuatro parámetros. Lo que quiero hacer
es sumar estos dos juntos y luego restar
estos dos juntos Ya ves que estoy haciendo eso aquí. Estoy obteniendo el resultado
de la suma en esta variable y el resultado de la resta
en esta variable Pero, ¿cómo devuelvo
ambos? Cuando hablamos de
devoluciones en métodos, podemos devolver un tipo aquí, pero solo podemos
devolver un valor. ¿Cómo podría tal vez 235 cosas diferentes de
un método? ¿Eso es posible? Bueno, en respuesta corta, sí, podemos usar la palabra clave
out para hacer esto. Y ves la palabra clave out
utilizada en muchas instancias. Por ejemplo, un método podría hacer algunas operaciones y
devolver un resultado. Pero también queremos devolver
tal vez si el método fue exitoso o tal vez un registro de cualquier error que
haya ocurrido en el camino. No sólo necesitamos el
resultado fuera del método, sino que tal vez necesitamos
más información sobre cómo manejó las cosas, ya
sabes, qué errores ocurrieron o prácticamente
cualquier cosa por el estilo. Entonces echemos un vistazo a la palabra clave out y
cómo es útil. Ahora la palabra clave out
sobre cómo se comporta, es muy similar
a la palabra clave ref. Si no viste
mi tutorial sobre la palabra clave ref o pasando
tipos por referencia a métodos, entonces
te recomiendo que lo compruebes. Lo que voy a hacer aquí, he definido dos variables
locales aquí,
resultado, sumar y restar
resultados, y las he inicializado a
cero. Ahora mismo los estoy
sacando a la ventana. Dentro del método, estoy haciendo más
o menos
exactamente lo mismo, pero quiero que estos
resultados de aquí se
reflejen en estas variables para reflejen en estas variables poder
enviarlas a la ventana, porque ahora mismo no puedo
sacar estos dos valores de este método. ¿Cómo hago eso? Echemos un vistazo al uso de la palabra clave out, lo que puedo hacer dentro de la lista de
parámetros aquí. Para este método, puedo agregar un parámetro extra
con la palabra clave out. Lo que quiero hacer,
quiero devolver ambos valores
fuera del método. Voy a tener dos variables
afuera aquí. El primero va a ser
el resultado de la adición. El segundo va a ser el resultado de la resta Ahora bien, debido a
que estos se están pasando
al método con sus
propios tipos y nombres propios, entonces no
puedo darles un tipo completamente
nuevo. Yo los quito. Así es
más o menos como funciona. Ahora puedes ver que aquí
ha surgido un error. Y cuando coloco el cursor sobre ese
dicho no hay argumento dado que corresponda
al parámetro requerido, básicamente necesito especificar
dos parámetros adicionales El número de parámetros
coincide con la definición. Aquí, necesito dos más. Cuando tienes la palabra clave out en la declaración del método aquí, también
necesitas especificar la palabra clave out al
llamar al método. Esto es lo que
voy a hacer aquí. Si viste mi video
sobre la palabra clave ref y pasando tipos de valor y tipos de
referencia a métodos, sabrás que cuando pasemos algo a un
método por referencia, podemos modificar los valores
dentro del método y estamos haciendo referencia al área de memoria donde se encuentran
estas variables. Esto es lo que hace la palabra clave
out. Pero aquí hay una
diferencia sutil entre la palabra clave ref y
la palabra clave out. Es decir, las variables
no tienen que ser inicializadas antes de
pasar una variable con la palabra clave out. ¿Qué quiero decir con eso? Bueno, en realidad veamos si
este ejemplo funciona Primero, antes
de adelantarnos, estoy pasando 20 valores
como parámetros de palabra clave fuera. Están entrando en el método, y luego en realidad estamos
estableciendo los valores aquí mismo. Echemos un vistazo. Se puede ver que obtenemos el resultado esperado. Dos más dos es 4.6
menos cuatro es dos. Sí funciona. Y en realidad
estamos obteniendo ambos resultados de estos
devueltos fuera del método. Pero en realidad no está
regresando del método, es solo modificar
estos dos objetos de valor ya que se están pasando por
referencia a este método, entonces solo estamos
dando salida a los Dije antes, había una diferencia
sutil entre la palabra clave out y
también la palabra clave f. Y es que al
usar la palabra clave out, las variables que se pasan
no tienen que inicializarse, eso significa que
no necesitan un valor Todavía va a funcionar
cuando ejecute el software. Ahora se puede ver
que tienen valores. Y eso es porque
cuando las cosas se pasan a un método aquí, tenemos que darles un valor. Si no hacemos eso, estamos pasando una variable. Aquí puedes ver que hay un
error y dice que se debe asignar el
anuncio de resultado antes de que termine el método. Así que tenemos que hacer algo con estos parámetros aquí
fuera. Tenemos que hacer
algo con ellos, darles un valor,
inicializarlos, hacer algo que sea la sutil diferencia
entre out y ref. Pero generalmente, la
palabra clave out te permite, en cierto modo, devolver más de un
elemento de un método, y esa es su potencia principal. Realmente otra cosa, no
tenemos que definir nuestras
variables aquí. De hecho, podemos
definirlos a todos en una sola línea. Si elimino completamente estas
variables entre la palabra clave out y
la variable solo tecleo in, int, por ejemplo,
para el tipo de datos. Ahora estamos definiendo nuestras variables en una
línea de código aquí. Y se puede ver que
se ve mucha idea. Entonces los estamos definiendo aquí, luego
los estamos pasando en todo en uno. Y luego está haciendo algo, echándolos de vuelta. Y luego estamos
sacando los resultados. Para que veas que obtenemos los
mismos resultados aquí mismo. Entonces ese es el poder de la palabra clave
out en C sharp.
75. 18-3. Palabras clave en: Voy a hablar de
la palabra clave en C Sharp. Ahora, tengo un ejemplo muy
sencillo. Aquí estoy llamando a un método que
suma dos números juntos. Cuando se llama al método, estamos relleno el resultado
de estos en una variable, y dando salida al resultado
sumando dos más dos, obtenemos la salida de cuatro ¿Cómo
entra la palabra clave en esto? Bueno, cuando usamos la
palabra clave en un método aquí, podemos especificar esto antes de
cualquier parámetro que queramos. Por ejemplo, el número uno, lo que hace la palabra clave, nos impide
modificar en absoluto este valor. Entonces si tratamos de decir
establecer un valor así, por
ejemplo, se puede ver que el
software ni siquiera compilará. Cuando resaltamos esto
y colocamos el cursor sobre él. Dice que no se puede asignar variable int
porque es de solo lectura. En realidad nos impide hacer cualquier cosa con
esta variable. Aquí de nuevo, podríamos poner esto en cualquier número de
parámetros que queramos. Se trata de
tipos de valores simples, enteros simples. Echemos un vistazo a cómo funciona
esto con los objetos. Por ejemplo, puedes ver aquí tengo un ejemplo
con un objeto aquí, como videojuego por ejemplo, estoy configurando el título del
juego a través del constructor a Minecraft y simplemente
sacando el título del juego Pero si trato de
modificar este objeto alguna manera al especificar
la palabra clave in, entonces va a arrojar un error de solo lectura
similar. Puedes ver aquí estoy borrando el título
configurándolo en una cadena vacía Pero está diciendo que no se
le puede asignar, es de sólo lectura. Del mismo modo, si intento crear una nueva instancia a partir de
esto completamente, entonces tengo exactamente
el mismo error. Este es el poder de
la palabra clave en C sharp. Evita que cosas como
métodos
modifiquen accidentalmente cualquiera de tus parámetros que deseas pasar. Si sabes que este método no
es
responsable de modificar tus
parámetros de ninguna manera, entonces podrías
considerar
especificarlos con la
palabra clave in para proteger tus datos y evitar que los
métodos cambien alguno de tus datos y que ocurran cosas
inesperadas, lo que puede suceder bastante
, créeme. Pero la belleza de
la palabra clave es sí, podrías pasar
aquí una constante o una variable de solo
lectura, por ejemplo. Pero tal vez tus objetos no son de solo
lectura o constantes, sino
que solo quieres que se
lean temporalmente solo por la
duración del método. Ese es el punto de
la palabra Q en tienda C.
76. 18-4. Palabra clave de los params: La palabra clave Perms en C sharp. Se ve así y
es la abreviatura de parámetros. Pero, ¿qué significa
y qué hace? Echemos un
vistazo a este ejemplo. Aquí mismo tengo un método que agrega algunos
enteros simples juntos Toma cuatro parámetros, los suma todos juntos y genera el resultado. El método los toma
de lo que sea que lo llame. Estamos sumando 224.5 Vamos a sacar el
resultado. Ahí está ahí. Por ejemplo, si quiero sumar dos
números juntos, lo
mejor quiero sumar
tres números juntos. O tal vez 17 números juntos. Pero quiero lo mismo, sólo
quiero un método. Quiero el mismo método y un método para sumar todos
estos números juntos. ¿Cómo puedo lograr eso? Bueno, a lo mejor podría
crear un objeto personalizado, por ejemplo, alimentar
en todos los números. O tal vez crear una lista y agregar todos los números a la lista. Entonces puedo pasar la
lista a este método. Esencialmente, eso es lo que hace
la palabra clave de los cochecitos. En este caso, cuando
uso la palabra clave Cochecitos,
escribo aquí Cochecitos en la firma
del método Aquí es un parámetro en sí. A continuación pongo el tipo de datos. El tipo de datos puede ser
prácticamente cualquier cosa detrás de escena. Utiliza el tipo de datos de objeto, que es de lo que todos los
tipos de datos derivan de todos modos. Pero estamos usando entero. Podemos usar
objetos personalizados si lo deseamos. Instancias personalizadas, realmente
no importa. Yo solo voy a llamar a esta lista porque esta lista va a contener todos nuestros números que vamos pasando
a este método. Ahora, al trabajar con listas, vamos a usar
algo así como un
bucle para recorrer cada
elemento de esta lista. Así podemos sumar todos los números juntos. Hagámoslo ahora. Inicializamos una
variable a cero. Esto mantendrá un recuento de todos los números que
estamos sumando. Eso debería funcionar ahí mismo. Estamos recorriendo
cada número de la lista. Estamos manteniendo una cuenta corriente, agregando todo a
este resultado aquí, y luego sacándolo. Vamos a obtener
el mismo resultado Aquí, se
puede ver 13. Ahora bien, este es el poder
de la palabra clave params. Mira esto. Bien, he modificado el
argumento de llamada aquí para agregar muchos más
parámetros a esta lista, pero puedes ver que no ha
causado ningún problema. Este es el poder de
la palabra clave params. Si tuviéramos que construir
una lista, por ejemplo, y pasar esto al método, entonces tendríamos que modificar
la lista de esta manera también. Pero se puede ver como esto no
causa ningún error en absoluto. Podemos compilar el software
y podemos ejecutar el software, y tenemos nuestro
resultado esperado aquí mismo. Este es el poder de
la palabra clave params. Nos permite usar
un método para aceptar un número variable de
parámetros del mismo tipo, y luego puede trabajar
con esa información. Ahora bien, hay algunas reglas
asociadas a esto. Sólo puede haber
una palabra clave params por declaración de método, por
ejemplo No podemos tener dos de estos como, así que no va a funcionar. En segundo lugar, la palabra clave params debe llegar al final
de todo aquí Si tengo más de
un parámetro aquí, parámetros deben estar al final No puede ser al principio, no puede estar en el medio. Por lo que puedes ver que se
ha producido un error aquí, porque debe estar
al final de la lista. Y por último, los parámetros aquí deben ser una matriz
unidimensional No puede ser una matriz
bidimensional, No puede ser nada
raro así. Entonces hay algunas de las reglas asociadas con la palabra clave
params Entonces ese es el poder de la palabra clave
params en C sharp. Sí, hay otras formas de
lograr los mismos resultados, pero cuantas más herramientas
tengas en tu caja de herramientas, mejor desarrollador
te convertirás. Entonces esa es la
palabra clave params en C sharp.
77. 19-1. Enumeraciones - el tipo de enum: Quiero hablar de
enumeraciones en C Sharp, también conocidas
como enumeraciones Y la palabra clave se ve
algo así. Pero, ¿qué es una enumeración y
por qué debería usarla? Bueno, tengo un
ejemplo aquí mismo. Aquí estoy configurando cuatro objetos de
videojuegos. Toman diversos parámetros. Echemos un
vistazo a la clase ahora. Entonces puedes ver que se
necesita una consola, un título de videojuego, un editor de videojuegos
y una calificación. Entonces, prestemos atención a esta cadena
de calificación aquí mismo. Lo que quiero hacer, solo
quiero
permitir ciertas calificaciones
para todos. Diez más adolescentes, maduros, 17 más, etcétera, etcétera. Yo sólo quiero que se pasen
estos
valores y solo quiero
tratar con estos valores. Pero
a la hora de configurar estos objetos, se
puede ver que los estoy
metiendo aquí. Pero es muy fácil
cometer un error. Podría hacer un error ortográfico, tal vez una minúsculas,
algo así Si esta aplicación está
conectada a una base de datos, entonces hay un poco de problemas. Voy a estar almacenando valores
incorrectos y todo el
sistema puede estropearse. Si alguien quiere
buscar un juego, por ejemplo, y la calificación es incorrecta
porque se ha escrito mal, entonces tal vez si está
buscando por calificación, este videojuego podría no
aparecer nunca en la Muchas razones por las que necesitamos que nuestros datos sean
concisos y precisos. Una forma de abordar este
problema de asegurarnos de que no haya errores
ortográficos para esta variable de cadena. calificación, por ejemplo, es usar algo llamado
enumeración o enumeración ¿Cómo configuro eso
y cómo lo
integro a mi clase de
videojuegos aquí? Bueno, vamos a echar un vistazo. Pasemos
al lado derecho aquí donde tenemos nuestro proyecto. Vamos a escribir Click, Ir a Agregar, y luego ir a clase. Vamos a llamar a esto algo que
represente nuestra calificación. Ahora bien, si tenemos una pieza de software muy
grande, podríamos querer ser realmente
descriptivos con esto. Creo que tal vez la calificación de los
videojuegos es buena. Sin embargo, a veces cuando
creas una enumeración, podrías tener una clase con
exactamente el mismo nombre y no puedes crear una
clase con el mismo nombre Lo que mucha gente hace al
crear una enumeración es agregar la palabra estado
o escribir después Entonces cada vez que crean uno, bien termina en estado o tipo. Realmente depende de ti,
no importa. Pero voy a
llamarlo algo así. Así que presta atención aquí, notas
que es una clase
aquí cuando hago clic en Agregar, así que si venimos a la izquierda, ahora tenemos un tipo de clasificación de
videojuegos de clase interna. Bueno, no queremos una
clase, queremos una enumeración. Y no había
plantilla para eso, así que ahora tenemos una enumeración Es tan simple como
cambiar de clase a enumeración. Tenemos una enumeración aquí
mismo. Entonces, ¿cómo funciona esto? Bueno, vamos a
nuestra clase de videojuegos aquí y tomemos nuestras calificaciones
permitidas. voy a poner aquí como comentario para que pueda hacer
referencia a ellos. Y quiero crear un ítem en la enumeración para
cada una de estas calificaciones Entonces quiero a todos
diez más adolescentes, maduros 17, etcétera Entonces quiero todos estos
ítems en esta enumeración. Y la enumeración
es como una lista. Entonces como una lista de valores. Y esta lista no es solo una lista, sino que es como una lista de solo lectura. No podemos modificar
esta información. Es prácticamente de solo lectura, así que lo usamos para referirnos
a estos valores. Todo se
aclarará momentáneamente. Lo que voy a hacer es crear algunos valores para cada una
de estas calificaciones. En la enumeración voy a comenzar con lo que
representa para todos Una vez que he creado un valor, pongo una coma y
luego una nueva línea Ahora puedo hacer la siguiente.
Ahora hay un problema. Una vez que he escrito diez, eso es porque en las enumeraciones, tus elementos no pueden contener números o ciertos caracteres
como este símbolo más Vamos a tener
que escribir esto. En este caso
podemos decir diez más, y eso funciona bien. Vamos a continuar. He escrito una enumeración aproximada
aquí
se puede ver que tenemos todos estos valores reflejados
en la Podemos agregar más en una fecha
posterior si así lo deseamos. Ahora bien, ¿cómo funciona esto? ¿Cómo podemos poner esto
en nuestra clase? Bueno, esto ahora es
como un tipo de datos realmente donde antes teníamos una clasificación de
cadena. Podemos usar esta
enumeración aquí mismo. Si vamos a nuestra
clase aquí mismo, reemplazamos la cadena con el tipo de calificación de
videojuegos. También lo reemplazamos
en el parámetro y también cualquier método que podamos
tener aquí. También ahí. Y parece que
tenemos un problema, y eso se debe a la accesibilidad. Por defecto, nuestra
clase es interna, pero debido a que nuestra clase de
videojuegos es pública, también
necesitamos hacer pública la
enumeración Ahora, todos esos errores se
han ido. Ahora, en realidad hemos cambiado el parámetro a
nuestro constructor, a un tipo de enumeración Echemos un vistazo a cómo
construimos estos objetos ahora. Ahora puedes ver que hay errores en todos estos aquí mismo. Intentemos cambiar a este adolescente
para usar nuestra enumeración. Si pongo una coma aquí, pueden
ver los intellisens,
el autocompletar ha
elegido Sólo vamos a hacer
doble clic en eso. Entonces vamos a poner un punto. Ahora puedes ver que aquí hay
una buena lista. Si alguien quiere
construir estos objetos. Ahora no pueden simplemente
poner cualquier valor. Mira, requiere un tipo de calificación de
videojuegos. Se puede ver en la lista de
parámetros. Pero ahora simplemente no
podemos poner nada. Tenemos que elegir
algo de esta lista. Si no lo hacemos, entonces
la aplicación ni
siquiera compilará
porque hay un error. Puedes ver cómo esta enumeración nos
obliga a elegir un
ítem de esta lista Ahora podemos decir
adolescente, por ejemplo. Ahora bien, si reemplazamos cada uno de
estos con la enumeración, puede ver cuando estamos
construyendo estos objetos, ahora se va a quedar
algo así Se puede ver que esta
es una idea bloqueada. Pero no sólo eso,
obliga a las personas o piezas de software o cualquier
otra cosa a no cometer errores
en nuestra información. Realmente no usarías
esto para algo como tal vez Blizzard o
World of War Crafts porque estos son únicos Sin embargo, quizás la
consola podría representar una enumeración porque
solo hay un
número finito de Ya sabes, tienes la caja
Playstation X o PC. Entonces esto nuevamente podría ser
representado por una enumeración, pero para algo así como calificación, esto parece un
candidato perfecto para tener como enumeración cuando se
trabaja con enumeraciones Por ejemplo, tal vez
estos videojuegos se almacenan en una base de datos. Ahora, esta base de datos
tendrá el nombre del videojuego, el título, y puede que no tenga el
nombre completo de la enumeración en la base Podría tener un
número entero como 01 o dos. Cada uno de estos
números enteros podría representar una calificación diferente
en la enumeración Por ejemplo, cada uno
sería 010 más sería uno, adolescente sería dos, etcétera Cuando define enumeraciones
en Visual Studio, hay un tipo subyacente
que significa en segundo plano Por defecto, cada uno de estos tiene un valor
que es un entero. Y te voy a mostrar
lo que quiero decir con eso. Esto genera una de estas enumeraciones a
la ventana de la consola Yo solo voy a sacar
video juego rating type teen. Probablemente solo
va a decir eso en la propia ventana, solo
dice adolescente. Pero mira lo que pasa si
convierto esto en un entero. Entonces si ejecuto la aplicación, ahora ves que tiene
el valor de dos. Por defecto, hay un entero
subyacente aquí. Eso es porque por defecto
el primer ítem es 012345. Esto se hace por defecto. Es un comportamiento predeterminado, pero en realidad
puedes
cambiarlo si lo deseas. Puedes especificar tus
propios valores para estos. Por defecto, se ve
algo así. Todos tienen el valor de cero. Este tiene el valor de 12345. Así es como se
ve detrás de escena. Estos tienen estos valores enteros. Puedes referenciarlos con el número o puedes
referenciarlos con el nombre. La elección depende de usted. Pero normalmente, cuando almacenas algo como esto tal vez
en una base de datos, o estás pasando estos valores a una
pieza diferente de software, entonces tal vez estés enviando el entero solo porque es más pequeño y es
más fácil trabajar con él. Es por ello que las enumeraciones
tienen un tipo subyacente. Considera esto como
un índice por ejemplo. Pero como dije,
puedes configurar tus propios tipos pero
también tus propios valores. Por ejemplo, quiero que
este sea diez, que ese sea 2030, 40, 50. Realmente no importa, la elección depende totalmente de ti. Y ahora si
volvemos a sacar esto a la ventana de la consola, se
puede ver que diez ahora
tiene un valor de 22, y eso es porque
le dimos el valor de 22. No sé por qué hicimos eso, pero se puede ver así es
como funciona el principio. Entonces básicamente detrás de escena, usa un entero, pero puedes cambiar esto a un tipo de datos
diferente si lo deseas, como un byte o un largo
o algo así. La elección realmente depende
de usted, pero por defecto. Se ve algo así. Si quieres cambiar el tipo, puedes agregar dos puntos después
y poner el nuevo tipo aquí. Cuando tienes un tipo aquí, entonces todos estos valores deben seguir el
tipo que especifiques. Quizás esto podría ser algo que no uses de inmediato, pero siempre es bueno
tener en
mente este conocimiento para cuando quieras
aplicarlo en una fecha posterior. Pero estas son las posibilidades y cosas que puedes hacer
con las enumeraciones. Lo que también es bastante común es
si se tiene una enumeración,
por ejemplo Todas estas son calificaciones de
videojuegos. Puede que no quieras
especificar una calificación, pero el usuario, se le da
una opción de seis opciones. Pero, ¿y si es opcional? Entonces, lo que suele hacer mucha
gente, definirán un ítem llamado non y generalmente
le darán un valor de cero. O podrían darle un valor de 999 y ponerlo al
final, por ejemplo. Pero esto es solo un ejemplo de cómo puedes hacerlo opcional. No sería el
campo opcional en este caso. Si no es obligatorio, lo contrario puedes seleccionar
una calificación aquí mismo. De nuevo, eso solo se refleja al elegir el
elemento no de la lista. No hay calificación para este juego, en cuyo caso es opcional. Ahora, enumeraciones. Hay mucho más en
las enumeraciones, y se puede hacer
mucho más con ellas. Aquí hay una clase estática
llamada enum, puedes usar varios métodos
para hacer con tus enumeraciones Se puede obtener el tipo subyacente como el entero del que
hablamos antes. Y se pueden hacer varias cosas. Así que, como que acabamos de
rayar la superficie aquí. Pero lo que voy a mencionar
es una cosa para mantener tus proyectos
un poco más organizados. Si venimos a la derecha aquí y damos
clic derecho a nuestro proyecto, y lo que tiendo a hacer es agregar
una nueva carpeta aquí mismo, y suelo llamar a esto enumeraciones Dentro de esta carpeta, pongo todas mis enumeraciones solo
para que estén más ordenadas Entonces de esa manera porque tienen la misma
extensión de archivo que una clase, entonces
realmente no te confundes. Puede ocultar
todas sus enumeraciones
en una carpeta de enumeración. Si recuerdas cuando
hablamos interfaces en el tutorial de la
interfaz, cómo tienen la palabra clave
interface y no la palabra clave class, entonces también puedes crear una carpeta
para tus interfaces. Esto es bastante común.
Simplemente mantiene las cosas organizadas simplemente porque
tienen la misma extensión de archivo. Si tienes una aplicación muy
grande con cientos de clases, puedes encontrar fácilmente tus enumeraciones solo porque todas
estarán en un
directorio llamado enums,
un buen poco de organización al trabajar con interfaces
Y además enumeraciones, enumeración Evita faltas de ortografía
o algo por el estilo. Y es muy útil
cuando se tiene una lista finita de artículos, por ejemplo,
consolas o ratings Quizá al trabajar con
trajes en una baraja de cartas o representar meses del año o
algo así. Pero recuerde, los elementos de enumeración se leen solo como constantes, por lo que no puede asignarles
nada, así que considérelos como de lectura
solo cuando trabaje con ellos Entonces eso es enumeraciones en tienda.
78. 19-2. Recursión y manejo de archivos (archivo IO / System.IO): Ahora voy a hablar de
un concepto completamente nuevo. Y ese concepto se
llama recursión. Si estás familiarizado
con la informática, o tal vez has hecho otros lenguajes de
programación, o incluso matemáticas. A lo mejor ya has oído hablar de esta palabra antes, pero a lo mejor no la has hecho. Entonces, ¿por qué estoy en Google?
Te oigo preguntar. Bueno, cuando empecé mis emprendimientos de
programación, recursión fue algo
que realmente me confundió. Alguna vez has visto
la película Inception, donde el tipo se va a dormir
y luego está en un sueño, pero luego se va a
dormir en el sueño. Y como que juega con tu mente y te
preguntas, ¿está soñando? ¿En qué capa de sueño
está o vuelve a estar despierto? Ya sabes, es muy confuso. Y los sueños anidados
en esta película siempre me
recordaron el concepto de recursión y verás por Pero ojalá en este tutorial, lo
voy a desglosar en sencillos pasos para que lo
entiendas
mucho más fácil de lo que
una vez lo hice cuando
empecé a aprender. Y te
voy a mostrar por qué. Si buscas en Google el
término recursión, obtienes una descripción aquí El proceso de
definir un problema o una solución en términos de una versión
más simple de sí mismo. Por ejemplo, puedes
definir una operación, encontrar el camino a casa como
si estuvieras en casa. ¿Entiendes a lo que me refiero aquí? No está muy claro, ¿verdad? Y cuanto más te desplazas, más confuso te pones. Es sólo una de esas
cosas sobre las que te arrancas el pelo y
cuando miras las imágenes, bueno, las imágenes tampoco ayudan
realmente. Simplemente obtienes este tipo
de imagen por aquí de algo dentro de otra cosa y solo se repite para siempre. Entonces déjame
explicarte qué es la recursión. Ayuda al mirar la
recursión en C Sharp en Google, y te da una
mejor explicación de lo que es en
términos de C Sharp recursión es un concepto en el
que un método se llama a sí mismo, y es exactamente eso En el mundo de C sharp, se define un método y el
método entonces se llama a sí mismo. Ahora bien, ¿por qué un método
querría llamarse a sí mismo? Bueno, si tienes funcionalidad dentro de un método para hacer algo, entonces tal vez quieras
reutilizar ese código. ¿Por qué no? La programación se
trata de reutilizar código Ahorra tiempo, es
más fácil de mantener y hay muchas otras
razones para hacerlo. Esto es lo que vamos
a estar viendo hoy, recursión en C sharp, y vamos a definir un
método que se llama a sí mismo Estamos por aquí
en Visual Studio. Ahora lo que quiero hacer es configurar un método
que se llame a sí mismo. Si ves algún otro
tutorial sobre recursión, probablemente
verás
algo donde tienes que elaborar el factorial
de un número cuatro Factorial es uno por dos, por tres por cuatro Y luego configuras
un método para hacerlo. Creo que ese es un ejemplo bastante
débil y aburrido. Creo que podemos usar algo tal vez podamos aplicar
en el mundo real. Creo que una función de búsqueda
es realmente buena para eso. Lo que quiero hacer, quiero
presentarles mi muy
mala colección de música. Aquí puedes ver que
es bastante ecléctico. Aquí tenemos todos los géneros
diferentes. Lo que quiero hacer es especificar un término de búsqueda y
ese podría ser cualquiera, podría ser el nombre de una banda, podría ser el nombre de una
canción, cualquier cosa por el estilo. Quiero devolver todos los archivos
de música que
coincidan con este criterio. Entonces vamos a pedirle al
usuario un término de búsqueda, el usuario lo va a escribir. El resultado serán
las rutas completas de todos nuestros archivos de música. Ahora bien, esta colección de música
está muy desorganizada, ahí por qué necesitamos una función de
búsqueda aquí Tengo una carpeta de música aquí, y dentro de esa tengo una carpeta llamada aún más música ahí dentro. Tengo todas estas carpetas nuevas, y después tengo música
salpicada por todas partes. Creo que una función de búsqueda podría ser algo bueno
para este ejemplo. El problema, necesito
algo para obtener los directorios
dentro de una ruta de archivo que proporcione el software. Entonces si proporciono el software, esta ruta de archivo aquí, lo
necesito para obtener
los directorios. Lo segundo que
tengo que hacer es obtener el software para obtener todos
los archivos en un directorio, y verificar a su vez cada uno de estos archivos para ver si
coinciden con los criterios de búsqueda. Necesita hacer dos trabajos. ¿Y por qué este escenario es un
buen ejemplo de recursión? ¿Cómo puedo aplicar un
método recursivo a este ejemplo? Bueno, quiero obtener
los directorios y
los archivos para cada
directorio de aquí. Yo quiero hacer la
misma lógica aquí. Quiero obtener estos
directorios, estos archivos. Y luego dentro de estos
directorios, quiero comprobarlo. Hay más directorios
entonces también obtienen los archivos. La lógica de los métodos
se aplica prácticamente a cualquier
directorio aquí. Quiero reutilizar
la funcionalidad. Quiero usarlo aquí inicialmente. Entonces quiero cavar
dentro de estas carpetas. Sigue cavando hasta que no
haya más, y luego revisa los archivos aquí. La recursión será un
muy buen ejemplo de algo que podemos usar para este escenario
en particular aquí Echemos un vistazo a
cómo podemos hacer eso. Ahora estoy por aquí en
Visual Studio. Lo que tengo que hacer
es crear un método. Y el método se
va a llamar a sí mismo. Y el trabajo del método es
esencialmente buscar un archivo
que el usuario especifique. Vamos a configurar eso ahora. Lo primero que
quiero hacer es pedirle al usuario un
término de búsqueda. Hagámoslo. Entonces quiero aceptar
la entrada del usuario. Ahora tengo el
término de búsqueda del usuario. Quiero llamar a un método. Vamos a configurar un método que en realidad va
a hacer la búsqueda. Voy a llamar al método
de búsqueda. Creo que ese es un nombre
bastante adecuado. Ahora, necesito definir
algunos parámetros. ¿Qué parámetros debe tomar? Bueno, el primero,
necesitamos saber dónde se encuentra
la música
en el sistema. Necesitamos una ruta de archivo. Creo que ese es un primer parámetro bastante
bueno. El segundo probablemente
el término de búsqueda. Necesitamos el método para saber lo que realmente estamos
buscando. El último, tal vez
un parámetro de referencia y tal vez eso sea una
lista o una matriz. Esto va a recoger
todos nuestros resultados. Cuando buscas algo, podrías tener un resultado, es posible que no tengas resultados. Pero también podrías
obtener diez resultados, como diez coincidencias
para tu búsqueda. No podemos simplemente devolver
un tipo simple, necesitamos devolver algo
como una matriz o una lista. Por ejemplo, creo que usar una colección como una lista
aquí va a ser bastante adecuado. Voy a llamar a esto
resultados porque va a contener todos nuestros resultados
que encontremos de nuestra búsqueda. Ahora tenemos el camino
donde está la música. Tenemos el término de búsqueda de
lo que estamos buscando. Ahora tenemos una colección aquí que va a
almacenar nuestros resultados. Una cosa que quizás te
preguntes es, bueno, ¿por qué no tenemos esto
como valor de retorno? ¿Por qué necesitamos un parámetro que sea un tipo de referencia
como aquí por ejemplo? Bueno, la verdad
es que realmente no
importa si configuro esto
como el tipo de retorno. Creo que podría complicar un poco más
este ejemplo. Lo que quiero
comunicarte es cómo funciona la recursión, donde un método llama a un método, también
conocido como
método recursivo Si configuro un tipo de retorno, entonces tengo que devolver
el valor de cada llamada al
método dentro de sí mismo. Creo que podría complicar un poco
el ejemplo. Voy a usar un
parámetro por ahora, entonces cuando realmente haya
desarrollado la solución, solo
voy a cambiar esto a un tipo de retorno para poder
mostrarte ese ejemplo también. Ese es el razonamiento
detrás de esto aquí. Sólo va a
almacenar los resultados. Al desarrollar
métodos recursivos como este de aquí, siempre
es bueno obtener primero la funcionalidad
base Y eso es
lo que está diseñado para
hacer ignorando completamente la recursividad Ahí es donde el
método se llama a sí mismo. Lo que quiero hacer es usar la ruta que se nos
da y usar el término de búsqueda y
ver si realmente podemos obtener algunos resultados de
la carpeta raíz aquí. Por ahora, vamos
a ignorar indagar en carpetas y
todo por el estilo. Lo que quiero hacer es
obtener estos archivos aquí, obtener todos los archivos para
el directorio dado,
Y luego a su vez, quiero revisar cada archivo para
asegurarme de que contiene
nuestro término de búsqueda. Si lo hace, quiero agregarlo a la lista de resultados que
acabamos de crear. Echemos un vistazo a cómo
podemos obtener estos archivos para un
directorio y luego verificar cada título para
asegurarnos de que contiene nuestro término de búsqueda
en Visual Studio. Ahora bien, si queremos trabajar
con archivos, directorios, ruta de
archivo, o
algo así, en realidad
hay un espacio de
nombres que podemos usar. Esto se nos proporciona. Usamos la palabra clave using
y luego escribimos en system y luego O significa input output. Es casi cualquier cosa
que ver con el registro de archivos a archivos de texto que leen de
archivos, todas las cosas así. Es un espacio de
nombres muy útil que podemos usar. No está incluido por defecto. Por ejemplo, antes en un tutorial
anterior donde usamos la clase estática matemática y dentro de las matemáticas podemos hacer
varias funciones matemáticas. Esto se incluye por defecto porque es una biblioteca
bastante popular. Al crear una aplicación, es posible que desee hacer muchas
cosas que hacer con las matemáticas, por ejemplo, y muchas
otras cosas también. Sin embargo, no todas las piezas de software que crees
van a funcionar con archivos. Es por ello que tenemos que incluir de forma manual de
forma explícita esta biblioteca. Eso es solo un poco de
información ahí. Si desea utilizar cualquier otro espacio de
nombres para el caso, puede agregarlos a continuación dentro del espacio de nombres del sistema
I Hay muchas
cosas que puedes hacer. Puedes hacer todas
estas cosas aquí. Muchas y
muchas cosas. Pero hay
algunas clases estáticas de las que quizás quieras
que te den cuenta. El primero, por ejemplo, es Directory, y esta
es una clase estática. Usando esto, podemos
crear directorios en nuestro sistema simplemente
dándole una ruta como parámetro. Podemos eliminar directorios. Podemos obtener archivos dentro de un
directorio que proporcionamos. Podemos hacer muchas cosas que
hacer con directorios. Este directorio,
clase estática, es realmente útil. Otra es una
clase estática llamada file. Con archivo, podemos crear archivos. Por ejemplo, si queremos
crear un archivo de registro, podemos eliminar archivos. Podemos verificar si existen archivos, podemos mover un archivo abierto. Así que muchas
cosas diferentes que hacer con los archivos. La última que es bastante útil es la clase estática path. Path es realmente útil
para trabajar con caminos. Si estamos dando nuestra ruta de archivo, podemos obtener el
nombre del archivo de la ruta. Quizá podamos obtener la
extensión de un archivo. De hecho, podemos trabajar con un camino completo y
también podemos unir caminos juntos. Esto es realmente bueno para
trabajar con rutas de directorio. Hay tres clases
estáticas que te resultarán muy
útiles en el futuro. Y vamos a
utilizar un par de estos hoy cuando desarrollemos nuestra búsqueda de funciones
recursivas Aquí, mencioné antes
que queremos que nuestro método obtenga los archivos en el directorio de ruta
solo para empezar, solo para asegurarnos de que
realmente esté funcionando, lo que queremos hacer es obtener todos los archivos en un directorio
dado. Conocemos esta información
porque este es el camino que se
pasa a nuestro método. Quiero obtener todos los archivos
dentro de este directorio aquí. Para ello, hacemos uso de la clase estática del directorio y hay un método
llamado get files. Obtener archivos toma
un parámetro y esa es la ruta donde se encuentran
los archivos. Ahora el retorno de este
método es una matriz de cadenas. Ahora esta matriz contendrá las rutas de archivo completas para cada
archivo en este directorio. Si venimos a
nuestro canal de música, aquí
va a conseguir todos
estos archivos. Cada elemento de la matriz
contendrá la ruta completa del archivo. La ruta completa en el sistema, ese va a ser el retorno de este método, obtener archivos. Voy a almacenar eso en
una variable llamada files. Eso va a ser todos los
archivos en el directorio dado. Ahora lo que quiero hacer
es recorrer todos estos archivos aquí y
verificar que el nombre del archivo, no necesariamente toda la ruta. Solo queremos verificar
el nombre del archivo para verificar que el nombre del archivo
contenga nuestro término de búsqueda. Aquí necesitamos algún bucle aquí. Creo que para cada bucle
podría ser suficiente. En este caso, visual studio amablemente nos
ha dado alguna ayuda de
autocompletar aquí Ya me lo llevaré. En este bucle de cuatro, quiero
verificar cada archivo a su vez y verificar que el nombre del archivo de este archivo contenga
nuestro término de búsqueda. ¿Cómo hago eso? Bueno, cuando quiero verificar,
necesito una condición. Sé que voy a necesitar
una declaración if aquí. Ahora bien, ¿qué condición
necesito en el comunicado? Bueno, necesito obtener el nombre del
archivo de esta ruta. No quiero la letra de unidad, no
quiero los nombres de las carpetas, solo
quiero el nombre del archivo
cuando se trabaja con path. Como mencioné antes, una clase estática llamada Path
es muy buena para esto. Hay un método llamado
get file name without extension que obtendrá
el nombre del archivo, digamos tres. También hay uno
llamado get file name. Puedes elegir cuál
deseas dependiendo de si
quieres que los usuarios busquen también extensiones de
archivo. Sólo voy a usar esta. Toma un parámetro y
esa es la ruta de este, este código resaltado aquí. Esto va a obtener el
nombre del archivo sin la extensión llegue
a nuestra música. Va a conseguir esta sección
destacada aquí
mismo, lo cual es genial. Eso es lo que queremos
volver a comprobar en visual studio. Ahora sé que ese
es el nombre del archivo sin la extensión
y sin la ruta. Quiero probar y ver si alguno de eso contiene
nuestro término de búsqueda. En un tutorial anterior, cubrí el trabajo con cadenas donde hicimos varias
cosas con
cadenas, subcadenas y
cosas así Debido a que esto es una cadena aquí, path get file name sin la extensión
devuelve una cadena. Por lo tanto, esto
representará una cadena. Cuando pongo arte
después de aquí tenemos todas estas cosas diferentes
que podemos hacer con cuerdas. Aquí hay un método
llamado contains. Contiene. Toma un parámetro, que
es un carácter, una cadena o, en realidad,
numerosos parámetros. Un carácter y un tipo de
comparación. Pero solo queremos usar
esta sobrecarga de cadena aquí. Queremos verificar si
contiene nuestro término de búsqueda. Creo que es un estado
bastante bueno. Ahora, hay un poco
de trampa aquí, que voy a revelar
un poco más tarde, pero por ahora la
voy a dejar Ahora, estamos comprobando si cada
archivo a
su vez contiene nuestro
término de búsqueda. Eso es bastante bueno. Ahora bien, si realmente
contiene nuestro término de búsqueda, entonces queremos agregar
esta ruta aquí, que es archivo, a nuestra
lista de resultados. Hagámoslo ahora. Utilizamos el
método add para hacer eso. Ahí agregamos el archivo. Si no sabes
nada de listas, entonces he hecho un
tutorial sobre eso. Te recomiendo que compruebes eso. Ahora parece que estamos
haciendo algo bastante bueno. Estamos viendo todos los
archivos del directorio dado. Si contiene el término de búsqueda, lo
estamos agregando a
la lista de resultados aquí, Debido a
que este es un tipo de
referencia, va a recordar
lo que le hemos agregado cuando este método haya
terminado de ejecutarse. Eso es porque está
almacenado en el montón, es un tipo de referencia Ahora lo que quiero hacer
en realidad es llamar a este método. Proporcionarle parámetros. Hagámoslo. Ahora. El primer parámetro que necesito es la ruta donde se encuentra
la música. Vamos a por eso. Ahora, vuelve a
poner eso aquí. Este es el directorio de rutas donde se encuentra toda la música. El siguiente parámetro que hemos
configurado es el término de búsqueda, que tomamos de
la entrada del usuario. El último que necesitamos para proporcionar una lista donde realmente
vamos a almacenar nuestros resorts. Voy a definir uno
local aquí a Maine. Configura una nueva lista aquí. No le he dado
ninguna capacidad porque no
sabemos cuántos resorts va a
haber. Acabo de crear una lista MT aquí. Voy a pasar
esto al método. Cuando el método haya
terminado de ejecutarse, tenemos acceso a estos
resultados aquí abajo. Eso es porque como mencioné, es un tipo de referencia. Ahora lo que queremos hacer es simplemente mostrar los resultados al usuario. A lo mejor podríamos usar un cuatro
cada uno para esto también. Lo que quiero hacer, cada vez que
tenemos un resultado en resultados, voy a decir
vamos a dar salida al resultado. Entonces podría agregar como una declaración if diciendo
si no hay resultados, lo
mejor voy a imprimir el
hecho de que no hay resultados. Bien, entonces se ve
algo así. Ahora aprecio que haya formas
más elegantes de hacer prácticamente todo
en el desarrollo de software, pero trato de escribir esto de una
manera que entiendas es más fácil de
asimilar porque así es
como funcionan los cerebros. Quizás al final, podamos
ordenarlo eso es opcional, Pero lo que quiero transmitir es el principio de los métodos
recursivos Tenemos alguna funcionalidad base aquí al desarrollar software, podemos probar, solo para
asegurarnos de que funcione, no
tenemos que
terminar completamente de desarrollar el software. Creo que ahora podría ser un
buen momento para probar esto, solo para asegurarse de que funcione. Ejecutemos la aplicación ahora. Ahora, por favor ingrese un término de búsqueda. Intentemos
buscar a Aba, por ejemplo. Por qué no voy en mi aplicación, escribo Abba dice que no
hay resultados para
mi búsqueda. ¿Por qué es esto? Intentemos resolverlo. Vuelvo al software ahora, no
estoy obteniendo ningún
resultado de aquí, pero claramente estoy
agregando un resultado aquí. ¿Qué está pasando aquí? Veamos si podemos
resolverlo. Pongamos aquí un
punto de quiebre y ejecutemos el software. Escriba Ab. ¿Qué tenemos aquí? Parece que estamos recibiendo
todos nuestros archivos aquí. ¿Estamos realmente llegando a este punto de quiebre
donde estamos agregando el valor?
Parece que no lo estamos. Entonces hay algo mal aquí. Parece que no podemos
obtener el nombre del archivo correctamente o algo bastante
diferente está sucediendo aquí. Parece que accidentalmente he puesto ruta aquí cuando
deberíamos tener archivo. Por el momento, solo estamos buscando la
ruta del archivo donde
se encuentra la música y no en realidad el nombre del archivo que
está dentro del bucle. Si eso resuelve el problema, bien,
parece que está funcionando. Ahora como puedes ver,
nadie es perfecto. Los errores ocurren,
pero si ves mis tutoriales sobre depuración
y todo eso, también
sabrás solucionar
problemas tú mismo. Entonces parece que está funcionando. Probemos
algo más muy rápido. Yo sí aludió a un
gotcha antes, y eso es si
busco a Aber, donde está minúsculas le pegué, y dice que no hay Pero claramente tenemos
una canción llamada Abba. Lo que puedes ver aquí es que
hay un tema sensible a mayúsculas y minúsculas. Eso es porque Aber en el
NP tres es mayúscula, pero estamos usando un término de búsqueda en
minúscula Entonces, ¿cómo solucionamos esto? Bueno, archivo es una cadena y
el término de búsqueda es una cadena. Cuando usamos cuerdas, tenemos muchas cosas
disponibles para nosotros. Lo que podemos utilizar es este
método aquí llamado a bajar. Lo que eso hace, convierte
todo esto en minúsculas. De igual manera, podemos hacer
esto en el término de búsqueda. Ahora estamos comparando todo nuestro término
de búsqueda, todo en minúsculas, con el nombre del archivo, todo en minúsculas. Ahora bien, no deberíamos tener temas sensibles a
mayúsculas y minúsculas. Si ejecuto la aplicación
ahora y busco a Aber, puedes ver ahora
tengo el resultado Ahora estamos ignorando el caso.
Eso es bastante bueno. Voy a hacer una
búsqueda más y solo buscar
tal vez la letra E solo para asegurarme de que obtengamos
múltiples resultados. Al volver, se
ve bastante bien. Parece que estamos
obteniendo todos los nombres de archivo que contienen la letra. Eso es bastante bueno. Ahora, creo que estamos listos para la recursión. Tenemos la
funcionalidad base funcionando. Estamos contentos de que esté funcionando
para el directorio base. Ahora podemos introducir recursividad. El problema es
cuando introduce recursión desde el principio, especialmente si
no eres competente, entonces si tienes un error, podría ser solo con
tu Es muy bueno que esto
funcione antes de introducir
la recursión a esto Hace las cosas mucho más fáciles. Vamos a introducir algo de
recursividad en este método. Ahora bien, te agradezco que
no lo entiendas la primera vez, pero no te preocupes, eventualmente lo
conseguirás. Hay algunas maneras de abordar este problema. Lo que quiero hacer, tengo este método de búsqueda
que obtiene los archivos, lo cual es bastante bueno. Pero también, quiero
darle a este método el siguiente directorio en
el directorio actual. Aquí, por ejemplo,
tenemos nuestro directorio musical. Ya estamos
revisando los archivos, pero también quiero obtener todos
los directorios aquí también. Entonces dentro de cada directorio, quiero hacer la funcionalidad
core, que es obtener los archivos, pero aun así quiero obtener
los directorios también. Entonces dentro de aquí, quiero hacer lo
mismo, obtener los archivos. ¿Hay
algún directorio aquí? Claramente, necesito alguna
función para obtener todos
los directorios en el
directorio actual. Hagámoslo. Ahora, voy a
poner eso aquí arriba. Hay una cosa útil que
podemos hacer para obtener directorios, y eso es usar la clase estática del
directorio. Hay un método llamado get directory y toma una ruta. ¿Qué camino hace?
Toma nuestro camino de raíz. Y al igual que antes, devuelve una matriz de cadenas y cada elemento esta matriz será la ruta completa de los directorios
en esta ruta aquí. Entonces voy a llamar a eso
DR para directorios. Y porque sabemos que queremos ir dentro de
cada directorio, necesitamos recorrer esto
también sin siquiera
pensar en nada. Sabemos que necesitamos
directorios y sabemos que necesitamos revisar
cada uno sin siquiera preocuparnos por el
problema de la recursión o inicio o lo que
quieras decir Sabemos que necesitamos esta
funcionalidad ahora. Una vez que tenemos esta
funcionalidad en su lugar, tenemos que averiguar cómo lidiar
realmente con este problema. ¿Qué ponemos aquí? ¿Necesitamos algo aquí? ¿Necesitamos algo
aquí? Pero ahora tenemos un
poco de plantilla. Echemos un vistazo
a cómo abordar este problema. Le estoy dando el
directorio raíz al método. Lo que podría hacer
en esta situación es obtener todos los directorios. Y con el primer
directorio voy dentro de él, luego vuelvo a llamar al método, Lo que va a hacer es
exactamente lo mismo. Va a conseguir todos
los directorios e ir en el primero. Va a conseguir que todos
los directorios vayan
en el primero. Y ahora estamos en
la carpeta final. No hay más directorios, así que no podemos ir en el primero. Entonces lo último que tenemos que
hacer es obtener los archivos. Entonces, lo que estamos haciendo aquí, estamos obteniendo los directorios siempre yendo en el primero, siempre yendo en el primero. Hasta que hayamos llegado
al final, obtenemos los archivos, salimos uno, entramos en el siguiente, obtenemos todos los directorios
vamos en el primero, obtenemos todos los directorios, vamos
en el primero, etcétera Entonces eso es lo que estamos haciendo aquí. Estamos buceando hasta el fondo, que es
lo primero que estamos haciendo. Vamos adentro, adentro,
adentro, hasta el
callejón sin salida más grande que está aquí. Y luego estamos
comprobando los archivos. Entonces eso es lo que vamos
a replicar en nuestro método. Ahora la primera ejecución
de esto aquí mismo, el método de búsqueda, le
estamos pasando la ruta que es
el directorio raíz para nuestra música aquí mismo. Lo que quiero hacer es obtener todos
los directorios como acabo de
mencionar en la carpeta raíz. Eso son todos los que están aquí. Eso es lo que está haciendo este bucle de
cuatro. La primera iteración
del bucle cuatro será
este directorio aquí Ahora queremos
ir realmente dentro de este directorio. Lo que podemos hacer, podemos pasarle
este método a sí mismo. Podemos llamar al
método desde sí mismo. Incluso lo que quiero hacer
es llamar al método. Vamos a simplificar esto.
Los resultados nunca cambiarán. No estamos definiendo
ningún resultado nuevo, simplemente
estamos
añadiendo resultados cuando tenemos un resultado,
cuando tenemos un partido De hecho, estamos inicializando
y definiendo los resultados
aquí arriba cada vez que
pasamos los resultados Solo queremos simplemente
pasarlo por ahí. Cuando llamamos a este
método dentro de sí mismo, solo
queremos pasar
este valor dentro. La única razón por la que queremos
hacer eso es sólo para agregarle. Realmente no
necesitamos hacer nada especial con esto aquí. Lo mismo se aplica con
el término de búsqueda. No estamos cambiando el término de
búsqueda aquí, estamos prácticamente pidiendo
al usuario un término de búsqueda. lo que a nosotros respecta, es más o menos leído
solo dentro de este método. Nuevamente, solo estamos pasando por
esto también. Al igual que los resultados,
lo único que realmente difiere aquí es el camino dentro de
nuestro primer directorio. En realidad queremos el directorio en el
que vamos dentro. Se va a quedar
algo así. Si acabo de quitar eso un poco, así es como
va a quedar. No sé si puedes
envolver tu cabeza alrededor de esto, pero la primera vez que se ejecuta esto, estamos obteniendo los directorios. Estamos recorriendo
esos directorios. Entonces el primer directorio, estamos llamando de nuevo a este método. Ahora se
está llamando a este método con el primer directorio
en la ruta original. Una vez que está dentro de ese
directorio, nuevamente, estamos obteniendo los
directorios nuevamente hasta llegar al
final, que está aquí. Imagina que este es el camino
que se está pasando en
Ahora, ahora no hay directorios. Esto va a tener
un conteo de cero. Esto para cada bucle ni
siquiera se va a ejecutar porque si no hay
directorios en este resultado, esto se omitirá por completo Ahora bien, cuando esto se omite, este método no se
llamará a sí mismo porque esta es la única vez que
el método se llama a sí mismo Lo que entonces va a hacer
es obtener todos los archivos. Es entonces obtener estos
archivos aquí y verificar para ver si tenemos una coincidencia
y luego termina el método. Cuando termina el método, volvemos a la llamada anterior, que está dentro de este bucle. Entonces se va a llamar nuevo en el
siguiente directorio, en la siguiente iteración
del bucle Después termina,
entra en el siguiente directorio. Aquí busca directorios
y archivos. ¿Funciona esto? Echemos un vistazo, ¿por qué
no introducir un término de búsqueda? Entonces lo que voy a hacer, voy a dar un
término de búsqueda para un archivo como este. Por ejemplo, hola, hola. Ahora, hola, hola se
encuentra en esta carpeta, dentro de esta carpeta, y hola, hola no está en el directorio
base. Al buscar hola, sé a ciencia cierta que está revisando bastantes carpetas
para poder encontrar este archivo, esa es una
prueba adecuada que podría usar. Vamos a ejecutar el programa. Por favor,
introduzca su término de búsqueda. Escribamos hola aquí. Parece que lo ha encontrado. Ves este resultado,
buscando subdirectorios, se ha ido dentro de dos directorios y
finalmente se encuentra el archivo Aquí, parece que en
realidad está funcionando. Este es un ejemplo aquí
de un método recursivo, eso es solo un método
que se llama a sí mismo Solo estamos rellenando los resultados en un parámetro que es un tipo de
referencia, es una lista Hagamos una prueba más solo
para asegurarnos de que está funcionando. Voy a tomar
ese archivo Hello, que está aquí, y
pegarlo en algunos lugares más. Voy a ponerlo aquí. Voy a ponerlo aquí. Voy a ponerlo aquí. Ahora deberíamos obtener
muchos más resultados. Ejecutemos el programa,
escriba hola. Y ahora se puede ver que
he encontrado todas esas instancias de
ese hola P tres, así que parece que está funcionando. Entonces esas son muy buenas noticias. Ahora la cosa al escribir métodos
recursivos, se necesita una manera de
escapar de la recursión La recursión no se detendrá a menos que introduzcas
algo así como una condición, tal vez una sentencia if O tal vez en nuestro
caso, tenemos un loop que recorre
directorios y archivos. No tenemos directorios
infinitos, no
tenemos archivos infinitos. Entonces eventualmente este método
recursivo se detendrá. Sin embargo, es bastante fácil tener
un método llamarse a sí mismo sin fin, como en este ejemplo Si tengo este método
llamarse a sí mismo con los mismos parámetros, no
hay forma de que esto salga. Este es el peligro
de usar recursión. Al escribir métodos recursivos, siempre verifique para
asegurarse de que tiene una condición o alguna cláusula de
escape De lo contrario tu aplicación
se congelará, y tendrás mucho comportamiento
inesperado ya
ves si ejecuto el programa, ahora escribo cualquier término de búsqueda, puedes ver que tenemos
un desbordamiento de pila. Intentó llamarse a sí mismo
24,000 veces antes que finalmente se estrellara porque la pila está llena del área de la
pila de memoria Siempre tenga cuidado con esto
al escribir métodos recursivos. Entonces al inicio del
tutorial, dije, oh, fácilmente
podríamos tener esta
colección aquí como retorno. No lo necesitamos como parámetro. Ahora ya he explicado recursión, esto puede modificar este código
y tener esto como retorno En cambio, configuré el valor de
retorno aquí. Yo defino esto aquí arriba. Vamos a quitar esa parte. Almacenemos los resultados
en una lista de resultados aquí, porque esta
será nuestra devolución aquí. Ya no necesito
pasar este parámetro, y ya no necesito
esto como parámetro, pero necesito definir
un resultado aquí. Hagámoslo ahora. Bien,
Lo que he hecho aquí, he agregado un retorno
aquí para buscar, que es una lista de una cadena. He definido la lista
de resultados de cadena dentro
del método aquí. Ahora hay un par
de cosas a tener en cuenta. Lo primero que tengo que hacer es en realidad devolver esto
fuera del método. Yo voy a hacer eso. Ahora lo
siguiente que tengo que hacer, cada vez que recursivamente
llamo a este mismo método aquí Necesito almacenar la devolución cada vez que la llamo
recursivamente también De lo contrario, vamos a
perder esta información. Si estamos abajo en la misma
profundidad de nuestra estructura de carpetas, hemos encontrado algunos archivos, por ejemplo, como aquí. Bueno, tenemos que pasar estos fuera de la
llamada interna del método, porque por ejemplo, aquí
no estoy almacenando una devolución. Lo que tengo que hacer cada vez
que recursivamente llamo a esto, necesito almacenar
los resultados aquí Ahora piensas, bien,
parece que está funcionando. He definido la lista, cada vez que recursivamente me
llamo a sí misma, estoy recordando estos
valores y configurándola aquí Entonces cada vez que tenemos un partido, lo
estoy agregando a la lista, y eventualmente lo
estoy devolviendo e imprimiendo los resultados. Echemos un vistazo y veamos qué
pasa. Digamos hola. Parece que tenemos
un pequeño problema. Aquí es donde la depuración
es muy útil, pero te puedo decir
lo que está pasando aquí El problema es que hemos
encontrado algunos archivos en las profundidades internas de
nuestras llamadas recursivas, por
ejemplo, estos archivos aquí Ahora se trata de dos carpetas de
profundidad, se puede ver aquí. Ahora lo que está sucediendo es que estos
no están siendo recordados, porque cuando esto
finalmente sale, estamos restableciendo este valor cada vez que llamamos a
este método recursivo Y eso es un poco problema. Estamos agregando las cosas aquí, pero también lo estamos reiniciando. Esencialmente no se está
recordando nada, pero en realidad estamos agregando
información aquí. Si pongo un
punto de ruptura tipo Hola, en realidad
hay archivos aquí, pero el problema es que
en realidad se está restableciendo. Si miro mi pestaña de
Locales aquí abajo, puedo monitorear los
resultados aquí mismo. Me puse un punto de quiebre
a la vuelta, pegué un cinco. Ahora ya pueden ver que tengo un
resultado si salgo de aquí. Ahora puedes ver los resultados
como reset a cero. En cuanto salgo de aquí, no se está recordando nada. Lo que está pasando aquí. El problema es, bueno, es un problema bastante simple, pero es muy difícil de
entender tal vez cuando se
habla recursivamente, Lo que tenemos que hacer
en realidad es agregar los resultados de esta
búsqueda a esta lista No podemos simplemente reemplazar la lista con los
resultados de la búsqueda, de
lo contrario, nos estamos
olvidando de todo lo que
hemos aprendido hasta ahora. Lo que tenemos que hacer es agregar todo desde los resultados
de la búsqueda recursiva Y hay un método
llamado add range. Y lo que eso hace, agrega uno o más elementos a nuestra lista. Y esta es la
ventaja de usar una lista sobre algo
así como una simple matriz. Tenemos estos métodos
disponibles para nosotros. Entonces echemos un vistazo a esto ahora y veamos si esto
funciona mejor. Entonces ejecuto la aplicación, escribo hola, y ahora tenemos todos
nuestros resultados. Ya no se están criando a través de nuestro método recursivo Llamar a esto es por
lo
que tener un retorno, agrega un poco más de
complejidad a las cosas. Y por eso introduje primero
el ejemplo con un
parámetro. Porque esto no se está reiniciando cada vez que
tenemos un retorno, sí, estamos definiendo el retorno aquí e inicializándolo
a una nueva área de memoria Pero necesitamos recordar agregar nuestros resultados de
cada llamada recursiva,
cada vez que llamamos a nuestro
método recursivamente Ahora, agradezco que
esto sea tanto para tomar, es
súper complicado. Pero yo, lo rompí
en términos simples para ti. Si ves este tutorial
quizá dos o tres veces. Y tal vez proporcione sus
propios ejemplos también. Eventualmente lo
descubrirás y algún día solo
hará clic. Te prometo que esto es recursión en C Sharp.
No sólo C Sharp. recursión está en muchos lenguajes de
programación e incluso en matemáticas
y cosas así Espero que hayan disfrutado de este tutorial y gracias por verlo.
79. 20-1. Proyecto final (juego de simulador de Top Trumps): Entonces el proyecto final. ¿Cuál es el proyecto final? Bueno, vamos a echar un vistazo. El proyecto final es opcional, pero
te recomiendo encarecidamente aplicar todos
los conocimientos que
has aprendido
hasta ahora y darle un intento sólido. Entonces
ganarás oficialmente el título,
el título no oficial de C
Sharp Computer Programmer, o C Sharp Software Engineer Suena bastante bien, ¿no? Entonces, para el proyecto final, vamos a estar simulando
un juego de top trumps Ahora bien, si no estás
familiarizado con los mejores triunfos, es básicamente una baraja de cartas Y la baraja de cartas está
temática para lo que quieras, realmente lo que quieras comprar. Por ejemplo, puedes
tener un dragones con criaturas
místicas
donde tienes magos y reyes y dragones
y cosas así Cada carta tiene un personaje, éste se llama
Dragón por ejemplo. Y tiene diversas estadísticas
como habilidad de fuerza, poder
mágico sobre el factor miedo. Sin embargo, si compras un
mazo con superhéroes, es posible
que tengan
algo totalmente diferente con diferentes nombres de
personajes Pero generalmente cada baraja
de cartas es temática. Cuando creas tu
versión de esto en C sharp, puedes elegir el
tema que quieras. El cielo es el límite, Solo usa tu imaginación
como funciona el juego. Bueno, he incluido una especificación
completa que explica cómo funciona
el juego, pero también algunas suposiciones que puedes tomar al desarrollar
esta solución. Te voy a mostrar
ahora una demo, más o menos sobre cómo funciona. Entonces aquí está la
especificación aquí mismo, no te
preocupes, he incluido
esto en formato de texto, así que haz referencia a ella algunas
veces cuando
planees tu proyecto y cómo vas a
abordar el escenario. Doy una breve descripción
de lo que es. Te he proporcionado algunos enlaces para que puedas investigar
más a fondo. Ahora bien, este es un juego para dos jugadores. Vamos a estar asumiendo que sólo
hay dos
jugadores jugando. Y he puesto una lista de
suposiciones que puedes hacer hora de crear este proyecto
solo para hacerlo mucho más fácil. Realmente no quiero que
pases semanas y semanas en esto. Puedes si lo deseas, no
es ningún problema en absoluto. Pero creo que usar
esta especificación, ya
sabes, un par de horas
al día durante una semana más o menos, creo que es una buena cantidad
de tiempo para entrenar tus conocimientos recientes
y desarrollar una buena pieza de software
para mostrarle a tus amigos, familiares o a quien quieras
hacer referencia a la especificación sobre
cómo ponerte en marcha con eso. Te voy a mostrar ahora mi
solución sobre cómo
abordé el problema para que
puedas hacerte una idea de cómo funciona Entonces, cuando el software
se ejecuta por primera vez, solo
estamos asumiendo que el
jugador uno va primero. El jugador uno puede presionar Enter
para comenzar su turno. Ahora es el turno de jugador uno. El jugador uno tiene cinco cartas y el jugador dos tiene cinco cartas. Entonces tienen cinco cartas cada una. Para que las cartas representen a un personaje como un
dragón o un rey, por ejemplo,
algo así. Aquí tengo caracteres totalmente
aleatorios. Eso es, ya sabes, lo
buena que es mi imaginación. una carta
o personaje seleccionado al azar juega una carta
o personaje seleccionado al azar de
mi mano, y ese es el osito de peluche. Ahora, el
osito de peluche tiene una altura, un peso, un poder mágico
y un factor de miedo. Porque es un peluche,
es bastante pequeño, no
es muy pesado, no tiene habilidad mágica
y
no tiene factor de miedo. Así que en realidad es
una tarjeta muy mala. Ahora la idea es que quiero
elegir la estadística más alta aquí, y espero que mi oponente tenga una estadística que
sea menor que la mía. Entonces si escojo altura, digamos 1 metro 45. Así que solo elijo el número
uno aquí. Presiono Enter. Entonces el jugador,
el otro jugador defiende con Harry
Houdini, que es un mago Pero tiene una altura de 5.7 Así que el osito de peluche no es
más alto que Harry Houdini Por lo que el oso de peluche pierde porque la
altura del oso de peluche es de sólo 145. Pero Harry Houdini tiene
57 años. El jugador dos gana. Pero debido a que jugador a uno, jugador dos se lleva la carta del oso de
peluche, jugador dos conserva su carta de
Harry Houdini Y ahora es jugador
dos turno para ir. Entonces si le pego a Anton, Ahora se puede ver que el
jugador dos ahora tiene seis cartas porque
ganaron el osito de peluche. Ahora es el turno del jugador dos. El
personaje seleccionado al azar es Picchu. Ahora Picchu tiene bastante buen poder
mágico, pero bastante corto. Y también es muy ligero. Y no hay
mucho factor de miedo. Entonces quiero jugar al poder mágico porque es bastante alto y
espero poder vencer a la carta defensora del ahora
jugador uno. Entonces echemos un
vistazo a esto. El otro jugador defiende
con Darth Veda. Pero elegí el
poder mágico, que era de 75. No obstante, Darth Veda sólo tiene un poder mágico de dos. Entonces gané. Volví a ganar. Ahora
porque volví a ganar, sigue siendo mi turno. Entonces sigue siendo el turno del jugador dos. Ahora ya pueden ver que
tengo siete tarjetas. El ganador del juego es la persona que tiene las diez
cartas en este ejemplo, porque sólo hay diez cartas. Si creas 20 cartas, entonces obviamente el ganador
es con las 20 cartas. Ahora, aquí hay
muchas suposiciones. Puedes ver que estoy seleccionando
aleatoriamente personajes de la baraja que tiene el jugador de
cada jugador. Mientras que cuando realmente
juegas a este juego en persona, tomas el que está en la
parte superior de la baraja. Entonces, estoy usando muchas
suposiciones solo para
acortar el tipo de
vida útil de este proyecto Sabes, yo no,
realmente no quiero que trabajes en
esto por 34 meses y te arranques el pelo. No creo que
sea un primer y último
proyecto muy divertido para ti. Entonces hay muchas
suposiciones, ya
sabes, no es
realmente obligatorio. Agrega tu propio giro.
Agrega tu propio sabor. Realmente depende de
ti, obviamente, acabo de tocar Picature,
y Piccature ha
sido Entonces ya sabes, no es
una aplicación perfecta, así que no te preocupes por
que sea perfecta. Es sólo para entrenar tus
conocimientos y cosas así. Así que es solo un poco
de diversión y creo que lo pasarás bastante bien
con esto de aquí. Tenemos al mini diablo, Somos miedo factor cuatro. Lo estamos haciendo bastante bien.
Tenemos nueve cartas ahora tenemos Harry
Houdini poder mágico Y parece que
hemos ganado el juego. El jugador dos consiguió las diez cartas totalmente destruidas, jugador uno. ¿Queremos
volver a jugar? ¿Sí o no? Si presiono no, entonces
gracias por jugar. Presiona Enter para salir. Ese es el proyecto final. Nuevamente, no es la solución, es solo una solución. Puedes hacer lo que
quieras con
los personajes que desees, pero trata de aplicar muchas de las cosas que realmente hemos
cubierto en el curso. Entonces aquí he creado, en el lado derecho aquí, he creado cuatro clases
personalizadas. Aquí, los he puesto en
un proyecto separado. Y cuando abro el método principal aquí
mismo en la clase del programa, se
puede ver que no hay
realmente mucho código aquí. Eso es porque lo hemos
separado en, ya
sabes, contenedores lógicos. Tengo una clase de
controlador de juego que maneja todo lo
que tiene que ver con el juego, los giros, y
todo por el estilo. Tengo una clase de jugador ahora, los jugadores,
modela a los jugadores. Y un jugador tiene una serie
de personajes o cartas. Y el personaje
o clase de cartas es responsable de todos los
personajes del juego. Para que puedas ver cómo estamos usando los conocimientos
que hemos aplicado. Donde tomamos una clase
y esa clase es responsable de todo lo que tenga
que ver con lo que se llama. Entonces la clase de personaje
trata con los personajes, el controlador del juego se
ocupa de cómo funciona
el juego, etcétera Entonces así es realmente como funciona. Estamos tomando todo
el conocimiento que hemos tomado y lo estamos aplicando ahora. Entonces esa es básicamente mi solución hacia el proyecto final. Ya sabes, Planeta Planeta. Usa algunos blocs de notas.
Usa un poco de papel. Usa una pluma. Piensa bien en cómo vas
a abordar el problema, cómo vas a
organizar el problema y qué técnicas
vas a usar, qué bucles, condiciones
y cosas así. Espero que te diviertas con esto. El proyecto final pone
a prueba tus conocimientos sobre muchos conceptos de las cosas que
hemos cubierto hasta ahora. Así clases, objetos,
instanciación, sentencias
if, sentencias
switch, condiciones operadores booleanos Cuatro bucles, bucles de alambre, muchos bucles diferentes, métodos y mucho más. Así que es una excelente manera de
tomar todo ese conocimiento y aplicarlo a una sola
pieza de software. ¿Cuánto tiempo tardará el proyecto
final? Bueno, si te gusta programar y quieres ser programador, entonces esto no debería
ser una preocupación en absoluto, porque la práctica
siempre es algo bueno. Si eres un principiante total
cuando iniciaste este curso, entonces quizás pases un
par de horas cada día durante una semana más o menos,
algo así. Como cualquier otro idioma,
francés, alemán, español. No vas a absorber toda la información
en una sola pasada. Simplemente no es realista. Pero utilizar los materiales del curso
como punto de referencia para
el proyecto final. Si estás desarrollando
tu proyecto final y no recuerdas
cómo hacer un bucle de cable, por
ejemplo, entonces simplemente vuelve a ver el tutorial de bucle de alambre de nuevo
solo para obtener un repaso. Incluso los programadores
informáticos profesionales utilizan Google y varios otros
sitios web como punto de referencia, y a veces lo hacen La programación diaria
consiste en pensar fuera de la caja y aplicar el pensamiento lateral y
lógico. No se trata de recordar sintaxis y regurgitar la sintaxis, así que no se deje disuadir
por Entonces he incluido mi solución
para el proyecto final, pero
te recomiendo encarecidamente simplemente no uses esto. No lo mires hasta que
hayas terminado el tuyo. Entonces puedes usarlo
como punto de referencia para quizás, tal vez mejorar el tuyo. O mira las diferencias entre mi solución
y tu solución. Recuerda, no hay una
solución a un problema. Puede haber múltiples soluciones y todas ellas siendo correctas. Pero úsalo solo
como punto de referencia cuando hayas completado
tu proyecto final. Envíala a tus amigos.
Envíalo a tu familia. Subirlo a Youtube por
ejemplo. Y envíame el enlace. Me encantaría ver tus proyectos
finales y cómo
interpretaste esta
especificación y ponerle tu propio giro. Lo último que quiero decir es, buena suerte con el proyecto
final y buena suerte para tus futuros esfuerzos de
programación Por último, gracias. Muchas gracias por
ver Cuídate.
80. 20-2. Resumen del curso (¿A dónde debo ir aquí?): Ahora bien, todas las cosas buenas
deben llegar a su fin. Pero si has llegado hasta aquí, entonces gracias por ver. Si tienes alguna consulta,
problema, niggles, preguntas con respecto a alguno de los contenidos de
todo el curso, entonces por favor deja un mensaje sobre el contenido en sí o
envíame un mensaje Estaré más que feliz de ayudar también
a revisar archivos
del proyecto que lo acompañan si aún no lo has hecho. La mayoría de las lecciones de este
curso tienen archivos de
proyectos acompañantes y siéntete
libre de expandirlas, aprender de ellas, pero también
agregarles tu propio giro. El límite es tu imaginación. La gran pregunta que
suelen tener muchas personas después de
terminar un curso es, ¿a
dónde voy a partir de aquí? Bueno, no voy
a dejarte colgado. Mucha gente lo hace, pero te
voy a dar algunas ideas. Depende cuáles sean
tus metas. ¿Cuáles son tus metas? Estos son únicos para ti, son
personales para ti. Por ejemplo, a lo mejor estás
buscando empleo. Quieres que
alguien te emplee . O tal vez sea una afición. A lo mejor quieres crear una aplicación telefónica
para ganar dinero. O tal vez quieras
hacer videojuegos en Unity o simplemente probar
un nuevo reto. Algo totalmente nuevo.
Entonces sí depende. Pero el
terreno secreto y común con todos
estos es la práctica, la
práctica, la práctica. C sharp no es muy diferente
de una lengua hablada real como francés o el alemán o el
portugués, por ejemplo Cuanto más lo uses, mejor te volverás. Es sólo natural.
Y de manera similar, menos lo uses, más te olvidarás. Entonces en tu tiempo libre, te
recomiendo crear pequeñas
aplicaciones de software para resolver tus problemas cotidianos y
hacerte la vida más fácil. No sólo eso, también es
bastante divertido. He hecho un montón de diferentes piezas de software
solo para hacerme la vida más fácil. Por ejemplo, he hecho un renombrado musical cuando
tengo itunes, por ejemplo A veces no
toma el nombre del archivo, toma una etiqueta oculta dentro
del MP tres, por ejemplo. Así que hice una pieza de software
para inyectar esa etiqueta en el MP tres para que mi itunes se vea muy bien
y esté todo automatizado. No tengo que, ya sabes, renombrar cada canción para darle el
artista o título correcto. Por ejemplo, esto es
muy fácil de hacer con muchas de las herramientas
y técnicas que
hemos cubierto en este curso. Cosas como cuando
aparecen artículos gratis en Craigslist
o cosas así, puedo tocar un sonido musical. Entonces, cada vez que alguien está regalando
algo gratis, mi computadora portátil comienza a reproducir música. Y entonces sé que algo
nuevo está en la sección gratuita y al instante puedo
contactar con el comprador y, ya
sabes, arreglar la
recolección de eso. Ya sabes, el límite
es tu imaginación. Y por último, he creado
un subidor masivo de Youtube. Lo que pasa es que si tienes
tal vez diez o 50 videos, quieres subir a Youtube, pero no quieres escribir todos los títulos y descripciones
y cosas así. Entonces he hecho una aplicación
donde puedo tomar 50 videos, por
ejemplo, arrastrarlos y
soltarlos en el software. Y llena el
título y descripción del video e incluso las etiquetas del
nombre del archivo de video Y esto ahorra tantas horas. Y esto es en realidad una
pieza comercial de software ahora. Entonces no sólo practica
mis habilidades de programación, sino que también gana
dinero de lado. Entonces ahí hay muchas ideas
que puedes, ya sabes, tomar a bordo y aplicar para
tus propios escenarios específicos. Otra cosa que puedes hacer,
que es muy, muy buena, es tomar pruebas de codificación en línea, como pequeños desafíos de codificación. Entonces, por ejemplo, hay
dos sitios web que puedes usar. Uno se llama Hacker Rank y otro se
llama Lite Code. Te voy a mostrar esos ahora. Ahora cada uno de ellos tiene muchos desafíos
de codificación diferentes, igual que presenté el proyecto final con
el simulador top trump. Pero típicamente,
son mucho más fáciles. Por ejemplo, dibuja una pirámide, que hemos cubierto
en este curso, o dibuja un cuadrado o encuentra a la
reina, cosas así. Desafíos tan rápidos que
ponen a prueba tu pensamiento lateral, que es pensar
fuera de la caja. Entonces no sólo ponen a prueba tus
conocimientos de C Sharp y quizás tu memoria de la
sintaxis, sino más importante, tu aplicación de un Sharp Cuando te presentan
un problema, prueba cómo funciona tu cerebro, cómo entiendes el
problema y encuentras una solución. Por lo general, estos retos son muy singulares y muy específicos. Realmente no puedes buscarlos en Google y encontrar una solución, por ejemplo. Entonces, si practicas
mucho estos desafíos de
codificación y hogar tu
capacidad para resolverlos, mejorando tu pensamiento lateral, entonces esto te hará muy atractivo para los empleadores
potenciales. Los empleadores no
buscan personas que puedan regurgitar y Buscan personas y
fomentan el pensamiento lateral. Y estas
pruebas de codificación en línea son perfectas para eso. No sólo eso, estos dos
sitios web que he sugerido, hacen un seguimiento de qué ejercicios ya
has resuelto. Y crean un perfil
como una pequeña tabla de líderes. Ya sabes cuáles
has resuelto. Y no veo ningún
problema en imprimir esto o enviarlo
a un posible empleador. Entonces ellos realmente pueden ver
qué retos has hecho. Y pueden ver que, ya sabes, no
es solo una carrera que quizás quieras o un trabajo que realmente
disfrutas haciendo esto. Y esto es lo
que buscan y esto es lo que
te separa de otras personas. Y nuevamente, no se
trata sólo de conseguir un trabajo. Incluso a las personas aficionadas les encantan
estos desafíos de codificación. Sabes, realmente
funciona tu cerebro. Es un muy buen
ejercicio de entrenamiento para tu mente, así que te recomiendo encarecidamente las pruebas de codificación
en línea. Una cosa más que puedes hacer es practicar preguntas de
entrevistas de trabajo de muestra, incluso si no estás
planeando ser empleado. Porque realmente ponen a prueba tus
conocimientos y te ponen en el lugar cuando quitas este
curso de tu laptop, por
ejemplo, digamos que
lo cubres con la mano o con un libro y en realidad te preguntas,
¿qué es el polimorfismo ¿Puedes responder esa
pregunta sin mirar este curso o buscarlo en Google por
ejemplo? ¿Eso es posible? ¿Y si te pregunto, qué es la
sobrecarga de métodos o a qué me refiero cuando digo clase abstracta
o abstracta Y ¿qué es la encapsulación y qué se diferencia eso de, ya
sabes, otro término ¿Honestamente puedes responder
estas preguntas? Entonces así es como
realmente te pones a prueba, ya sea que entiendas
los principios. Es fácil ver a
alguien más hablar de
algo y decir, oh, bien, sí, lo entiendo. Pero si cubres el material con la mano y
lo escondes de tu vista, puedes decir honestamente,
bien, el polimorfismo es Entonces es una cosa, leer algo y
entenderlo, pero es otra cosa,
recitarlo de vuelta en tus propias palabras Y eso es muy importante
no sólo para conseguir un empleo, sino también entender realmente todo lo que abarca
este curso. Por lo que recomiendo encarecidamente
hacer esto también. Entonces lo último que
voy a mencionar en términos de qué
voy a hacer a continuación, por qué tomaste este curso. Algunas personas pueden haber tomado este curso para
pasar a otra cosa. Quizás querías hacer desarrollo de
juegos en Unity. A lo mejor querías
desarrollar sitios web, así que necesitabas conocer el agudo. Entonces puedes aprender la Red
Spot, por ejemplo. O tal vez quieras
crear formularios para una aplicación de escritorio o
una aplicación móvil. Puedes aplicar sharp a
todos estos escenarios, pero requieren más
conocimientos para cumplir con éxito el rol o cumplir lo que quieres hacer. Pero en términos de conocimiento y comprensión y
práctica en C sharp, este curso será muy
útil para esas aplicaciones. Te puedo decir que al 100% si quieres empezar a
crear juegos en Unity, encontrarás que
conocerás prácticamente
todo el C sharp. Necesitas saber, o
al menos saber buscar e investigar para cualquier nuevo método
y clases que desees usar. Cualquier conocimiento requerido para
crear videojuegos en Unity evolucionará en torno a comprender y aprender el motor Unity, por ejemplo, que
es muy diferente. Pero en términos de C Sharp, estás cubierto de nuevo para
crear aplicaciones móviles. El C sharp ya cubierto, Quizás solo necesitas aprender algunas cosas gráficas o de nicho para hacer con aplicaciones móviles. Así que nuevamente, este curso se
shop será un punto de apoyo perfecto para
lo que quieras lograr Cualquiera que sea tu objetivo final. Entonces lo último
que voy a decir es, nuevo, muchas
gracias por ver. No olvides compartir conmigo
tus proyectos finales si deseas acometer esos. Si tienes alguna duda, envíame un mensaje
y deja un comentario. Y solo hazme saber cómo fue
el curso para ti. Y tal vez dentro de cinco
a diez años cuando eres un desarrollador de
software profesional, tal vez puedas enviarme un mensaje y solo dejarme saber
cómo te va y decirme si este curso
te ayudó a largo plazo. Estaré creando más cursos, así que siéntete libre de
revisarlos por última vez. Muchas gracias por
ver Cuídate.