Transcripciones
1. Introducción avanzada de C#: Hola ahí y bienvenidos a mi curso y temas avanzados de
C-sharp. En esta serie de videos, vamos a estar sobre los
detalles del curso o clase
anterior y continuar nuestro viaje para echar un vistazo a
conceptos avanzados en C-Sharp. Y este curso se va a acompañar con
un repositorio Git, que te va a permitir ampliar tus conocimientos,
reproducir los ejemplos. Entonces, si quieres aprender algo más
complejo y C-sharp, entonces este curso va
a ser el adecuado para ti. Nos vemos en la siguiente.
2. C# Avanzó la configuración: Hola ahí y bienvenidos de nuevo. En este breve video,
vamos a ver el entorno en el que puedes seguir a
lo largo de los ejemplos. Entonces, básicamente,
tienes dos opciones. Una es que puedes usar
con Visual Studio apresurado, puedes usar la versión 29
o la versión 2022. Se puede descargar desde el lado
oficial de Microsoft. Y básicamente, lo
que hay que hacer es abrir el Instalador de Visual
Studio. Y puedes dar clic
en modificar. Aquí. Es necesario tener el desarrollo dotnet
comprobado e instalado. Una vez que tengas esto instalado, podrás
seguirlo. Esa es una opción. La otra opción que puedes usar es el Código de Visual Studio. Y Visual Studio Code, puedes comprobar las extensiones
y comprobar si hay C sharp. Esto es un poco lento. Pero básicamente, si
instalas esta extensión, también
deberías estar bien. Entonces eso era todo lo que estoy usando, básicamente una máquina Windows. Y eso es todo. Nos vemos en la siguiente.
3. C# Logical avanzado y Bitwise: Hola ahí y bienvenidos de nuevo. En este video,
vamos a aferrarnos. Vamos a hablar operadores
lógicos y bit a bit
y cómo puedes usarlos. Tan lógico y sabio. De acuerdo, vamos a crearlo. Entonces, básicamente, cuando
hablamos de
operadores lógicos y bit a bit y C-sharp, C-sharp soporta cuatro
tipos principales de operaciones que se
agrupan en base la idea detrás de su existencia. Por lo tanto, las categorías son aritmética,
relacional, lógica, asignación
bit a bit, y algunas operaciones
misceláneas. Los operadores aritméticos
suelen realizar operaciones en dos números. Entonces quieres sumar dos números, multiplicar, dividir, etcétera. Los operadores relacionales se
utilizan para comparar o Chegg, calidad del
objeto de entrada u objetos. Y los operadores lógicos nos
permiten comparar un poco de un objeto dado y siempre
devuelve un booleano como resorts. Entonces, ya sea verdadero o falso, los operadores
bit a bit
realizan la operación en bits
individuales y los
resultados son siempre bits. Y los operadores de asignación nos
permiten inicializar un objeto con un valor para
realizar una operación específica. Y también hay otro concepto
importante que es la precedencia del
operador, que los operadores son
más fuertes que los demás. Y esto narra la lógica de cómo se evalúan las expresiones
complejas. Entonces, si queremos echar un
vistazo a los operadores lógicos, podríamos hacer lo siguiente. Agreguemos la
tecla correcta al final. Y podríamos decir que
tenemos un booleano a, que es cierto, y el
booleano b que es falso. Podríamos usar la línea
derecha de la consola para comprobar si cuál es el
valor de a y B. O podríamos comprobar
el valor de ohmios o línea
derecha a o B, y así sucesivamente. Si iniciamos esto o
bien lo
ejecutamos, podemos ver que a y B es
falso y a o B es verdadero. Entonces cuando estamos
hablando del operador final, tenemos que saber que
la condición es verdadera cuando ambas entradas
son verdaderas, de lo contrario es falsa. La condición en caso
de operadores OR, la condición es verdadera
cuando cualquiera de ellos es verdadera, de lo contrario es falsa. Entonces eso tal vez
se trata de los operadores lógicos
y tenemos negación. Y si usas signo de
exclamación antes de la variable, no obtendrá su valor. Entonces hemos definido un s verdadero, y aquí si negamos
verdadero, obtenemos falso. Ahora, lo que también podemos comprobar
son los operadores bit a bit. Así que podemos tener una matriz int
que va a ser seis. Y llamémoslos C y D. Y la D va a ser 17. Entonces, si queremos usar
los operadores bit a bit, lo que podemos hacer es lo siguiente. Por lo que podríamos usar el
convert to string. Esta es una función que
permite convertir una cadena. Y podríamos decir que a o B. Y también podríamos
usar los dos aquí. Entonces déjame sólo revisarlo. Entonces conviértanse a cadena a o B. Y si vamos, Aguanta, es C o D. ¿De acuerdo? Entonces básicamente cuando
usamos el operador OR, actúa como si tuviéramos algunos
que estos dos números. Entonces tenemos el valor de 23. Y podríamos tener, Vamos a comprobar sólo para ser dos veces representación
de estos números. Entonces seis es 0000110. Y tenemos el 17, que va a ser
ceros, ceros 010001. Y también nos vendría bien
la operación AND aquí. Si lo ejecutamos, obtenemos este valor. Y ya sabes, cuando echamos un
vistazo a la operación final, obtendríamos una. Si en ambos casos
hubo uno, de lo contrario obtenemos 0. Por eso obtenemos ceros. Resultado porque ninguna de estas columnas se alinean
para obtener el valor uno. Y podemos usar el operador AND
bit a bit. Entonces eso se ve así. Y eso es menos siete. Y podríamos usar el operador OR
bit a bit C o D. Y esto nos da 23. Y técnicamente eso es todo. Eso es lo que quería
mostrarles en este video. Nos vemos.
4. C# Const avanzado vs solo lectura: Hola ahí y bienvenidos de nuevo. En este video
vamos a
hablar de la diferencia
entre costo y solo lectura. C-afilado. C-sharp
facilita palabras clave como concentrado solamente o
estática de solo lectura incluso. Y puede ser
confuso al principio. Tenemos que conocer las pequeñas
diferencias que existen entre ellas. Entonces la palabra clave const no
es más
que una constante. Entonces por ejemplo, a costo
cadena, mi cadena. Y podríamos decir que
esto es una cuerda. Y cambiemos esto a
comillas dobles. ¿De acuerdo? Ahora se está quejando de
que está asignado, nunca se usa, pero eso está bien. Entonces por defecto, si no le damos un valor
a esta cadena constante, nos dará un error
porque se debe inicializar. Por eso está
subrayado con rojo. Pero después de darle valor, debería estar bien. Y uno, cuando definimos
la función constante, es básicamente una
excepción a esto. Entonces, por ejemplo, si
tiene una prueba de cadena estática, y podríamos decir que tenemos un
valor de prueba de cadena constante y el retorno. Entonces básicamente tenemos que escribir la restricción my y la línea derecha de la consola. Eso va a usar
teléfonos todas las tres teclas. Para que podamos tener el
prompt, vamos a ejecutarlo. El valor de las
constantes no puede cambiar durante la ejecución. Recientemente, la palabra clave es
un modificador especial que se parece mucho
a la palabra clave constante. Y se puede usar en campos, pero no en variables locales. Entonces estos campos pueden ser
inicializados cuando se declaran, ¿cuáles son el constructor
de nuestro objeto? Y esta palabra clave asegura que la instancia variable
o propiedad de un objeto no se pueda modificar
después de la inicialización. Y tal intento resultará
en una excepción de exención. Y por qué las constantes en él se inicializan en tiempo de compilación. La palabra clave de solo lectura
permite
inicializar las variables ya sea en tiempo de
compilación o en tiempo de ejecución. Por lo que podríamos tener la columna de
cadena pública de solo lectura por Mike era compilar en ella. Y podríamos simplemente
dejarlo tal como está. Entonces, por ejemplo, podríamos
tener como un estudiante de clase. Y esta clase podría tener la cadena
pública de solo lectura, nombre completo. Y el nombre de cadena del
estudiante público. El nombre completo es igual al nombre. Y si vas a la principal, podríamos crear a nuestro alumno. Después ER y New Student, y usa la línea derecha de la consola para imprimir la
danielle para el nombre. Y ahora podemos ver
la salida. Está ahí. La diferencia central en el nivel
más alto si queremos
diferenciar la palabra clave de solo lectura
y la const. Por lo que podríamos decir que la
diferencia radica en cuando se conoce
el valor de la variable a través del
ciclo de vida de la aplicación. Para la palabra clave de solo lectura, el valor se conoce
más reciente por tiempo de ejecución, que para la palabra clave const, el valor debe
conocerse por tiempo de compilación. común de estas
palabras clave es que ambas
cubren tipos de datos
inmutables, lo que significa que el valor no puede cambiar lo largo de la vida
de la aplicación. Para la palabra clave const, la variable marcada
como tal es colocada por el compilador en los
metadatos ensamblados que definen la constante y los metadatos
e incrusta el valor al código
del lenguaje intermedio después de la inicialización. Esto significa que no
hay asignación de memoria que cuatro constantes durante el
tiempo de ejecución bajo el capó, el valor de solo lectura no
es una constante. Se almacena en el montón del cargador, que es un
tipo memorial que no se puede asignar hasta que se cargue el
tipo. Entonces, técnicamente, eso era
todo lo que quería decirte. Nos vemos en la siguiente.
5. Alcance y visibilidad avanzados de C#: Hola ahí y bienvenidos de nuevo. En este video
vamos a
hablar de alcance y visibilidad. Entonces estos son
conceptos muy cruciales o básicamente cruciales para entender. Y la mayoría de los lenguajes de
programación por ahí incorporan
este concepto. El diseño, la estructura
en la que viven sus datos, y muestran la dirección en
la que los datos pueden fluir. Primero,
profundizamos en la visibilidad para comprobar el alcance. Entonces, por ejemplo, si
hablamos de visibilidad, necesitamos considerar
un método de clase y visibilidad
variable o
al menos estos constructos. Sin embargo, hay cinco tipos
diferentes de visibilidad. El primero es público, el segundo está protegido. El tercero es interno. Fuerzas protegidas internas,
y la quinta es privada. público es el tipo de visibilidad más
indulgente. El miembro definido de esta manera se
puede llegar desde cualquier lugar. Los miembros protegidos
especificados sólo pueden ser alcanzados desde la misma clase
o desde dentro de la clase. los miembros internos especificados Se puede llegar alos miembros internos especificadosdesde
el mismo proyecto. Y
se puede llegar a los miembros
internos protegidos desde el
mismo proyecto o aquellas clases que
heredan de la clase, ya sea de otro proyecto. Los miembros privados especificados pueden ser alcanzados por otros
miembros de la misma clase. Por defecto, las estructuras de clases se establecen a este nivel de visibilidad. Este es el más restrictivo. Entonces veamos demostración. En el espacio de nombres, tendremos la visibilidad de la clase pública. Y tendremos el mensaje de cadena
pública, que es que soy visible
desde cualquier lugar. Y tendremos el mensaje de viga de
cuerda protegida sólo del mismo cristal. Y mensaje de cadena interna sólo desde dentro
del mismo proyecto. Y tendremos el
mensaje de cadena privada, Dao chatbot. Entonces tendremos el vacío público. Pero mensaje arquitectónico. Este mensaje protegido
va a usar la consola. Línea derecha, mensaje B y línea de escritura de punto de consola. Pero si el mensaje, ahora, lo que podemos tener
es otra clase. Entonces la clase pública B, que va a heredar
de la clase de visibilidad. Y la estática pública. Vacío. Main va a hacer esto. Entonces visibilidad, una nueva visibilidad. Y una visibilidad B va a ser una
visibilidad. Agárrate. Lo que nos gustaría
hacer es seguir adelante y usar los teléfonos o
escribir línea un mensaje. Unos o un punto. Escribir línea a mensaje en la consola dot write
line aid at p0 message. Y ser Goodall, hizo Mensaje. Después se leen los conos. Por lo que ahora esto se puede eliminar. Deberíamos tener la línea correcta y tendremos el mensaje P. Tenemos la visibilidad ocular, y tenemos el vacío
estático público, principal. Esta va a ser
la nueva visibilidad de IA. Tenemos la visibilidad
V. Y el yo es el a visibilidad es nuevo yo visibilidad visibilidad para
ser como nueva visibilidad. Y si ejecutamos esto, deberíamos tener el
siguiente resultado. Por lo que esto demuestra
la visibilidad. Cuando estamos
hablando de alcances. Este concepto define una parte de la aplicación donde
la variable es accesible y se le llama
el alcance de una variable. O las variables se pueden definir en clases, métodos y bucles. Entonces, por ejemplo, si tenemos definida
una
variable de nivel de clase cast, se ve así. Entonces clase pública a. y podemos tener el
evento a, que es seis. Y cuando declaramos una variable en la clase
fuera de cualquier método, se puede acceder a
ella en
cualquier lugar de la clase. En nuestro caso, al
igual que la variable a. cuando definimos una variable de
esta manera se les llama campos de clase
o miembros de clase. Por lo que podemos hablar de visibilidad
a nivel de método también. Y podemos definir,
por ejemplo, vacío. Primero. Este va a ser nuestro método. Y tendremos un doble C, que va a
ser diez, eso es 0. Y podríamos tener la línea derecha de la
consola C. De
esta manera demostramos cómo
los métodos encapsulan nuestro propio, su propio espacio de nombres y las
variables definidas dentro. Podemos ver cómo
se supone que debe imprimirse el valor de la
variable . Y también podemos crear un
bloque de variables de nivel. Y esas variables definidas
en un bloque van a vivir sólo o ser accesibles mientras estemos en la ejecución del
bloque. Entonces eso era todo lo que
quería mostrarles sobre alcance y visibilidad. Nos vemos en la siguiente.
6. C# Avanzado Inseguro: Hola ahí y bienvenidos de nuevo. En este video,
vamos a
hablar de inseguro en C-Sharp. Entonces básicamente estamos
hablando de código inseguro en C Sharp. Cuando codificamos el código, ejecutamos el código sin
supervisión del CLR, que es corto para el tiempo de ejecución del lenguaje
común. Por lo tanto, el código inseguro es un código
que puede incluir punteros. Por lo que puede sacar una
conclusión de que los punteros son
inseguros en C-sharp. No obstante, no es del
todo cierto y
estamos aquí para arrojar algo de
luz sobre este misterio. Por lo que el CLR controla
la ejecución de programas desde la carga a la
memoria hasta la seguridad del tipo de
manejo de excepciones. Hay numerosas
instalaciones proporcionadas por CLR y hay dos
instalaciones que se proporcionan. El primero es el recolector de
basura, que se supone que debe
limpiar después de los objetos no utilizados. Y el segundo es el manejo de
hilos. Por lo que hay dos componentes principales
del framework .net. Tenemos el laboratorio base, BCL, que es la biblioteca de clases base, y el CLR, que es el tiempo de ejecución del lenguaje
común. Por lo tanto, BCL no es más que
la biblioteca estándar de dotnet, que se puede acceder
a través de aplicaciones de consola , aplicaciones
VPN, ASP.Net, etc. Se trata de un conjunto de clases y
funcionalidades
predefinidas que puedes reutilizar. Entonces básicamente me puedo
descomponer en dos partes más, el CTS, CTS y el CLS. El CTS es la especificación de
tipo común y el CLS es la especificación común del
lenguaje. Necesitamos aclarar dos conceptos más
que son necesarios para entender la
ejecución del código de respuesta y lo que significa. Entonces dos tipos de código que es código
administrado y código no administrado. El código administrado se
considera código seguro. El no administrado es código inseguro. Entonces, básicamente, el código administrado corre enteramente bajo la
supervisión de CLR. Se rastrea y
se recoge la basura automáticamente. También tiene acceso a todo
el arsenal de
instalaciones que brinda CLR. Ahora, aquí vienen los punteros. Por lo que los punteros sólo se
interpretan en el
contexto, contexto de código no guardado o
inseguro o no administrado. Y un puntero puede
ser un tipo de puntero, un tipo de valor, tipo de referencia. Entonces para definir un puntero, necesitamos el siguiente código. Podemos tener una estrella int, que se va a
llamar mi puntero int. Y podemos tener una
estrella del vacío, mi puntero vacío. Y al nombre del
tipo definido antes del astérix se le llama
el tipo de referencia. Los tipos de puntero
no heredan de la clase
base de lugar de objeto y no
hay conversión entre los tipos de
puntero y la clase de objeto
base. También podemos definir
múltiples punteros. Entonces int, estrella por daños, mi salud, mi experiencia, etc. El recolector de basura
no protege las referencias del
objeto. Significa que aunque apunte a una referencia o a una estructura que
contenga referencias, el recolector de basura
puede recogerla, o si la recoge. Entonces si está prohibido,
es, está prohibido que un
puntero apunte a una referencia o a una estructura
que contenga una referencia. Y podemos tener puntero de
los tipos de base en C punzantes. Entonces vamos a demostrarlo. Voy a comentar esto. Así que aquí tenemos matriz, que va a
contener dos enteros, que van a ser 12. Y podemos usar la estrella int fija p es igual a 0. Aquí, lo que nos gustaría
hacer es tener P2, que es igual a p. y usar la consola,
la consola, derecha, línea, estrella V2 o asterix P2. Entonces para deshacernos del rojo por
la línea, podemos decir que esto es inseguro. Y básicamente después de eso, veamos la prueba. Muy bien. Usemos la consola. Hay tres claves
para leer el valor. Así que ahora como se puede ver, tenemos un puntero
que apunta
al primer elemento de la
matriz, que es uno. Y la palabra clave answer if
marca la sección del código que para el compilador
que sostendrá punteros. La palabra clave fija significa que
pinchamos el asterix, ser muy capaz. Entonces este encima
de nuestro montón y el último asterix ser más es igual a
uno se llama deferencia. Están haciendo referencia. Entonces, básicamente, si seguimos adelante
y hacemos algo como esto, entonces asterix p plus equivale a uno. Entonces podemos usar la consola
dot write line asterix be. Por lo que ahora si lo
ejecutas, puedes ver que movimos
nuestro puntero con un índice. Por lo que hay una lista
de operadores y declaraciones que podemos utilizar para manipular punteros en la
respuesta si el contexto. Entonces podemos tener básicamente
el acceso de los miembros. Podemos tener la indexación, podemos tener la
dirección de una variable, podríamos tener los operadores
aritméticos, y podemos tener
operadores de comparación y así sucesivamente. Así que podemos tener también algunas
declaraciones que es fijo y pila son log tan atascado y bloqueado significa asignar memorial
en la pila. Y si desea verificar la
respuesta si propiedades de capa, podemos tener métodos, tipos y bloques de código, cuales pueden definirse
como seguros ya que el código es requerido para funciones
nativas que
dependen de punteros y Asif código, el introduce riesgos de seguridad y estabilidad del
código que contiene nuestros sub-bloques necesitan
ser compilados con inseguro que lo que arreglamos aquí. Y en algunos casos como
si Dios pudiera resultar en un mejor rendimiento ya que se eliminan
los
controles de límites de matriz. Entonces eso era todo lo que
quería mostrarte sobre inseguro. Nos vemos en la siguiente.
7. Colecciones genéricas avanzadas de C#: Hola ahí y bienvenidos de nuevo. En este video,
vamos a hablar colecciones
genéricas
para que podamos llamar. Entonces eso es
lenguajes de programación vinieron a vivir. Por lo general había un requisito
común entre ellos y la gente quería almacenar datos una manera estructurada
para más adelante en el tiempo, recuperarlos y manipularlos. Eso eran operaciones genéricas
que comúnmente se realizan en estos
conjuntos de datos como impar, eliminar, encontrar, ordenar,
reemplazar copia, clonar, número de elementos
almacenados, y así sucesivamente. C-sharp y dotnet no son la
excepción en esta situación. Por lo que hay básicamente dos
tipos de colecciones que se proporcionan con un marco
a nuestra disposición. El primero es enero, y el otro no
es genérico, pero tuve que dotnet versión dos, sólo
hay colecciones. Y si desea categorizar colecciones
no genéricas, podemos hablar de
ArrayList, tabla hash, lista
ordenada, pila, cola, y las Colecciones genéricas al
menos diccionario se
ordena pila de lista y cola. Por lo que la principal diferencia entre las colecciones
genéticas y no genéticas es que el valor de los tipos que pueden almacenar en la colección
no genérica. Cada elemento puede representar
el valor de diferente tipo. En tanto que el genérico significa que solo
puedes tener el mismo tipo. Entonces, básicamente, necesitamos el sistema de que las colecciones
son genéricas para usarlo. Y nos permite
crear, por ejemplo, una lista de enteros
llamados mi lista. Y básicamente queremos
una nueva lista con, por ejemplo, diez valores. Esto significa que
tenemos una lista que sólo
puede almacenar enteros. Se llama mylist y corrió valores
medio abajo sin
la sentencia using, podríamos especificarlo de
la siguiente manera. Entonces básicamente podríamos
dar el camino completo. Eso es sólo por interesante. Por su interés. Lo que también podemos hacer es
revisar la tabla hash no genérica. Una tabla hash. Deberíamos llamarlo mi hash. Y esto va
a tener un nuevo hash, la barra o más bien hash set. Hash establece y muestra potenciales
los corrige . Entonces sistema que llama elecciones, ese genérico, ese conjunto hash. De acuerdo, entonces
tendremos el HashSet. Y esto debería ser como un entero o
algo así. Y nosotros que ver con los n valores, no. Enero en capacidad. O debería ser HashSet D. Pero debe ser C hash sharp, hash hash table. Así que vamos a hacer esto con la tabla hash. Entonces vamos a aceptarlo. Oh, esto debería ser un sistema de llamadas acciones que
hash el arco, mi hash. Y ahora podemos continuar. Entonces básicamente llamemos a este
nuevo sistema llamado elecciones. El balón. Genial. Entonces lo que podemos hacer es lo
siguiente, mi hash. Y tendremos la habilidad
compartir con el valor primero. Y mi hash ese sitio de Ed Lu. Y esto debería
llamarse segundo. Ahora, genial. Entonces lo que podemos hacer aquí
es lo siguiente. Entonces por cada 13 D en mi hash. Y creo que esto
también va a venir de las colecciones del sistema esa entrada del
diccionario. Genial. Lo que también podemos
hacer es simplemente
externalizarlo aquí usando el sistema
que las colecciones. Y ahora podemos quitarlo. Genial. Así que nos
gustaría iterar sobre estos y usar la línea derecha de la
consola. Y tendríamos la
clave D igual a ese valor. Y usa la consola para leer clave. Para aceptar este
valor, Vamos a ejecutarlo. Y si lo ejecutas, deberíamos ver el
siguiente resultado. Entonces así es como
podemos usar tabla hash. Lo que también podemos hacer es
tener un ArrayList genérico. Así que básicamente, vamos a
crearlo lista de matriz. Mi lista también es igual a
nueva lista de matriz. Y no daríamos un
argumento en este caso. Y usar el mi lista para
agregar una milla es agregar
a mi lista tres
lineales y así sucesivamente. Así que sólo por el bien de demostración, y para cada guerra de objetos
por elemento en mi lista, dos, íbamos a seguir adelante y consola punto escribir elemento de línea. Genial. Ahora, lo que podemos hacer es ver la salida en la
pantalla después de la ejecución. Y básicamente eso es todo. Por lo que también hay otro concepto que se llama
boxeo y unboxing. Y este concepto es
muy importante cuando estamos trabajando con
genéricos en C Sharp. En general, el concepto y su realización proporciona
algunos beneficios de las colecciones fuertemente tipo, así
como proporcionar mayor calidad y
rendimiento impulsado código. Hay dos categorías principales
para el tipo de datos es C-sharp. Uno se llama tipo de valor y el otro se
llama tipo de referencia. El boxeo es el
proceso de convertir un tipo de valor a un tipo de
referencia. Y detrás de escena, el CLR asigna nuevo
objeto en el montón, luego copia el valor del valor de los tipos de valor
a esa instancia. Por ejemplo, tenemos un entero que es a
b con el valor 99, un objeto B, que
es igual a a. y cambiémoslo de esta manera. Y tenemos a, C
con el entero b. y ahora lo que podemos hacer es usar la línea derecha de la consola, ver, más b, más a. y ahí vamos. Entonces no hay espacio
entre el espacio que no
sea engañoso. Y aquí vamos. Entonces técnicamente eso era
todo lo que quería mostrar. Tú. Nos vemos en la siguiente.
8. C# Conversiones explícitas avanzadas con cifras implícitas: Hola ahí y bienvenidos de nuevo. En este video, vamos a continuar nuestro viaje C-sharp. Y vamos a hablar conversión de
tipo
explícita e implícita. Entonces, básicamente, hay dos categorías principales
de lenguajes de programación. El primero es tabulador estáticamente, y el segundo se escribe
dinámicamente. Así que estáticamente tipado
estos como C-Sharp, C, C más, más y así sucesivamente. Y dinámicamente tipado es como Python y Ruby y otras cosas. Y la tipificación dinámica a veces también se conoce
como tipificación de pato. Entonces básicamente si
parece un pato, camina como un pato y
charlatra como un pato. Entonces probablemente sea un pato. Vamos a echar un
vistazo a las características proporcionadas por C-sharp con respecto a la
tipificación estática en C-Sharp, cuando se declara una variable, no
se puede declarar de
nuevo ni asignar un valor de otro tipo. Tipo. El tipo es implícitamente convertible a un tipo de variable
dado. Esto se decide durante el tipo de
compilación y plantea una restricción en cuanto a cómo un desarrollador usaría
declarar variables, aunque también viene con
un bache de velocidad en la ejecución. Por lo tanto, los
lenguajes estáticamente tipados suelen ser más rápidos que los
tipados dinámicamente, pero ambos tienen sus ventajas
y estas ventajas. Entonces por ejemplo, si
decimos que tenemos un entero que
es j en C-Sharp, entonces no podemos hacer lo siguiente. Asignar cadena como valor. Esto simplemente
no va a cortarlo. Pero lo que podemos hacer es
asignar un valor de diez o hacer lo siguiente que 0. Se supone que estos funcionan. Y esto nos daría un anuncio o porque el entero y una cadena o no
implícitamente convertible, podría
llegar un
momento en el que necesitemos copiar un valor de
otro valor aquí, valor de un variable
a otra variable, como pasar entero a
un método que toma un doble argumentos largos
o permanecer una para empujar variables entre clases. Por lo tanto, C-sharp proporciona formas de convertir un tipo a otro. Uno está implícito, el
otro es explícito. El tercero es definido por el usuario, y el cuarto es la conversión
con clases de envoltura. Por lo que la conversión de tipo también se
llama fundición o encasillamiento. Conversiones implícitas. ¿ Qué debemos saber de ellos? Básicamente, cuando
hablamos de conversión implícita, eso no es una sintaxis especial
para este tipo de conversión. Este es el
tipo de fundición más seguro. No se pierden datos. Por ejemplo, convertir
de tipos enteros
más pequeños a más grandes o
clases a clases base. Esa es una tabla de
conversión numérica implícita, es decir, que resulta útil
cuando queremos
averiguar qué enteros
son compatibles. Y lo puedes encontrar aquí
en el lado de Microsoft. Y por ejemplo, para una conversión
implícita, podríamos utilizar lo siguiente. Vamos a esconder esto. Así que tenemos un entero que
se llama número 128, y tendríamos un doble, que es un más grande, y
es igual al número. Y la amplitud es un ejemplo
de conversión implícita de clase a clase base
sería algo así. Clase a es igual a clase nueva. Y tendríamos
la clase base C, que es igual a a. esto es sólo un ejemplo porque estos no están bien definidos, pero así es como
podrías y debes hacerlo. Y hay una serie
de conversiones, subtipos que todos se
consideran implícitos. Entonces, por ejemplo, conversiones de
identidad ,
conversiones numéricas
implícitas, etc. Ahora tenemos
conversión implícita fuera del camino, deberíamos hablar de
X más versiones tranquilas. Por lo que este tipo de fundición también
implica un operador de costos. Y el proceso suele estar asociado con la
pérdida de información o
la falta de conversión entre conversiones típicamente
no métricas. Mencioné cuando convertimos de un tipo de datos de precisión más grande
a una precisión menor y veces
convertir de una clase base a
una clase de base de datos es todo
show también se menciona aquí. Entonces un ejemplo para una
conversión explícita sería mi pi. Y diríamos que
tenemos
un entero a y nos gustaría tener el valor como un entero de
mi pastel asociado con a. y si fuéramos a usar la
línea derecha de la consola con a y mi b, obtendríamos la siguiente clave de avaricia de
Guanzhong. Vamos a guardarlo y ejecutarlo. Entonces podemos ver que el decimal, los números después del
punto donde corte. En este caso, podemos
hablar de conversiones ejecutadas
entre clases. Entonces tenemos, por ejemplo, una clase OPA, que es el auto. Y esto sería una
instancia de la clase alta. Y tendremos un auto C, que va a ser igual a o. y tendríamos el
OPA o igual a c. Así que este es un ejemplo conversión
explícita entre
clase y clase base. Y básicamente eso es todo. Lo que quería mostrarte. Nos vemos en la siguiente.
9. Funciones con cuerpo de expresión avanzada: Hola ahí y bienvenidos de nuevo. Ahora lo que nos gustaría
aprender en c-sharp es el tema, la expresión, pero
funciona sintaxis. Pero funk, sintetizador Don't Save. De acuerdo. Por lo que con la versión de la versión
seis del lenguaje C Sharp, esa característica se agregó
al lenguaje de programación. Se llama expresión miembros con
cuerpo. La idea detrás de esta
característica era hacer el código más
legible y conciso. Y vamos a
ver en este video cómo esta nueva característica se puede
incorporar a nuestro código. Entonces tenemos el
concepto de miembros en C-Sharp, y está relacionado con la programación
orientada a objetos. Los números nos permiten
modificar el comportamiento de nuestra clase y cambiar la
forma en que interactúa con otras clases y
dejarla y la
información capsulada según sea necesario. Por lo que los miembros son el pegamento que mantienen unida la aplicación. Entonces, ¿cuáles son los miembros
que están disponibles? Contamos con constructores,
destructores, captadores y setters de
propiedades,
métodos e indexadores. La expresión pero
en miembros se puede aplicar a cualquiera de los
anteriores que mencioné, pero necesitamos
considerar cuál está disponible en nuestra versión
actual. Por lo que soporta versiones
de la versión seis, la propiedad getter y métodos. A partir de la versión siete,
el constructor, sector inmobiliario
destructor y los indexadores. Entonces tomemos un ejemplo para el constructor y destructor. Entonces básicamente
tendremos un servidor de clase. Dentro de nuestra clase, tendremos
el nombre de la cadena pública y
el nombre de cadena del servidor público
es igual a nombre , igual a nombre. Y tenemos que
asegurarnos de que esta la M mayúscula y esta
es la N.
capitalina Muy bien, ahora, podríamos tener nuestro destructor
para el servidor. Y podríamos simplemente decir en la línea derecha de la consola
que el final está cerca. Muy bien. Ahora lo que tendríamos aquí, llamémoslo a esta
clase pública const buddy. Y tendríamos nuestro
público estático, vacío principal. Y tendríamos el servidor, que es un del nuevo servidor. Entonces aquí, o más bien controlador
de dominio. Y después de eso, lo que podríamos hacer es usar el punto de la consola, escribir línea un nombre, y usar la tecla de consola. Espera a que el prompt. Ahora si lo ejecutamos, podemos ver la siguiente ODE. Y sí, básicamente eso es todo. Entonces así es como
podemos usar en los miembros. Lo que también podemos hacer es
usarlo en básicamente accesores. Entonces, por ejemplo, si
se supone que mi servidor tiene
un público en V CPU, entonces podríamos tener
el get return el v Scott v CPU, y el sector devolver
el guión bajo V
CPU es igual al valor. Y sí, tendríamos también el int
privado subrayado V CPU. Entonces así es como podríamos aplicarlo básicamente
a la fuente de acceso. Entonces podríamos seguir adelante y usar
una vCPU para ser igual a diez. Y podríamos
agregarlo a nuestra salida. Si lo
ejecutamos, podemos ver que este servidor, tiene diez núcleos. Y también podríamos
tener un indexador usado. Entonces técnicamente si definimos la cadena pública y
llamamos a esta red, entonces esta podría ser una nueva
cadena con cinco valores. Y podríamos usar
la cadena pública. Y este int me dan adaptadores
de red. Y los adaptadores de red
equivalen al valor. Y ahí tenemos los adaptadores de red
con esta cadena. Y deberíamos tener esta I. Y esta con el índice. Así es como lo
usaríamos en indexadores y también
podríamos usarlo en métodos. Entonces, básicamente, si
definimos nuestro vacío público, podríamos tener la línea
derecha de la consola arrancada. Y luego decir que el
estado es igual a Iniciado. Y para que esto funcione, necesitamos definir el estado
privado String pub. Y eso es algo así. Entonces esto es todo lo
que quería contarte sobre la expresión,
pero funciona. Por lo que esta es una forma más nueva
y concisa usar tus clases
con todas sus golosinas. Nos vemos en la siguiente.
10. C# precedencia del operador avanzado: Hola ahí y bienvenidos de nuevo. En este video,
vamos a hablar precedencia
del operador en C-Sharp. Entonces vamos a crear nuevo
proyecto para esto. Entonces, básicamente, el orden de
los términos y expresión en cualquier lenguaje de programación se determina el resultado
de la evaluación. Y la
precedencia del operador en C-Sharp determina cómo ocurre la agrupación de estos términos y
expresiones. Y caminaremos por esencial en cuanto
a lo que debes conocer esta técnica y crear apps
semánticamente correctas. Por lo que hay tres tipos
diferentes de operadores que son operadores unarios, binarios y ternarios. Y estos definen cuántos
operandos y operador pueden tomar. El United toma uno, el binario toma dos, y la curtiduría toma
tres operandos. Tenemos que
hablar de asociatividad. Entonces, básicamente, hay dos
tipos de asociatividad es, uno es el de izquierda a derecha
y de derecha a izquierda. Y la precedencia del operador es significativa sólo si hay operadores de precedencia
mayor y menor en una expresión. En este caso, la precedencia
es de izquierda a derecha. Entonces, por ejemplo, int x es igual a siete más tres dividido por dos. El orden que debemos
recordar es que cuando
hablamos de urinario, tenemos esta siguiente fuerza. Entonces tenemos el tamaño
del extremo, la estrella. El más, el menos, la negación, el más, más y el menos
menos prefijos. Y luego tenemos elenco tipo. Cuando hablamos de expresiones
condicionales, tenemos el signo de
interrogación y la columna. Y tenemos asignaciones
compuestas simples, Como iguales a veces iguales
dividido por iguales, y así sucesivamente. Y básicamente podemos cambiar la precedencia de los
operadores por paréntesis es, y esto es lo que quiero decir con eso. En el primer caso, primero
dividiremos tres por dos y luego sumaremos siete. En el segundo caso, sumaríamos 37 y
luego dividiríamos por dos. Entonces eso era todo lo
que quería mostrar. Tú. Nos vemos en la siguiente.
11. Puntos de entrada y salida con métodos avanzados: Bienvenido. En este video vamos
a hablar de métodos, puntos de
entrada y salida. Por lo que cada aplicación C, C-Sharp tiene un antropólogo
llamado método principal. Este método se invoca primero y se controla cualquiera que sea
la lógica de negocio que
se implemente en su AP
. Desde aquí. En esta guía vamos
a descubrir cómo CRM CLR, por lo que el tiempo de ejecución de lenguaje común sabe a qué método
llamar y cuándo llamar. Y vamos a
ver la diferencia en estos contextos entre
las aplicaciones ejecutables
y las bibliotecas. Entonces CLR es el tiempo de ejecución del
lenguaje común. propósito es
traducir su código para
que el hardware
de su máquina pueda entender sus intenciones. Cuando se escribe el
código en C-sharp, se le conoce
como código fuente. El compilador
específico del lenguaje
va a convertir ese
código en algo llamado MSAL o lenguaje
intermedio de Microsoft. Y a veces también
se le conoce como CIR, o lenguaje intermedio común. Y básicamente, el estado intermedio
del código también tiene metadatos específicos del
lenguaje y,
y la implementación de tipo y la implementación real
de cada una de nuestras clases, funciones, métodos, y así sucesivamente. Ahora el CRM CLR interviene
y proporciona un servicio y el tiempo de ejecución para que su código
viva y el GIT, el compilador de tiempo de ajuste
también vive en esta RAM, que convierte el código
en código de máquina, que a su vez es ejecutado por
la CPU de su computadora. El ejemplo más básico es lo
que se puede ver en la pantalla. Entonces Ponzo, esa
línea derecha, hola mundo. Y cuando ejecutamos este código, podemos ver que el Hello World está impreso
en la consola. Y después de eso se cierra. Así que cuando tenemos una aplicación que se compara con un archivo ejecutable, tenemos dos
enfoques distintos para los puntos de entrada. Uno es sincrónico y el
otro es asíncrono. El tipo de función principal
es siempre estática. Y tenemos la opción
de elegir si vamos a devolver el código de estado después que la aplicación exista o no. Y necesitamos usar
entero de lo contrario vacío. Entonces
los métodos sincrónicos son estos. Entonces si vamos aquí y hacemos esto, tan básico Curly, vamos. Tenemos un principal que
no devuelve nada sin argumentos. Uno es con argumentos, y el otro principal es devolver un entero
sin argumentos y el otro es con argumento. Y el otro tipo
se vería así. Entonces tenemos algo
llamado tarea en dominio. Y también puede tener versiones argumentadas
y no argumentadas. ¿ Por qué se duplica? Los puntos de salida sirven como mecanismo
de control y transfieren el
control de vuelta a la persona que llama. Ya sea con el valor
de retorno de un tipo específico o nulo. El principal método de llegar a
los puntos de salida significa que nuestra aplicación está cerrada. Entonces por ejemplo, si
dijéramos que volveremos 0, entonces este va a
ser nuestro punto de salida, por así decirlo, en una función. Y eso es todo lo
que quería mostrarles. Nos vemos en la siguiente.
12. Limitaciones de parámetros genéricos avanzadas de C#: Hola ahí y bienvenidos de nuevo. En este video
vamos a
hablar de restricciones de
parámetros genéricos. De manera genérica se convirtió en parte de
C-sharp con la versión 2 del lenguaje y el CLR, el tiempo de ejecución del lenguaje común. Se ha introducido
un nuevo concepto de parámetros de tipo que
permiten diseñar clases y métodos que difieren la especificación
de una o más pestañas hasta que se
declare la clase o método y instanciado
por código de cliente. Entonces, por ejemplo, si
fuéramos a crear una clase, clase matriz genérica d, y decir que tenemos
el vacío público. Resumir la entrada. Y así se podría
definir una clase genérica. Y básicamente, estas clases y métodos combinaron tres características
distintas. Una es la reutilización, la
segunda es la seguridad de tipo y la tercera es la eficiencia. Los genéricos se
usan con mayor frecuencia en conjunto con colecciones y métodos
que operan en ellos. Se introdujo un nuevo espacio de nombres, que se llama system
that collections, ese genérico, que contiene varias nuevas clases de
colección basadas en genéricos. También tenemos la posibilidad de
crear tipos genéricos personalizados. Por lo que necesitamos hablar de
parámetros también. Por lo que llamamos parámetro un
marcador de posición para un tipo específico que el cliente
especifica cuando
crean una instancia
de un tipo genérico. Una clase genérica
no se puede usar tal
cual, porque es simplemente un blueprint para ese tipo y
necesitamos declarar, luego instanciar un tipo
construido por tipo específico de volumen. Y podemos tener un
ejemplo para eso. Entonces, por ejemplo, si
tenemos esta matriz genérica, que es un entero, entonces así es como lo
haríamos instanciar. Y veamos las
posibles correcciones. Nosotros no tenemos uno. ¿ De acuerdo? Así que en este
ejemplo mostramos la instanciación de
instanciación para el blueprint de
array genérico con tipos enteros. Y en este caso el parámetro t se
sustituye en tiempo de ejecución. Y con el argumento tipo que nos permite crear un tipo objetos
seguros y eficientes
utilizando una definición de clase. Existen algunas reglas sobre nomenclatura, por lo que
los parámetros de tipo genérico deben tener nombres
descriptivos y prefijo parámetro de tipo
descriptivo T, o algo así. También tenemos ocho limitaciones que debemos tener en cuenta. Entonces déjame simplemente copiarlo
y pegarlo aquí. Entonces cuando d es un strikes, el argumento debe
ser un tipo de valor, excepto ahora la bola,
cuando es clase, el argumento debe
ser un tipo de referencia y se aplica a
las clases cuando t no lo es. Ahora el argumento debe
ser no, no liberal. Cuando no está administrado,
el argumento debe ser una M y cada tipo,
Es una clase base. El argumento debe ser
tratado desde una clase base. Cuando d es una instancia nueva, el argumento debe tener un medidor
padre menos constructor. Cuando se trata de una interfaz
ellos argumento debe estar ya implementado
en una interfaz específica. Y cuando eres tú, el argumento debe
ser o papi con del argumento
suministrado para ti. Entonces, ¿por qué usamos restricciones? cumplimiento de restricciones o parámetros de tipo
específico nos
permite aumentar el número de operaciones permitidas y llamadas a
métodos a las admitidas. Y lo que nos
gustaría hacer es
crear una demostración
para el examen. Permítanme simplemente comentar esto. Digamos que tenemos una clase, clase genérica con t, donde t es una clase. Y podemos decir que tenemos
una t privada de solo lectura, que es un campo. Y tenemos una clase
genérica pública, el campo o mejor dicho valor. Y esto subraya
campo es igual a valor. También tenemos el método
t genérico público con el medidor de fondo T. Y podemos seguir adelante y usar
la línea derecha de la consola. Y decir que el tipo
del medidor inferior es a la vez T y valor es valor. O más bien metro o metro de fondo. ¿ De acuerdo? Y el método genérico. Y las mujeres necesitan asegurarse de
que regresemos este campo. Y podemos usar la línea derecha de la
consola. La impresión de que
el tipo
de parámetro de retorno es dipolo. Valor T. Este campo de puntuación. Muy bien, aquí podemos
instanciar nuestra clase. Así que podemos tener una cadena de clase
genérica a, que es igual a nueva cadena de
clase genérica hola mundo. Y podemos usar la llamada al método
genérico a punto. Y podemos usar la
consola dot write line, no right line, read key para
hacer una pausa por un segundo. Y vamos a darle a esto
la cadena de argumento. De acuerdo, vamos a ejecutarlo. Y como se puede ver, tenemos una cadena con
la cadena de valor. Y ahí vamos. Entonces estos son los mensajes
que podemos ver. Técnicamente, eso era todo
lo que quería mostrarte. Nos vemos en la siguiente.
13. Tipos genéricos abiertos y cerrados con C#: Bienvenido. En este video
vamos a hablar los tipos
genéricos abiertos y cerrados. Por lo que con la versión
dos de C Sharp, un nuevo concepto ha incluido, se introducen, que
se llama genética. La idea básica era permitir que un tipo específico como
float, double o string se pasara
como parámetro a métodos, clases e incluso interfaces. Esa es una
limitación muy crucial para las cobranzas, que es una falta o incluso
ausencia de verificación de tipo. Sin embargo, esto permite
agregar los objetos de cualquier tipo de interconexión
porque
todos son descendientes de la clase base del
objeto. Esto contradice la definición
básica de C, C-sharp como un tipo seguro y comprende en la seguridad de tipo. En esta guía, vamos a echar
un vistazo más profundo en cuanto a lo que son los
genéricos y lo que son medios de propiedad
abierta y cercana. Los tipos en C Sharp tienen
dos categorías principales. Uno se llama valor y el otro se llama tipos de referencia. Ambos pueden
ser tipos genéricos que toman parámetros de
tipo uno-a-uno. Por lo que el enero cerrado. Por lo que una de las
características más potentes y C-sharp, que tienen los desarrolladores de
tipos definidos de estructuras de datos
como colecciones. Y esto es, esto
no solo se traduce en
una mejor calidad de código, sino detrás de escena,
él, agrega un impulso de
rendimiento decente también. Entonces echemos un vistazo a
cómo se ve esto. Tendremos un dispositivo de clase
pública. Y este dispositivo va a tener un nombre d0 público, Get and Set. Y la categoría pública T. Con el gatt y el conjunto. Tendremos el asimiento público. Esto va aquí. Entonces estos van a ser los genéricos de clase
pública. Y lo que nos
gustaría hacer es tener el público estático, vacío principal. Y dentro de la principal, tendríamos el dispositivo
con la cadena a como
un nuevo dispositivo Domain Controller. Y saltémonos el nombre. De acuerdo, sí, ¿
deberíamos hacer esto? Y tenemos el dispositivo float
b con el nuevo dispositivo de flotación. Y vamos a cerrarlo. Y podemos modificar la a, ese nombre para que sea el controlador de
dominio. Y la categoría
a ser esta cosa. Y esto va para la B también. El servidor Dns estará
en esa categoría. Y llamémoslo producción. Y lo que podemos hacer es
por ejemplo, aguantar. Esta debe ser 1 f y
2 f Así consola, derecha, línea, a, nombre y una categoría. Y lo mismo va para el B, O, K y usar el colon. Así que lee clave para mantener la consola. ¿ Por qué le echamos un vistazo? Ahí vamos. Hemos creado una clase genérica que representa un dispositivo. Y en función del
tipo del genérico, podemos inicializar los valores. Y lo que también podemos hacer es
crear un enero abierto. Por lo que nos gustaría que este
código lo demostrara. Entonces tendremos una clase pública, o g con la T. Y necesitamos estar usando el
sistema de reflexión del pensamiento. Y aquí tendremos
al público en M, g. y tendremos un
woo hoo igual a 0. Para poder usarlo, lo que tenemos que hacer es
crear una instancia. Por lo que tendremos un vacío estático
público. Agárrate. Esto es en la
genética de las plantas son públicas. Objeto estático. ¿ Se correrá? Y esto va
a tener el tipo de g enum type in para eso. Consigue el campo rojo más fresco. Woo hoo. Y nos gustaría
obtener el valor. Y ahora lo que podemos hacer es
seguir adelante y crear un nuevo
objeto de instancia que se ejecutará. Y tendremos la
consola de línea derecha. Cuéntanos lo siguiente. ¿ Esto es genérico? Y usamos el foo
que tipo
info tipo y es genérica definición
de tipo. Ahora bien, así es como se pueden
definir los genéricos abiertos. Y al usar la reflexión para obtener un
campo constante, el Woo-hoo. El CLR, convierte automáticamente el entero en una
instancia del tipo abierto. Entonces básicamente eso fue todo. Lo que quería
mostrarles en este video. Nos vemos en el axón.
14. Parámetros y descarte de salida avanzada de C#: Hola ahí y bienvenidos de nuevo. En este video, vamos
a echar un vistazo a dos características incluidas en la versión C sharp
seven. Y estas características
esencialmente cambiaron la forma funcionaban
los desarrolladores y se desarrollaban
las aplicaciones. El parámetro app es
útil cuando los métodos necesitan devolver
más de un valor. Y este parámetro se pasa por referencia y básicamente
transforma el parámetro formal, un alias para el argumento
que debe ser un muy capaz, muy similar a la palabra clave de
referencia. Pero la principal diferencia
es que esta última necesita ser inicializada de
antes de la mano. El descarta básicamente variable
temporal, por lo que las variables ficticias que se
utilizan en el código de la aplicación. propósito principal de este gato es proporcionar variables
reutilizables
que disminuyen la asignación de memoria y mejoran la legibilidad
y mantenibilidad. En primer lugar, vamos a echar
un vistazo al parámetro OUT. Entonces básicamente tiene tres reglas. El parámetro se puede pasar sin declaración
e inicialización. Se puede utilizar el tipo var en la lista de parámetros del
método. No tenemos que tener
el mismo nombre para nuestro parámetro en la
función y el núcleo. Entonces tomemos un demo para eso. Tenemos una cadena
estática pública, SLA. Con el doble a y doble B. Dentro de esta función, nos
gustaría tener un resultado que viene de las
matemáticas alrededor de a veces b. o mejor dicho, ¿cómo
debemos hacer eso? B dividido por a. y quisiéramos multiplicarlo por 100
y necesitamos dos dígitos. Entonces esto es lo que nos
gustaría tener. Y tendremos la
cadena SLA igual al total de horas disponibles. Horas. Y el SLA es el resultado. Ahora bien, lo que nos gustaría
hacer es devolver SLA. Y lo que nos gustaría
hacer después de esto es
básicamente modificar nuestra firma de
función. Y diríamos que nuestro resultado doble de salida y fuera SLA de cadena van
a ser otros parámetros. Y tenemos que quitar la
inicialización de eso. Podemos usar esta función
llamada a partir de ahora. Así consola línea derecha. Y nos gustaría usar
qué usaríamos SLA. Y básicamente, nos gustaría
tener entonces un total de horas
disponibles con ocho. Y nos gustaría tener el
resultado novedoso y fuera. cadena de SLA y el uso de
los teléfonos son clave. Para guardarlo. De acuerdo, empecemos. Y como pueden ver, este es el resultado. Lo que también podemos hacer
es usar esta tarjeta. Las variables de esta tarjeta tienen
el símbolo de subrayado. Entonces, por ejemplo, si creamos una variable que se
llama Coupa con 12345, entonces sigue adelante y
haz el guión bajo. ,
subrayado es igual a cupón. Entonces lo que podemos hacer es
usar la línea derecha de la consola, la escritura la
primera y la segunda. Entonces déjame mostrarte. Entonces esto es básicamente lo simple, este es un ejemplo sencillo para el descarte y cómo usarlo. Y nuestra tarea era
crear dos variables a partir de las cuales se
nombraban variables del cupón y descartar
el resto de los valores. Y si podemos decir
algo como esto, entonces el verdadero poder de esta tarjeta es cuando la
combinamos con la variable externa. Entonces, por ejemplo, si tenemos void
public, sorry, static, void B, S con la
cuerda d t Entonces si el tiempo que seca bares el SDR y fuera subrayado, entonces podríamos decir que los conos de esa derecha
fechade línea es válida. De lo contrario, la fecha de la línea
derecha de la consola está en Guanzhong. Izquierda. Muy bien. No
olvidemos este de aquí. Y si podemos seguir adelante y llamar a la P S con el O2, 292022. Deberíamos ver
lo siguiente en nuestra pantalla. Y aquí vamos. Entonces técnicamente, esto es todo lo que quería
mostrarles en este video. Nos vemos en la siguiente.
15. Directivas Preprocessor avanzadas de C#: Hola ahí y bienvenidos de nuevo. En este video,
vamos a
hablar de
las directivas de preprocesador en C-Sharp. Entonces, básicamente, este concepto pertenece al
reino de los lenguajes compilados. Son lenguajes compilados
o lenguaje que toma algún código de nivel superior
como C-Sharp o C. Y con la ayuda del compilador, lo traduce
a código máquina. El compilador es una capa de
abstracción entre diferentes arquitecturas
de fabricantes. Sabe traducir bloques de código a
diferentes arquitecturas. Entonces como, sí, procesadores Intel
o AMD. Y el
propio procesador no garantiza el código final
de la máquina. Como su nombre indica, solo
está preprocesando
las instrucciones. Contamos con un lenguaje de nivel superior. Entonces tenemos un preprocesador que un lenguaje puro de alto nivel, que un compilador y ensamblador, loader y el enlazador. Por lo tanto,
las directivas de preprocesador pueden ser la sentencia if como una
hoja y si y así sucesivamente. Y vamos a echar un
vistazo a un ejemplo sencillo. Por ejemplo, si queremos
usar esta directiva, podríamos decir que si
depuramos, entonces nos gustaría
decir que la consola del sistema, modo de depuración de línea
derecha. Nos gustaría decir consola
del sistema punto, escribir línea, y conocer el error. Y entonces tráelo aquí. Y podemos cerrar esto
con la declaración endif. Y aquí hemos definido una
directiva de preprocesador que dice que esto sólo debe ser
considerado en modo debug. De lo contrario,
imprimimos ningún debug. Y podemos ejecutar esta solución en modo
release o debug. Y por defecto el modo
debug es R1, y esta es la salida
que deberíamos ver. Entonces sigamos adelante y usemos las llamadas al
sistema o la tecla de lectura. Si ejecutamos la solución, se
puede ver que estamos
corriendo en modo debug. Y sí, esa fue la demo. Por lo que hemos definido un indefinido. Y estas directivas se
pueden usar para definir o directivas indefinidas
para el preprocesador. Y el caso de uso más común para esto es cuando
nos gustaría
definir condiciones extra para
la compilación en sí. Por lo que esto generalmente se hace en
tándem con la directiva def. Y básicamente podríamos
seguir adelante y definir el dev. Y si fraude, nos gustaría
decir que definimos depuración
e indefinido, corsé y fin si. Y deberíamos
ponerlo en el primero. Esto está funcionando. Entonces
lo que también podemos hacer es usar la advertencia o
el anuncio o y básicamente, podríamos decir que si no corroer, no probar y no Deb, entonces podemos lanzar
un mensaje de error indicando que no se puede combinar. Omitimos un
mensaje de advertencia
que indica que se ejecuta con código duro. Y podemos terminar con
esta declaración if. Y si ejecutamos esta solución, no vemos nada. Pero en el minuto que
quite este, vemos que hay
adultos en la compilación y podemos ver el
mensaje de error que no podemos compilar. Entonces este es un comportamiento
que podemos implementar. Lo que podemos hacer es
usar también la directiva align. Entonces línea que activa nos permite modificar la
numeración de diapositivas del compilador e incluso el nombre de archivo para los adultos y advertencias. Entonces digamos que nos
gustaría modificar el nombre del archivo reportado cuando se genera
una advertencia. Entonces pongamos aquí
y digamos esa línea, una, queriendo línea que C S. Ahora si
quitamos esto, deberíamos poder
ejecutar nuestra solución. Tenemos esta salida. ¿ Todo bien? Ahora lo que nos gustaría hacer es aprender sobre
región y n región. Por lo que estas directivas son útiles
cuando estamos trabajando con editor de código de
Visual Studio
o con el propio estudio. Y no hay
salida especial de esta dieta activa, pero permite marcar regiones
específicas las cuales
serán expandibles y colapsarán,
colapsar CBO por su
editor de elección. Entonces por ejemplo,
podríamos decir que una región usando y podríamos decir que
esta es la región final. Y ahora somos capaces
de derrumbarla. Y también tenemos el pragma, advertencia
del pragma
y la suma de comprobación del pragma. En palabras simples, directiva
pragma se puede utilizar para afectar cómo se maneja el
reporte de tiempo de compilación o advertencias y dar instrucciones especiales
a los compiladores. Por lo que hay dos variante básica. Uno es querer, el
otro es checksum. Cuando usamos el deseo, tenemos la opción de especificar deshabilitado
o restaurar, seguido de una lista de advertencias sobre las que hay que actuar o nada asume todo tipo de querer el
checksum congénita, genera una suma de comprobación del archivo fuente que
tendrá la depuración. Entonces por ejemplo, si tenemos el siguiente pragma definido
el siguiente pragmay lo ejecutamos, verán que no
se han encontrado problemas. Básicamente, eso era
todo lo que quería
mostrarles sobre
las directivas de preprocesador. Nos vemos en la siguiente.
16. Índices de sobrecarga avanzados de C#: Bienvenido. En este video,
vamos a hablar los indexadores de
sobrecarga en C-Sharp. Entonces, en C-Sharp, tenemos muchas
estructuras de datos diferentes disponibles. Y estos nos permiten almacenar y recuperar datos específicos
en nuestro momento de necesidad. En este video,
vamos a aprender sobre los indexadores y sobre
todo cómo puedes sobrecargarlos
haciendo de la manera correcta. Cuando hablamos de indexador sobrecargar la idea
detrás de esto, la fuerza, la clase a comportarse como una estructura de datos y hacer un
seguimiento de sus instancias que nos permiten recuperar
esas instancias a medida haría con una
matriz, matriz de lista. En primer lugar, despejamos el tema de en los indexadores y luego volteamos la
mira para agregar sobrecarga. Entonces vamos a crear un nuevo
proyecto en la carga. Entonces esa es una
sintaxis general, básicamente de plantilla para esto. Y vamos a echarle un vistazo en
un ejemplo práctico. Entonces por ejemplo, digamos que
tenemos una clase estudiantes. Y aquí tenemos una matriz de cadena
privada. Y vamos a llamar a esto indexadores, que es una nueva cadena
con valores Dan. Y tenemos un String público. Y apunta al índice. Y lo que nos gustaría
hacer es lo siguiente. Tendremos el gatt, que devolverá el índice de
indexadores y el conjunto, que va a fijar el
índice a un valor específico. Aquí en lo principal, lo que nos gustaría
hacer es crear una nueva instancia de los alumnos, y llamemos a esta escuela
primaria. Y aquí quisiéramos tener las escuelas primarias
primer elemento con mi nombre, y las
escuelas primarias segundo elemento con el nombre de mi hermano. Y el
segundo elemento de la escuela primaria consigue el nombre de
mi hermana. Y lo que nos gustaría
hacer es tomar un bucle
for e iterar de 0 a I
menos que e imprimir la línea derecha de la
consola. Y la primaria. I'th elemento. A continuación, utilice la
tecla de lectura de la consola para mantener el mensaje. Ahora, como pueden ver
en la consola, tenemos los tres nombres. Y claro que aquí
está parpadeando porque el resto de
la lista está vacía. Ahora bien, ¿qué pasa aquí? Tenemos un curso de clase, los estudiantes se comportan como una matriz
rara y permitiendo que hasta diez nombres
de estudiantes se almacenen en el dominio. Se crea una instancia de la clase y se insertan tres alumnos. Y si tuviéramos que establecer los siguientes elementos, entonces la escuela primaria, TAM, una madre, entonces deberíamos
obtener una excepción. Porque
no hay décimo elemento. El tamaño simplemente no
nos permite que sean
puntos importantes aquí. Por lo que hay dos
tipos básicos de índices. Una y dos dimensiones. La búsqueda de índices puede ser sobrecargada
y no son iguales a propiedades y
permite que un objeto sea indexado y establecer accessor. Nosotros asignaremos. Sin embargo, recuperaremos un valor. El valor se utiliza cuando
se establece el valor. Y a los indexadores se les conoce como matrices
inteligentes o propiedades
parametrizadas, lo que puede ser un
poco engañoso. Y los indexadores no pueden ser miembros
estáticos como lo son
como miembros de la clase. Entonces, ¿cómo sobrecargamos
a los indexadores? Vamos a crear una nueva clase. Llamemos a estas guías. Y tenemos una cadena privada, matriz y nombres de guía, que es una nueva cadena. Dan valores. Tendremos la cadena pública, este índice int
va a devolver el valor del índice de nombres de
guía. Y el conjunto va a establecer el valor del índice de nombres de guía al
valor especificado. Y podríamos tener al público durante esto
con el índice de flotación. Y deberíamos tener las mismas funciones
Get y Set. Y tendremos la
cadena pública, esta doble id Modifiquemos esta. Y lo tendríamos puesto en uno. Y aquí no
tendríamos una definición establecida. Ambos devuelven algo
que se llama, esto es de sólo lectura. Y ahora en nuestro principal, si comentamos esto, podemos instanciar a las guías. Y tendremos un doble valor, la k, y es **** 0. Y aquí se escribiría el primer
elemento de las guías. Y las guías flotan elemento
basado en índices
estaría en guías. Y lo que podemos hacer es
usar la línea derecha de la consola. Y nos gustaría
imprimir el elemento guías k. Y nos gustaría
imprimir el primer elemento. Y nos gustaría
imprimir el primer elemento
más el
primer elemento basado en flotación. ¿ De acuerdo? Entonces lo que podemos ver
aquí es que
accedimos básicamente a
diferentes versiones de este basado en el tipo de
indexador que hemos utilizado. Y aquí tenemos un índice
que es un entero. Y aquí tenemos uno
que es un valor de flotación. Y podemos referenciar estos y manipular
en base a ese valor de retorno. Y tenemos un último ejemplo que nos gustaría
echar un vistazo, y se llamaría multidimensional más té
que mencioné ahora. Y aquí tendremos
la cadena privada. Y tenemos esta coma. Y tenemos los nombres de guía, que es igual a nueva
cadena diez veces. Entonces tendríamos
la cadena pública, esta int x e int y. y tendríamos el get, que devuelve los nombres de la
guía x
e y. y tendremos el conjunto
que va a establecer el guíe los nombres x
e y al valor. Y si seguimos adelante
y lo instanciamos, así que úsalos a todos. Los diamantes son ahora iguales
a nuevos multidimensionales. Y luego usa el a primero. Habrá el Danio y uno para ser otro. Entonces podemos usar
bucles anidados para iterar sobre j es igual a 0, j
menor que el término j más más. Y usa la línea derecha de la consola. Y nos gustaría
usar la a y y o j Y y lo que nos gustaría
hacer es agregar el cheque. Entonces si a x e y
es igual a nulo, entonces usamos los teléfonos toda esa línea
brillante con la cadena f. X e y está vacía. Así que vamos a hacer esta x, y vamos a hacer esta y.
Y de lo contrario, lo siento, yo y j. Y j De lo contrario, nos
gustaría usar esta impresión. Muy bien. Entonces ahora en la salida, esto es lo que podemos ver. Por qué técnicamente es esto. Es así como puede sobrecargar
los indexadores en C-Sharp. Nos vemos en la siguiente.
17. Atributos predefinidos comunes con C#: Hola ahí y bienvenidos de nuevo. En este video
vamos a echar un vistazo propósito de
los
atributos predefinidos comunes en C-Sharp. Por lo que los atributos permiten a los
desarrolladores asociar metadatos o
información declarativa en su proyecto y su código. Una de las formas que
prefiero usar es mañana las clases o
funciones obsoletas medida que
continúa el desarrollo de la app? Y primero vamos a echar
un vistazo a qué
son los atributos y ver algunos
ejemplos de eso. Por lo que los atributos son lugares en tu código donde
podemos definirlos. Y son como asambleas, métodos, tipos, y
la lista continúa. Una vez que haya asociado el atributo con nuestra parte de código
seleccionada, tenemos la opción de
consultarlo con una técnica llamada reflexión. En el framework .net, cada
tipo y componentes como ensamblajes y clases tienen sus propios metadatos
definidos por defecto, cuales pueden ser extendidos por información de metadatos
personalizados como
nosotros, somos en la portería. Y cuando aplicamos información de
metadatos, tenemos la opción
de elegir el alcance. Podemos aplicarlo a montajes
enteros o solo a
partes específicas de nuestro código. Los atributos tienen la
habilidad especial de avanzar, para ser ampliados configurados
con parámetros. Y por último, lo más
especial los metadatos es que nuestra
aplicación puede inspeccionar sus propios metadatos e inspeccionar también otros
metadatos de progreso. Esto nos permite construir en comprobación de
compatibilidad
y otras características agradables. Entonces hay este
código esqueleto que podemos usar. Y esto nos va a estar diciendo que este es
un parámetro posicional, tiene valor y demás. Digamos que tenemos el
siguiente código el cual representa la máquina de suéter
y tiene dos funciones. Una es nuestra puesta en marcha de
la máquina y la otra es la instalación de actualizaciones. Entonces tenemos el servidor de clase
pública, y tiene el nombre de cadena
privada. Y tiene el nombre de la
cadena pública, nombre de la propiedad. Y el nombre del conjunto es igual al valor. Lo siento, nombre de subrayado. Y tenemos el nombre de la cadena pública,
nombre del constructor. Se trata de especificar un nombre. Y tenemos el servidor público de actualizaciones
void, que está pasando
directo a la consola. Ese servidor de actualización. Y tenemos el inicio. Y va a decir que
estamos reiniciando el servicio. Genial. Entonces ahora lo
que nos gustaría hacer es
cerrar nuestra clase. Sí. Y a medida que el
proyecto evolucione,
nos gustaría agregar la
siguiente función que va a desestimar el servidor de
actualizaciones y manejar tanto la actualización
como la instalación y el resto iniciar la tarea
con algún paso extra. Entonces, ¿cómo
dejamos, que los desarrolladores sepan que se introducirá
la nueva función
, que cubre estos. Todo lo es. Lo que podemos hacer es agregar la nueva línea o mejor dicho definición de
función. Y luego decir al
servidor de actualizaciones que esto es obsoleto. Y lo que nos gustaría hacer es decirle a la
duna que use este método, use el inicio en su lugar. Y podemos tener también
este falso cae aquí. Entonces ahora tenemos esto, de esta manera. ¿ De acuerdo? Entonces el
punto clave aquí es esta línea, y necesita ser precisa
con los nombres de las funciones. De lo contrario, el compilador
arrojará un error indicando que se puede encontrar
el método
al que nos referimos. Entonces lo que nos gustaría
hacer es copiar este y Seguro que esto también es correcto. Y tiene que ser preciso
para los nombres de las funciones. De lo contrario, el compilador
lanzará un anuncio o declarando que no se puede encontrar el método al que nos estamos
refiriendo. El segundo argumento es verdadero
o falso. Cuando lo configuramos en false, el compilador
lanzará una advertencia, pero la compilación la
pasaremos. Si se establece en true, se levanta
una excepción y
la compilación se detiene. Y ese es también un concepto que se llama
atributo targeting. Y apunta a la entidad la
que
se dirige el atributo. En este caso, la
función a es el objetivo. Ahora podemos hablar de atributos
predefinidos. Estos atributos
se referían a un conjunto de atributos que están integrados en la
biblioteca de documentos por Microsoft. Y tenemos que ser
conscientes de que esa es una clase base para atributos, que se llama sistema
ese atributo. Y cada atributo
predefinido del cliente hereda de esta clase base. Los
atributos predefinidos más comunes son serialización, serialización, obsoleto, DLL,
importante y método húmedo. Lo que podemos hacer es definir los atributos de
nuestros clientes. Por lo que cualquier persona que use el
framework .net y defina su
costo de absolutos, puede ser para uso privado
o privado, se empaquetan en
biblioteca pública o aplicación. Lo que nos gustaría hacer es seguir adelante y crear
la siguiente demostración. Entonces tenemos que importar el sistema
que reflexión. Y lo que queremos hacer
es definir una clase. Y el uso de atributos de esta clase serán los objetivos de
atributo de esa clase. Y la clase se va a
llamar atributo de la empresa, que heredará de
la clase base del atributo. Y tendremos el nombre de la cadena privada, ubicación de cadena
privada. Y el
nombre de cadena pública con la brecha. Eso devuelve el nombre. Y el conjunto, que
va a establecer el nombre igual a valor. Y tendremos la ubicación de cadena
pública. Y tendríamos un constructor. Así que el atributo de la empresa pública y la compañía de cadena y
la ubicación de la cadena. Y nos gustaría
tener el nombre igual a empresa y la ubicación igual a ubicación. ¿ De acuerdo? Entonces ahora que tenemos
esto fuera del camino, podemos tener nueva clase base de
atributos donde la empresa
va a ser imaginaria. Y tendrá algo
ubicado en Atlanta. Esto, esto se va a
llamar servidor de clase. Y tendrá un nombre de cadena
privada. Y la cuerda privada. Este nombre de cadena pública. Con el GET. Vamos. Eso devuelve el nombre y el conjunto que devuelve
nombre es igual a valor. De acuerdo, entonces tenemos
esta clase pública. Llamemos a este servidor
de la empresa, lo siento. Y tendremos
reutilizadas estas funciones. Por lo que tenemos estas
funciones obsoletas y tenemos el resto arrancar y agregarla
en funciones de doma. Y aquí en lo principal, podemos crear un servidor a partir del nuevo controlador de dominio
del servidor de la empresa. ¿ Y por qué llora? No tiene constructor, por
supuesto, porque hay que definirlo. Así público, servidor de la empresa, cadena, nombre, y el nombre
es igual al nombre. De acuerdo, ahora tenemos
el constructor y tendremos
la info del miembro. Info es igual a tipo o a
un tipo de tuerca de fama, sino más bien al servidor de la empresa. Y la matriz de objetos
con el atributo va a ser la info,
obtener atributos personalizados. Muere tanto el atributo de
la empresa como un falso. ¿De acuerdo? Y después de eso, podemos usar el bucle foreach para iterar sobre cada atributo de objeto
en atributos. Entonces simplemente use
el atributo de la empresa C es igual al
atributo de empresa, atributo. Tú. Y conos en la línea derecha. Signo de dólar, cotización, a, nombre y una ubicación o no. B. C, Que ubicaciones, lo siento. Y podemos usar los de
la tecla tres para
mantener el prompt. De acuerdo, ahora como puedes ver, pudimos obtener el atributo de una instancia
específica. Y así es como puedes usar atributos predefinidos
comunes en C-Sharp. Nos vemos la próxima vez.
18. C# Advanced Read only autoproperties: Bienvenido. En este video vamos
a hablar de tres, las únicas
propiedades automotrices en C-Sharp. Así que lee solo
propiedades de auto. ¿Cuáles son? Nos divergimos y seis tienen
C-sharp lanzado en 2015. Entonces como siete años no fueron al
lado de la visa
Studio Ultimate. Esa fue una
característica muy singular implementada. Esto se llama propiedad
auto de solo lectura y a
veces se refiere como
getter only auto property. Entonces en este video,
vamos a tomar,
tomar el concepto de
campos y propiedades
y ver cómo ambos
pueden ser de solo lectura y cómo se
implementan enfocándonos en
el aspecto auto propiedad. Entonces miedos versus propiedades. Estos dos conceptos
giran en torno a la idea de abstracción.
Conla clase. Puedes tener campos
y propiedades. Los campos son
miembros variables normales o de clase. ¿ Por qué escribí auto? Una clase de auto? Y las propiedades son una
abstracción que
permite obtener o incluso
establecer sus valores. Entonces por ejemplo, podríamos crear la clase de campo público y lo
habríamos sentido, clase, está bien. Nombre de cadena
privada y función de cadena privada. Y lo que podemos hacer es definir estos llamados campos en un constructor de
construcción. Por lo que el servidor público sanó, tendríamos el
nombre de la cadena, la función de cadena. Aquí. Lo que nos gustaría
hacer es decir que este nombre es igual a nombre. Y esta función es
igual a función. Cuando definimos campos, debemos asegurarnos de definirlos como privados. Ya que esto asegura que no estamos violando el concepto
de encapsulación. Encapsular en definitiva significa que estamos construyendo los campos, pero estamos agrupando los
campos o datos con métodos y funciones que son capaces de manipularlos. Y no exponemos estos
datos para manipulación directa. Y este código actual
no es realmente suficiente
porque
no somos capaces de recuperar estos. Entonces lo que tenemos que hacer es
seguir adelante y definir la siguiente
cadena pública nombre, nombre. Y usaríamos para llegar a
devolver el nombre y el conjunto, el conjunto, el nombre al valor. Tendríamos la función de cadena
pública, y obtendríamos
la función y pondríamos la función a valor. Y ahora tenemos, ahora
tenemos la opción de leer
y modificar las propiedades. Entonces veamos nuestro frío. Por lo que el campo de servidor a es igual a
nuevo campo sándwich. Y el nombre es DC. La función en el
hilo de plata más bien es una. Y la función es controlador
de dominio. ¿ De acuerdo? Ahora lo que podemos hacer es
usar la línea derecha de la consola, la impresión, un nombre
y una función. Y no te olvides de la
consola que tres teclas. Entonces cuando ejecutamos este ejemplo, esto es lo que es la salida. Así que hemos
establecido y accedido con éxito a estos, y hemos
inicializado nuestra clase con un constructor
más tarde los campos se
cambiaron con la ayuda
de los accesores de propiedades. Y hemos obedecido también al principio
de encapsulación. Ahora que aclaramos el concepto, podemos condimentarlo con
el aspecto de solo lectura. Cuando queremos crear
un campo de solo lectura, solo
tenemos que usar
la palabra clave Read Only. Entonces si modificamos
esto para que sea de sólo lectura, entonces podemos ver que el nombre subrayado
va a ser rojo. Y en este caso
de un número de miedo, esto significa que sólo tenemos una
oportunidad inicializar el campo con valor. Ocurre cuando llamamos
al constructor constructor y estar en eso obtendríamos un
anuncio o de tal intento. Por lo que esto se puede quitar de forma segura. Si tuviéramos que ejecutar
esto una vez más, se
puede ver que
está funcionando bien. Pero si intento decir que
el nombre es igual a nuevo nombre, lo que debería ver
es que esta es una propiedad de solo lectura
y no se puede modificar. ¿ De acuerdo? Entonces en caso de número de
campo, ¿de acuerdo? Y hemos visto la salida. Entonces así es como puedes usar propiedades Alto de
solo lectura en C-Sharp. Nos vemos en.
19. Sintaxis avanzada de C# para literales: Bienvenido. En este video
vamos a hablar de cómo se puede reconocer la
sintaxis para la alfabetización, incluyendo Unicode deck skip secuencias y
guiones bajos en C-Sharp. Entonces saltemos directo a ello. Posteriormente nos en C-Sharp y nada
más que valores fijos. Estos valores son utilizados por
variables o constantes. Hay muchos tipos de
literales, como entero, coma flotante, carácter,
cadena, booleano. Y si echamos un
vistazo a literales enteros, esto sería un ejemplo. Y es un tipo de literatura
que concierne a enteros. Y hay básicamente
tres subtipos, decimal, octal y hexadecimal. Este es el decimal. Lo que podríamos
hacer es crear el octo, que es el, oh, vamos. Y ocho. Y ahora 028. Y podemos tener el hex, que es 0 x uno, C por ejemplo. Y básicamente lo que podríamos hacer es seguir adelante y usar los
conos o línea de izquierda a derecha. Y decir que el nombre
de variable de a tiene valor. Y haz esto por
los tres. Entonces esto es para la O y la H. Y no te olvides del
colon, así que lee clave. Entonces si lo ejecutamos, esto es lo
que tenemos en pantalla. Entonces note cómo el nombre de nos permite
referirnos al nombre de una variable en nuestra interpolación de
cadenas. La otra cosa que
tal vez no notemos es cómo se muestran
los valores en caso
de hexa y número octal. Y básicamente les gustan
los prefijos del prefijo. No vemos el
prefijo hexadecimal ni el prefijo. Lo que podemos hacer es crear
un literales de punto flotante. Así que vamos a crear el
flotador f k es igual a 283848. Y podríamos tener el flotante, flotante octo F B, que sería el
28 o 27 menos cinco. Y podríamos El, lo siento, d y novela. Sí, ahora parece que es mejor. Entonces podríamos tener la 28ª F. Y ahora lo que podemos
hacer es imprimir los valores. Entonces la a, la B, y la C. Y si la ejecutamos, observe cómo esto también tiene la notación diferente cuando se imprime a la pantalla. Esta es la
notación científica para las carrozas. Y también podemos tener literales de
carácter. Entonces car c es igual a a, o podemos definir la versión
Unicode. Entonces debes tres O, seis. Y vamos a imprimir esto. Ca, ca Ver eso. Nos vemos. Ahí vamos. Entonces este es el carácter Unicode para el signo de
interrogación, por ejemplo. Y también podemos tener literales de
cuerda. Y también podemos tener
los literales booleanos. Vamos a imprimirlos. Entonces esta es la S. Y esta va a ser la abeja. Va a ser la abeja. Ahí vamos. Y lo que podemos tener son también secuencias de escape
Unicode. Entonces, por ejemplo, estas son las secuencias de escape
que podemos usar. El Unicode me
los puso en barras inversas. Así podemos tener el carácter de
arco, el retroceso, la
alimentación de forma, retorno de carro, nueva línea, grifos horizontales,
verticales ,
comillas simples, comillas dobles, y la barra inversa también. Y también hay que
hablar de subrayado. Así que en mi experiencia, este tema es uno de los que más divide entre los desarrolladores. Una razón de esto
es que hay quienes aprenden C-sharp
como primer idioma, tratando de seguir
las mejores prácticas y guías de estilo de codificación. Y también hay
quienes vienen de
diferentes orígenes, como C, C plus plus Python
o cualquier lenguaje. Y tienden a nombrar
variables de manera diferente. Y así, por supuesto, cada
empresa puede tener su propia codificación
como
o directriz de estilo. Y lo que puedes hacer es echar un
vistazo al policía estilo. Y también el Corazón Británico. Estas son herramientas que te
permiten crear como un estilo o una versión basada en guía de estilo
verificada de tu aplicación. Entonces eso fue todo lo que
quería mostrarles en este video. Nos vemos en la siguiente.
20. C# Advanced Returning solo lectura referencias de funciones: Bienvenido. En este video
vamos a hablar de tres girando
referencias de solo lectura desde funciones. Por lo que este tema que todos
ustedes tienen gira en torno al código seguro tipo y
memoria. Entonces divergimos y uno de los
desarrolladores liberados de C-sharp podría pasar argumentos a
los métodos por referencia. A medida que pasaba el tiempo y la
programación cambiaba, la palabra, surgieron
nuevos retos que obligaron
a agregar las nuevas características a C-sharp. Con la versión
siete de C-sharp, se agregaron
dos
características muy importantes. Una fue la posibilidad
de declarar referencias a variables
locales y
la otra fue
regresar por referencia a partir de métodos. Construiremos las bases para entender los dos
tipos de argumentos. Argumento pasando. Entonces, ¿cuál es la diferencia
entre el valor y las finanzas? Estos son dos
tipos principales en C-Sharp, y también tenemos la posibilidad de
definir tipos personalizados, pero no está en el
alcance de este video. Por lo que vía tipos de referencia muestran diferentes
características de rendimiento si nos fijamos bajo el capó, debido a
que la naturaleza misma de esa implementación
donde las pestañas no tienen ninguna sobrecarga memorizar los datos que puedes almacenar en un tipo específico como entero string double tienen
un tipo específico, tamaño
específico y los tipos de referencia tienen que
agregar campos adicionales. Uno es el encabezado del objeto y el otro es
la tabla de métodos. El encabezado de objeto es utilizado por el tiempo de
ejecución del lenguaje común para almacenar información
adicional y
básicamente es una gran máscara. Entonces echemos un vistazo a struct. Por lo que pública sólo lectura
struct, una dinámica. Y esta estructura
tendría la cadena pública, cadena Bob Lake por
su nombre, con el GET. Y doble público. De hecho, relación con el GET
y el int público, casos
iniciales y doble tasa de mortalidad
pública. Ahora podemos tener una instancia o un constructor
para la pandemia. Y tendría
el nombre de la cadena, doble relación y int
y doble tasa. Y ahora aquí en la pandemia, tendríamos el
nombre del virus igual al nombre, la relación igual
a de hecho razón. Y el caso es, perdón. De hecho la proporción debe
ser igual a la relación. Y el caso inicial, esto debería ser
igual a k es, es, y la tasa de mortalidad
debe ser igual a tasa. Y podemos ver que los
accesores son leídos, solo se definen con get
y falta el conjunto. Y no leemos
solo palabra clave es que le diga a la CRL que nuestra struct va
a ser inmutable. Eso significa que con el tiempo no se pueden cambiar
los campos. Ahora nos gustaría
combinar este hombre, El aspecto antes mencionado, que es la struct y
pasando valores por referencia para crear una demostración
para este tema. Entonces lo que nos gustaría hacer es crear esto. De acuerdo, entonces la
alineación es buena. Clase pública, sencilla,
ref, de sólo lectura. Y tendremos la matriz int estática
con el nuevo int tres. Y va a ser 123. Y el índice int
get static, int index. Y le devolvemos a la RAF un índice. Y tendríamos el vacío
público estático para nuestro qué. Este debe ser cerrado. Y aquí nos
gustaría usar los conos toda esa
línea brillante para obtener índice. Agárrate. Aquí es donde
deberíamos ponerlo. Obtenga el índice primero y use
los conos o la tecla de lectura. Y podemos ver el
valor que es uno. Entonces, en este código,
vemos una matriz estática de enteros con
un tamaño de tres. Y nuestro método GET
index está tomando un índice como
argumento y devuelve un int en un jar de nuestra
matriz, que es radón. Si pasamos el índice
que es mayor que la longitud de la matriz
o menor que 0, entonces obtenemos una excepción
del índice fuera de
rango excepción. Entonces, si queremos crear
un ejemplo más complejo, podríamos hacerlo de la
siguiente manera. Entonces digamos que tenemos struct, que está representando
aulas. Entonces esto tiene el constructor, que está tomando un
nombre y el tamaño. Y también tiene un arreglo privado
de utilización actual. Y tiene un nombre y las propiedades de
tamaño, y así sucesivamente. Entonces ahora lo que podemos hacer es seguir
adelante y crear lo siguiente. Entonces tenemos un bar muy
que se llama habitaciones, y es un aula nueva. Y aquí nos gustaría
tener las nuevas aulas. Matemáticas con diez personas. Y las nuevas aulas llevan a ser más ricas con 20. Y no
olvidemos cerrarla. Podemos tener la escuela var
y tiene aulas nuevas. Y la escuela. Ese almacén se va a llevar las habitaciones las
cuales inicializarán. Y entonces podemos usar los
teléfonos toda esa línea correcta para imprimir la escuela que
consiguen utilización. 10. Si lo ejecuta, se puede ver la diferente utilización del
aula. Y esto es básicamente
como puedes crear tus propias referencias de
solo lectura para ser devueltas desde
funciones en C Sharp. Y técnicamente, eso era
todo lo que quería mostrarte. Nos vemos en la siguiente.
21. Método avanzado C# sin nombre: Bienvenido. En este video
vamos a
hablar de métodos sin nombre. Así que este es un conjunto de características en C-sharp que es muy
importante entender. Este conjunto de características
gira en torno a lambda, expresiones
lambda, delegados
y métodos anónimos. Vamos a ver
cómo puedes usarlos. En primer lugar, vamos a
hablar de delegados. Por lo que normalmente funciona o pausa uno o más parámetros
o nada en absoluto. Por lo general devuelven
algo o realizan unas operaciones específicas con
datos o los textos que tienen. Estamos hablando de delegados
cuando quisiéramos
pasar funciéndose
como parámetro. Veamos lo que
C-sharp tiene para ofrecer. En primer lugar, nos
gustaría crear un delegado. Entonces, por ejemplo, tendríamos el servidor Linux de
cadena estática pública, que tiene el
nombre de la cadena, el estado de la cadena. Tendríamos el cheque si el estado es igual a
arriba, entonces regresamos. El servidor es. De lo contrario lo
que quisiéramos hacer. Si el estado está abajo. Entonces podemos devolver
el servidor está caído. Y por último, regresar estado desconocido. Muy bien. Por lo que funciona problema con debe tenerlo
en comillas dobles. Genial. Bien. Ahora lo que tenemos que
hacer es crear una reacción de estado de cadena delegada con el servidor de cadena
y el estado de cadena. Y tenemos que definir la cadena estática
pública Windows Server con el
nombre de la cadena y el estado de la cadena. Y lo que nos gustaría hacer para devolver el servidor está en estado. Estado con el
signo del dólar, claro. Y deberíamos
moverlo aquí dentro del programa. Y aquí nos gustaría
crear una reacción estatal. Linux es igual a nueva reacción de estado. Y usaríamos
el servidor Linux. Y la reacción de estado Windows, nueva reacción de estado
Windows Server. Y nos gustaría hacer
la siguiente consola, línea
derecha, Linux, bind and up. Y tendríamos
otro Linux que es LDAP y tenemos lo siguiente. Entonces ahora nos gustaría tener esta reacción estatal o simplemente
verla en acción en vivo. Entonces, ¿cuál es el problema? Como pueden ver, no hay problema. El servidor está activo, por lo que básicamente está
funcionando como se pretendía. Y sí, podríamos ampliar aún más su
funcionalidad de este material con la comprobación remota o la apertura de
tickets si estás en una gran
infraestructura empresarial, pero vamos técnicamente. Entonces ahora vamos a
hablar de métodos anónimos. Por lo que en el apartado anterior, se discutió cómo los delegados son
tipos de referencia y se utilizan para
hacer referencia a cualquier método que
tenga la misma firma. En contraste con ellas, las funciones anónimas
se tratan de analizar bloque de código o código
como parámetro delegado. Vamos a crear el
siguiente ejemplo. Delegado público. Estado vacío, el estado de cadena. Y en el vacío estático principal, lo que nos gustaría hacer es
crear el
ámbito exterior, que es 99. Y el estado S
va a ser delegado. Y será un delegado estatal de
cadena. Y básicamente lo que nos
gustaría hacer es usar una línea derecha de consola. Y se ingresó al estado. Hagamos que sea una cuerda f
y cerremos la consola. Línea derecha. Signo de dólar. El valor del ámbito
externo está fuera del alcance. Y vamos
a mandar D aquí arriba. Y si lo
ejecutamos, deberíamos cerrar
este también. Deberíamos ver lo siguiente. El estado hacia arriba y tercero, y el valor del ámbito
externo es 99. Entonces así es como se pueden
definir métodos anónimos. El último debe
ser parámetros lambda que comprobamos qué expresiones
lambda. Se trata de una
función anónima que puede contener expresiones
y declaraciones. Entonces vamos a crear lo siguiente. Tendremos la cadena de
función, cadena. Y va a
ser un nombre bienvenido. Y definimos el
retorno Nombre de bienvenida. Peso por supuesto,
el signo del dólar. Y no olvides cerrarla. Así que ahora podemos usar la línea derecha de la
consola para imprimir el pulgar de riqueza. Danielle. Si lo ejecutamos, se
puede ver que estamos
utilizando la expresión lambda. Podríamos crear otro ejemplo. Entonces int, int n 34 es igual a x y devuelve la x por tres. Y después podemos
imprimir la entrada 0.5. Deberían ser 15. Entonces eso era todo lo que quería
mostrarles en este video sobre expresiones
Lambda, delegados, y métodos
anónimos. Nos vemos en la siguiente.
22. LINQ avanzado de C#: Bienvenido. En este video
vamos a echar un
vistazo a la sintaxis de
consulta integrada en lenguaje, que es la
versión larga de cue enlazado. Y se introdujo en otro framework dotnet con la versión 3.5 allá por 2007. Y el concepto central
era ampliar el marco y junto con él, el lenguaje C-sharp con capacidades de expresión de
consulta. Por ejemplo, si tuviéramos
que crear un ejemplo, podemos crear una cadena
ArrayList. Y que contiene lista de
servidores con la
nueva cadena de lista. Y nos gustaría tener el controlador de
dominio de telar de campana de botella. Y protésico,
que es el DNS. Y a clave, que
es la, la ACP. Y básicamente esa es
la estructura que podrías definir
en la función principal. Es así como pudimos
demostrarlo. Entonces d c es igual a lista, lista servidores, donde S, S contiene Controlador de dominio. Y vamos a moverlo
aquí dentro de la principal. Entonces ahora podemos usar la línea derecha de
la
consola, la impresión, los DC. Y como pueden ver, esta es la lista de EECS. Y tiene básicamente
una ejecución diferida. Entonces, para
profundizar en la cola vinculada y qué otros beneficios
hay para comer, necesitamos entender qué es la ejecución
diferida. En la mayoría de los casos
durante
la compilación, las expresiones de enlace
se evalúan en un conjunto de datos específico y las variables se inicializan
con los valores filtrados. Al implementar la ejecución
diferida, podemos ahorrar valiosos recursos de CPU
y RAM. Porque el concepto nos
permite no
evaluar una
expresión específica ni retrasar la evaluación hasta que se requiera
realmente
el valor realizado. Hay dos
casos en los que es muy útil. El primero es cuando tu
aplicación está trabajando en múltiples gigabytes de datos
o incluso terabytes de datos. Y el segundo es cuando se han encadenado
múltiples consultas que resultan en diferentes
manipulaciones de los datasets. Entonces tenemos una palabra clave de la que
debemos hablar. Y esto es rendimiento. Para profundizar en
nuestra comprensión de las diferentes ejecuciones, necesitamos introducir una
palabra clave llamada yield. Y esto se introdujo con
la versión 2 de C-sharp. Es con la Vita para evaluación
perezosa y mejorar el rendimiento de las consultas LINQ. Y la palabra clave yield
es context you are, lo
que significa que se puede usar
como nombre de variable
sin ningún problema. Entonces vamos a crear una
pequeña aplicación. Aquí. Nos gustaría tener
un servidor de clase pública. Y tiene un nombre de cadena
y una función de cadena. Y tenemos el nombre de
cadena pública con el Get. Eso se supone que
devuelva el nombre. Y el conjunto, que
se supone que establece el nombre es igual a valor. Y tenemos lo mismo
para la función hasta
ahora, funcion de cuerda sombría. Y usamos la función,
olvídate de respuesta. Muy bien. También tendremos
constructor, por lo que servidor público. Y este constructor
va a tomar el nombre y la función. Y establecer la función
es igual a la función. Nombre es igual a nombre. ¿ De acuerdo? Y básicamente
eso de la clase servidor. Y vamos a tener
otra clase pública, que es el programa interino. Y aquí nos gustaría
crear estática pública I innumerable para el
servidor, el servidor DB. Y aquí tenemos que
definir lo siguiente. Vamos a tener una
matriz de servidores con los servidores. Eso es sólo una nueva
instancia del servidor. Y esta instancia
va a ser poblada por el nuevo servidor o mal préstamo
y controlador de dominio. Y vamos a tener lo que sea y donde sea. Y uno va a ser el HCP y DNS. Muy bien. Esto ahora está cerrado. Y lo que nos
gustaría hacer es tener el para-cada servidor S en servidores y rendimiento retorno S. Así que ahora ya nos han ido los
guiones bajos. Y lo que podemos hacer
en dominio es usar el forEach en Server DB. Y simplemente use la línea derecha de la
consola, signo de
dólar, y use el nombre del punto S y
la función de punto S. Ahora bien, si lo ejecutamos, se
puede ver que tenemos la ejecución diferida
demostrada y somos capaces de iterar
sobre el INR I innumerable. Y la clave aquí es el rendimiento. Entonces aquí el retorno S, que nos permite iterar sobre cada elemento de nuestra lista de servidores. Y no devuelve toda
la lista a vez para guardar saber MOD
y mejorar el rendimiento. Este es también un ejemplo
para la ejecución diferida. Como el para cada bucle fue sacando los
términos uno por uno. Y deberíamos considerar diferencia entre Lizzie
y la ejecución ansiosa. Así o evaluación tampoco. El uso de evaluación perezosa significa que sólo un
solo elemento de la colección fuente es proceso durante la llamada al iterador. Entonces algo como esto. Y un iterador puede
ser una clase acostumbrada o un bucle foreach o acate
dependiendo del contexto. Y eso fue todo lo que quería mostrarles en este ejemplo.
Nosvemos en la siguiente.
23. Interpolación de cadena avanzada con C#: Bienvenido. En este video vamos a hablar de la interpolación de
cadenas. interpolación de cadenas
tiene algo que ver con la impresión
en la consola. Y es básicamente
una tarea común. Podemos imprimir un simple mensaje de
estado, el resultado de una acción
específica. En realidad no importa. Lo que importa es cuán flexibles son
nuestras declaraciones de impresión. Y también importa cómo
encaja en el flujo de programas. Por ejemplo, deberíamos
considerar lo siguiente. Por lo tanto, la interpolación de cadenas puede
usar tres tipos de variables, sustitución, acceso a matrices, expresiones y llamadas a métodos. El aspecto más importante de la interpolación de cadenas es
el carácter del signo del dólar. Entonces por ejemplo, cadena donde, donde debe tener
score y string qué? Tomate. Y podrías usar la
línea de escritura de punto de la consola para imprimir. Compré en y uso la consola dot write line, no right line, console, lee T. Y si lo ejecutamos, se puede ver que estos valores variables
fueron muy bien interpolador. Y básicamente lo que podemos hacer es interpelar
matrices también. Así que vamos a crear una matriz
entera que contiene los números pares 2468. Y ahora podemos usar la consola dot write line que la política. Entonces el primero, segundo, tercero, cuarto son números pares. Y ahí vamos. Este
debería ser el primero, y esto debería ser números pares. De acuerdo, así que ahora la salida
parece estar bien. Lo que podemos hacer es interpelar
también expresiones o intercalar
con expresiones. Entonces tenemos dos valores, x,
x es igual a ocho e y es igual a diez. Podríamos usar lo
siguiente para imprimir una
salida muy bien formateada. Entonces X más Y es igual a X más Y. Y podríamos
dividir los tiempos y tal vez el menos. Y si es agudo este ejemplo, deberíamos ver lo
siguiente en la salida. Por lo que tienes la
opción de evaluar expresiones cuando
estás interpolando. También se podría crear una
función que tendrá la estática int cuarta potencia int x. y debe devolver x
veces x veces x veces x. y aquí en la consola. Y podríamos escribir x a la cuarta es la cuarta potencia x De
esta manera, interpola
la llamada de función a sí misma, y también podemos interpelar
con alineaciones. Así que vamos a crear
trabajadores variable, que es un nuevo diccionario
de cadena y cadena. Aquí, podríamos decir que tenemos el John aunque,
igual a DevOps. Aunque, John equivale
a subir de nivel para sumar. Aquí, lo que podemos hacer es
usar la línea derecha de la consola. El impreso que tenemos. Este debe ser el menos 15. Y deberíamos ayudar a la posición con los 20. Y usa el para cada bucle. En los trabajadores. Aquí, imprime la clave del título. Y el valor del título
debería ser una K mayúscula, K. Y si ejecutamos esto, se
puede ver que aquí
tenemos el ritmo. En esto. Agárrate. Debería ser así. Se ve mejor. Entonces eso era todo lo que quería mostrarte
sobre la interpolación de cadenas. Nos vemos en la siguiente.
24. C# Asignación de valor avanzado y tipo de referencia: Bienvenido. En este video, vamos a hablar un tema interesante en C-Sharp, y se le llama valor y la asignación de tipo de
referencia, tan bien y gráfica. Entonces vamos a crear el proyecto. Por lo que en función del sistema
de tipos de un lenguaje de programación, existen dos categorías principales. Existen lenguajes de
programación fuertemente y débilmente tipados. Y estas categorías definían
cómo se aplicaban las reglas de tipificación durante la compilación y el
tiempo de ejecución del código fuente. En 1974, Barbara
Liskov y Stefan ceros definieron un
lenguaje de programación fuertemente tipado de la siguiente manera. Siempre que el objeto
se pasa de la función de llamada
a la función es su tipo debe ser compatible con el tipo
declarado en la función de código. Entonces vamos a
dar un poco de contexto y echar un vistazo a cómo y cuál es la
diferencia entre ellos. Así que en el
framework dotnet y tocar el lenguaje de
programación c-sharp, hay dos tipos principales. Uno se llama valor y el
otro es un tipo de referencia. Ese es otro término
llamado contextos. Y hay dos
contextos en C-sharp. uno se le llama seguro y al
otro se le llama inseguro. Explicaremos esto más adelante, pero cabe mencionar
que en contextos inseguros, tenemos un tercer tipo
llamado puntero. Por ahora, basta, conocemos el contexto seguro
cuando el contexto es seguro, cuando el código se está ejecutando bajo la supervisión del CLR. Hay cuatro tipos que caen dentro de la categoría de
tipo de referencia. Cadenas, matriz,
clases y delegados. Y el resto de los tipos para caen dentro de la categoría de tipo. Así bool en coche, decimal, y así sucesivamente. Echemos un vistazo al tipo de valor. Entonces digamos que tenemos una función, pública estática, vacío al cuadrado ella. Y recibe un
doble como argumento. Y lo que vamos
a hacer es usar la línea derecha de la consola
y básicamente x veces x Ahora podemos declarar una variable a, que es Stan, y
usar la consola. O más bien simplemente llamar
al cuadrado doble it a. y vamos a darle una tecla de lectura de punto de
consola. Ahora si lo ejecutamos, deberíamos ver la salida como 100. Entonces, ¿qué pasa
detrás de escena? El valor de este contenido se
asigna en la pila y un solo espacio en memoria
basado se reserva
un solo espacio en memoria
basadoen el tipo
en la mama, esta variable
sostiene directamente el valor. Entonces si tuviéramos que
copiar este valor a otra variable y asignación, se copia
el valor. Por lo que tendrá el valor
de estos resultados dos veces, dos veces en la pila
para cada variable. Todos los tipos de datos predefinidos
en brazos e incluso estructuras. O de esta manera. Los tipos de valores se
crean en tiempo de compilación. Debido a esto, están protegidos del recolector de
basura. No puede acceder a ellos. Ahora echemos un
vistazo al tipo de referencia. Entonces digamos que tenemos un servidor de clase
pública. Y este servidor va
a tener un nombre de cadena, público y CPU y
público en RAM, o simplemente hacerlo doble. Entonces ahora lo que podríamos hacer es
crear el público
y el vacío inicializar. Y vamos a tener una categoría y el
servidor S como argumentos. Entonces en caso de que la
categoría sea pequeña, entonces lo que nos gustaría
hacer es crear o más bien asignar el tipo pequeño. Y lo que quisiéramos, perdón. Tipo de cadena pública. Entonces como el tipo debe ser pequeño, ya que la CPU debe ser uno y S, la RAM debe ser dos. Como si la categoría fuera media. Entonces asignaremos un poco más de
recursos y lo llamaremos medio. Veamos dos núcleos, cuatro gigs de RAM. Si la categoría es grande, entonces nos gustaría asignar las cuatro CPU grandes y
ocho gigs de RAM. De lo contrario, nos
gustaría lanzar una nueva excepción. Nuevo sistema, esa excepción de
argumento y categoría debe ser
pequeña, mediana o grande. ¿ De acuerdo? Entonces ahora lo que podemos
hacer es crear un servidor. Servidor va a
ser un servidor nuevo. Podemos llamar a la inicializar. Agárrate. Debería ser así. Cuadrarlo. ¿ Por qué no funciona? Tenemos esto. Tenemos
el servidor inicializado. Y debería estar cerca de aquí. Entonces inicializa servidor y un
logo y ya está definido. Entonces hagámoslo
ser y al cuadrado a. entonces no hay argumento
dado el servidor inicial. Entonces hagámoslo pequeño. Y Lee. Entonces tenemos la cadena
y el servidor S. ¿Por qué no es tipo de referencia de clase
pública. Y tenemos el servidor aquí, y el servidor de cadena y programas. Entonces tenemos el pequeño
mediano y tenemos el servidor S, vacío estático
público. Genial. Entonces ahora lo que deberíamos poder
hacer es usar la
consola de conos línea derecha con el signo del dólar y sólo
mostrar los atributos. Así que sea cpu, tipo
y B que Graham. Y vamos a dividirlos. ¿ De acuerdo? Entonces básicamente eso es todo. Tenemos una clase que es
del tipo de referencia. Y esto es importante tener en cuenta porque la función
llamada inicializar servidor, que está inicializando,
toma dos argumentos. El primero es
un tipo de valor y el segundo es
un tipo de referencia. El tipo que es donde pasa
la clase, la función cambiará las propiedades públicas
de la clase pasan por referencia en función de la
categoría. Pasamos. Si pasamos una categoría
que no se implementa que un
nuevo anuncio o su trono. Entonces eso fue todo lo que
quería mostrarles en este video sobre
valor y tipo. Nos vemos en la siguiente.
25. Operador de propagación nulo avanzado de C#: Hola ahí y bienvenidos de nuevo. En este video
vamos a hablar del
operador de propagación en C-Sharp. Por lo que
allá por 2016, están pasando muchas
cosas. El pasado 12 de noviembre, hubo un evento
llamado Visual Studio connect head por Microsoft
en el cilindro se libera versión de vista previa de Visual Studio 2015 y
la C sharp versión seis. Esta nueva versión ha
incorporado muchos cambios que los desarrolladores y la tecnología
de ese tiempo requerían. Sólo por mencionar algunas
de estas características, que era la propiedad
auto de solo lectura
es la expresión de
inicializador de propiedad automática,
PERO miembros de la función IT utilizando estática y los operadores
condicionales más nuevos. Por lo que en esta guía, vamos a echar un vistazo a los operadores
condicionales, o como más comúnmente
se conoce como operador de propagación. También hay gente
por ahí que se refieren a esta característica como operador de
navegación segura. Para entenderlo, necesitamos introducir
dos nuevos operadores. El objetivo principal de
estos operadores es
hacer que la ejecución de código sea más fluida y reemplazar la excepción de referencia
nula con adición o manejo significativo. Así que vamos a ver un ejemplo para
el operador de acceso miembro. Antes de la c-sharp. C-sharp, el siguiente código
habría resultado en ninguna excepción de referencia. Entonces tenemos a este pasante o burdo. Tenemos el vacío estático principal. Entonces básicamente este es el código. Y sí, tenemos un
servidor y ya está. Entonces ahora lo que nos gustaría
hacer es superar este tema y
lo podemos hacer de la siguiente manera. Así que vamos a tener servidor de clase
pública con
el nombre de la cadena pública, que tiene un getter y setter. Ahora lo que nos gustaría
hacer es inicializarlo. Y tendremos una matriz de servidores, que se va a
llamar servidores. Y tendremos una
matriz de servidores con cinco servidores. Ahora, lo que nos gustaría
hacer es tener un servidor, S1 lo hará el nuevo servidor. Y el S1, ese nombre. Esto va a ser primero. Vamos a
tener un servidor, S2. Y S2, el nombre
va a ser segundo. Ahora lo que nos gustaría
hacer es asignar a los servidores y a los servidores. Segundo. Y luego adelante. Para cada servidor S, N servidores. Y simplemente usa la consola
dot write line S, ese nombre. Muy bien. Cuál es la clave real aquí es
que ahora si la
ejecutamos, deberíamos ver el
siguiente resultado. Entonces básicamente necesitamos una matriz de cinco o en este
caso dos elementos. Y la encuesta se
llenará de servidores, tendrá su nombre propiedad
también inicializado. Después iteramos sobre el
servidor y verificamos con el
operador de acceso miembro si el nombre del
servicio o inicializado. De acuerdo, Ahora tal vez te
preguntes dónde está
la demostración del elemento
x, este operador. Y podemos convertir fácilmente
el bucle de la siguiente manera. Entonces si comentamos esto, podríamos usar la
línea derecha de la consola y simplemente decir que los servidores cuestionan o simplemente no lo hagamos de esta
manera. Pero a lo largo. De esta manera. Para int I es igual a 0, yo menos de dos I más, más. Y aquí nos gustaría tener a
los servidores signo de interrogación, signo interrogación, nombre,
doble signo de interrogación, y decir que no se especificó ningún
nombre. Ahora dejémoslo correr por cinco. Oh, ¿cuál es el error? Oh, necesito cerrarla. Muy bien. Entonces esto no se establece en un objeto. De acuerdo, vamos a convertirlo. Entonces esta es básicamente
la demostración para el operador de
propagación neuronal. Esta es la sintaxis para eso, y así es como puedes usarla. Y eso fue todo lo que
quería mostrarles en este video. Nos vemos en la siguiente.
26. C# avanzado de Clojures y expresiones de lambda: Hola ahí y bienvenidos de nuevo. En este video,
vamos a
hablar de cierres con expresiones
lambda. C-sharp, la capacidad
que permite a un método o una función hacer referencia a
la variable no local, qué valores se llama cierre. Esta característica se utiliza
comúnmente en conjunto con la función
lambda, que no son más que funciones
anónimas
que los desarrolladores utilizan sobre funciones principales para proporcionar una forma de flexibilidad. Hablemos primero de
variables no locales. Entonces, en C-Sharp, es posible
acceder a una variable fuera del alcance de una
función. Y considere las variables normales x ya que de esta manera se denominan variables
no locales. Si usted, también puede escuchar desarrolladores referirse a
este tipo de Fourier, pero como capturado muy capaz. Y básicamente, lo que podríamos hacer para demostrar
aquí es lo siguiente. Tenemos una cadena estática, mejor, una cuasi lineal, y
tenemos un vacío estático. Foo es el mejor. Y podríamos decir que queremos que la consola se imprima esa línea
correcta. Lo mejor es lo mejor. ¿ De acuerdo? Y deberíamos mover
este agujero aquí. Lo que podríamos hacer es
usar la tecla de
lectura de puntos de la consola y llamar a la
que es la mejor función. Esto es básicamente lo que se ven las variables
capturadas. Y cuáles son las funciones
lambda. Ya teníamos un
video sobre lambdas, pero tratemos de reiterarlo. Por lo que hay un montón
de artículos sobre lambda y ellos siendo cierres. Y algunas personas tienden a estar de acuerdo de
alguna manera que las hay, pero solo son
parte de la verdad. Y creo que India, al
igual que el partido de oposición, las funciones de
Lambda pueden
implementarse como cierres, pero no son
cierres en sí mismos. Esto realmente
depende del contexto en que uses tu aplicación
o el entorno. Cuando se está creando comiendo una función lambda que no
utiliza variables locales, debe implementarse
como cierre. Por lo que las expresiones lambda pueden
tomar dos formas básicas, expresiones lambda y
declaraciones lambda. Entonces para una
expresión de excepción lambda, podríamos dar este ejemplo. Por lo que toma dos valores booleanos y comprueba si
son iguales. Y podemos tener
lambdas de declaración también. Y se ven
algo así. Entonces ahora tenemos una cadena y luego le daría la bienvenida a esa
cadena con el mensaje. Por lo que debemos notar cómo cerrar el corsé rizado también
termina en punto y coma. Cuando trabajamos con lambdas de
sentencia, solemos crear
múltiples expresiones, encapsularlas
dentro de nuestra función. Lo que nos gustaría
hacer es dar un giro empinado y combinar
lambdas y cierres. Por lo que tenemos cierre de
clase parcial estática
pública, demo. Aquí. Lo que nos gustaría
hacer es crear el vacío estático público. Afuera. Esta va
a ser nuestra función. Y dentro de la función, tendremos una variable
local Norte. Y dice que el
cierre basado lambda. Ahora tendremos el
funk, ensancharlos a todos. Y nos gustaría
usarlo como Lambda. Y tendremos
la cadena local. Se trata de Lambda y el local de
retorno Plus. Muy bien. Después de eso, tendremos un
mensaje de cadena, que es demo. Y nos gustaría usar la línea derecha de la consola
para imprimir el mensaje. Y en dominio, lo
que podríamos hacer es usar el
demo de cierre que fuera. Y eso es todo. Entonces vamos a ejecutarlo. Y aquí podemos ver cómo se demostró
esto. Por lo que vemos en este ejemplo que son
variables no locales no cambiaron. No obstante, la situación
podría no ser siempre cierta. Si la variable cambia, la función de referencia
se verá impactada. A veces este es exactamente
el caso que queremos lograr. Por ejemplo, podríamos tener
una función que registra el cambio de
terminal en un estado de función con una función Lambda. De esa manera, cada cambio
de estado resultaría
en un logotipo diferente. Entonces ahora podemos
demostrarlo con cierres, y aquí es cómo lo haríamos. Entonces tendremos una
variable foo, que es stem, y la función
que se llama bar. Y simplemente regresa para la línea derecha de la consola. Y usaríamos la barra completa. Y podemos cambiar el
valor de foo a 20. Y después de eso,
tendremos un luchador que
es igual a barra. Y podríamos usar la línea derecha de la
consola para
imprimir luchador con el luchador. Y así es como podríamos
implementar cierres. Y técnicamente eso es todo lo quería mostrarles
en este video. Es así como puedes usar cierres
con expresiones lambda. Nos vemos en la siguiente.
27. Foreach y enumeradores avanzados de C#: Hola ahí y bienvenidos. En este video
vamos a hablar de
entender a los generadores
y enumeradores. Y yo enumerador en C-Sharp. Entonces uno de los conceptos
se llama generadores, el otro son iteradores. Vamos a inspeccionar cómo se
incorporan
estas ideas en C-Sharp y comprobar cómo
puede utilizarlas desde para nuestra propia ventaja. Un generador suele ser una
función o una rutina especial implementada en el
lenguaje que controla el comportamiento de un bucle. El generador cervezas
un parecido misterioso. Dos funciones que
devuelven un array. Tienen parámetros y pueden ser llamados para generar una
secuencia de tiempos phi. Sin generadores,
digamos que tenemos una función que devuelve una lista de enteros
alrededor de 1 millón a la vez. Esto significa que las necesidades, la lista necesita ser
construida en la memoria, asignar espacio para
todos los valores, y luego pasar esos valores
siempre que necesiten ir. Si tenemos los
recursos, está bien. Pero la gente siempre se
esfuerza por averiguar algo para
este tipo de problemas. Y nacieron los generadores. Y los iteradores son como la contraparte para
los generadores. Y el concepto
se remonta a 1974. Al lenguaje de programación C. Por diseño, un
iterador debe permitir que el programador
atraviese contenedores específicos, y es más comúnmente
utilizado para listas. Así que vamos a ver un ejemplo
en la implementación, tenemos una lista de
cadenas a iterar, que es una nueva cadena de lista. Y para ser iterado
tiene una función add. Y podemos decir que la programación es divertida. Ahora, podemos convertir esta lista
en un generador de manera muy sencilla. Podríamos simplemente
decir que es una
I y una cadena numérica. Y básicamente necesitamos
cambiarlo de esta manera también. Por lo que enumero arco, cuerda y agárrate. Tenemos éste. Y este debe ser
el que se va a iterar. Y necesitamos cambiar
el otro también. Entonces me inclino para ser iterativo. Y lo que podemos hacer ahora es
tomar el bucle for-each y decir elemento de
cadena en I innumerable y usar el elemento de línea derecha de la
consola. Y si seguimos adelante y leemos
clave para esperar la salida, esto es lo que
vamos a ver. De esta manera, hemos cambiado
la lista a un generador, por lo que tiene una huella de
memoria menor. Y aquí, básicamente no
hay declaración break. Y sin embargo no va infinito, por lo que sabe parar cuando nos gusta como agotar la lista que nos
gustaría iterar. Y podemos ver al té tomar un ejemplo
práctico o más práctico también. Por lo que nos gustaría crear una
pequeña aplicación que pueda procesar los números si son
impares o incluso de manera diferente. El enumerador de ojos
nos proporciona una solución elegante, que es, implica
dos métodos estáticos. Entonces el primer
método estático sería este. Y vamos a necesitar
usar el enhebrado del sistema. Y lo que nos gustaría hacer es tener el proceso de
auditoría así también. Por lo que incluso procesar qué proceso. Entonces ahí vamos. Entonces, ¿qué pasa aquí? Tomamos un
numerador ojo como argumento. Y si la corriente es 0, decimos que la lista se
procesó saliendo que
esperar cinco segundos. Si es módulo dos, entonces decimos que el número
es incluso llamando procesador. Y ahí vamos. Entonces esto es para los números pares
y los impares. Y ahora dentro de nuestro main, lo que podemos hacer es
crear una list int, que se llama MyList. Y esta es una nueva
lista de enteros con valores
Dan para yo
va de 0 a I, menos de diez I más más. Y nos gustaría usar el punto de mi lista agregar
para agregar nuevos elementos. Y después de eso,
tendremos el ojo enumerador. Y esto va
a tomar un entero. Mi lista en m es igual a
milista, obtén un numerador. Mi lista en num, muévete a continuación. Procesar o mylist el
num, y eso es todo. Entonces vamos a darle una oportunidad. Y como se puede ver, la salida muestra que la
lista se procesó saliendo. Entonces así es como se puede utilizar para cada
enumerador de ojos en C-Sharp. Nos vemos en la siguiente.
28. C# miembros de instancias estáticas avanzadas: Bienvenido. En este video, vamos a
hablar de cómo se puede distinguir a los miembros estáticos
y de instancia. Así que la
programación orientada a objetos gira torno a dos términos principales en. Uno es objeto y el
otro son instancias. Existen diferentes ideas
teóricas que implementa el
lenguaje de programación específico. En esta guía,
vamos a echar un vistazo a una estática y miembros de instancia. Nosotros decidiremos los términos
y de qué se tratan, cómo puedes utilizarlos
en algunas reglas muy simples. Por lo que distinguimos también tres
tipos de números diferentes. Podemos tener
campos o propiedades estáticas, métodos
estáticos y clases
estáticas. Entonces empecemos con las clases. Lo que es, lo que pasa con las clases
estáticas y no estáticas son las clases son
estáticas o no estáticas. Y tenemos clase no estática. Puede contener métodos, propiedades e incluso eventos. Y puedes llamar a esto incluso sin instanciar la clase. Entonces, por ejemplo,
creemos un proyecto para eso. Ahí está este non. Entonces, por ejemplo, vamos
a crear una clase que
llamaríamos no estática. Y aquí vamos a tener una
cadena estática pública, sin instancia. Y en la línea de
escritura de punto de la consola, imprimimos. No necesito saberlo. Dan Shi a mostrado. Agárrate. Debemos ser devueltos. Muy bien. Y lo que también podemos hacer es al
interior de nuestra clase interna, definimos nuestra cadena pública. Otra instancia. Y aquí
no devolvemos instancia aquí. O bien. Si vas a la principal, después de tener la llave correcta. Lo que podemos hacer es usar
la línea derecha de la consola, la impresión, el resultado
de la función de la función no estática sin
instancia. Y también la línea derecha de la consola. Y otro no así. Entonces, básicamente, si
ejecutamos este ejemplo, verás que
llamamos a la función de la clase sin instanciación. Sin usar el modificador
público, podemos llamar a las
estrellas conocedoras de la clase demo
estática y no estática, y no
heredamos nada de
eso en nuestra clase principal. Y también debes conocer la palabra clave pública cuando
invocamos otra instancia
del método desde dentro de nuestra clase principal y nivel de
accesibilidad
es correcto esta vez. Básicamente. En otra redacción, cuando hablamos
de los miembros de instancia, hablamos de aquellos miembros
de clase a los que no se puede llamar accedido sin
instanciar la clase. Aquellos a los que se puede acceder
se denominan miembros. Entonces, por ejemplo, si le doy este
número de cadena pública no estática es igual a lo que sea, entonces podemos acceder a este. Entonces, ¿qué pasa con los métodos estáticos? Entonces, por ejemplo, si
tenemos este ejemplo, esto se va a llamar un miembros
estáticos, un método estático. Y cuando se define
un método estático, permitimos el acceso desde ese
método sólo a los miembros estáticos de la clase y no podemos
acceder a los miembros de instancia. Y si tuviera que acceder a esta variable miembro
desde el método estático, seguiría funcionando bien. Por lo que ahora tenemos que hablar de propiedades
estáticas o campos. Entonces, cuando tenemos un campo estático, debemos tener en
cuenta que este campo identifica solo una
ubicación de almacenamiento en la memoria. Y no importa cuántas
instancias creamos que será sólo una
copia de un campo estático. veces,
como resultado de lo La mayoría de lasveces,
como resultado de lo
natural de su naturaleza, las propiedades
estáticas se
utilizan para almacenar datos que destinados a ser compartidos por
todas las instancias de la clase. Y si quieres un
ejemplo para eso, podemos crear una clase
llamada contador. Aquí tendríamos la estática pública int down Cs es igual a 0
y contador público. Lo que nos gustaría hacer es
utilizar las instancias más iguales a uno para aumentar
el contador de instancias. Y cuando seguimos adelante y creamos una nueva instancia desde el mostrador, lo que podemos hacer es usar
la línea derecha de la consola. Imprime el número
de instancias. Aquí, lo que haremos es
usar el número de clase de contador, o más bien instancias para
imprimir el número de instancias. Actualmente si ejecutamos esta
solución, veremos una. Pero si creas unas
cuantas instancias más. Entonces digamos que este es el conteo 123. Y si vamos a imprimir
el nuevo conteo de instancias, veremos que tenemos un
total de cuatro instancias. Y básicamente eso es todo. Entonces esto es lo que
quería mostrarles en este video. Nos vemos en la siguiente.
29. Inferencia de tipo avanzado C#: Hola ahí y bienvenidos de nuevo. En este video, vamos a hablar de mecanografiar
financiamiento c-sharp. C-sharp es un lenguaje fuertemente
tipado. ¿ Es por una declaración
se llama explícita. Y esto significa que tenemos
que especificar una nueva variable. De lo contrario el compilador
lanzará un anuncio o con la versión
tres de C-sharp, se introdujo
una nueva palabra clave, y se llama voir. Y esto permite a
los desarrolladores almacenar cualquier tipo de valor de una
manera implícita, lo que significa que el
compilador decidirá por nosotros durante el tiempo de compilación cuando ejecutamos la primera
asignación sucede qué convertirse como un
tipo de esa variable. Y se puede
integrar fácilmente con link Q, que es el lenguaje de consulta
integrado. Antes de la introducción
de la inferencia de tipo, se definió
explícitamente lo que
va a ser una cadena o
entero o lo que sea antes del tiempo de compilación
compuesto. Por lo que definimos una cadena con
el valor por defecto y así sucesivamente. Y ahora tenemos que
hablar de enlace q Así q significa consulta
integrada de lenguaje. Se trata de un conjunto de tecnologías
basadas en la integración de capacidades de consulta
directamente en el lenguaje C Sharp. Es muy similar al de query. Y el objetivo era
filtrar los datos en base a criterios
específicos y soporta mayor parte del tipo de datos Slack, secuela, Zemo, y así sucesivamente. Y vamos a crear un ejemplo que se supone
que demuestra justamente eso. Entonces vamos a crear un servidor de clase
pública. Dentro de la clase pública, tendremos un nombre String
público, cual tiene un getter y setter. Y tendremos un sistema operativo
String público con el getter y setter. Y después de eso, lo que
nos gustaría
hacer para crear un nuevo solar. Y esto básicamente
no es sólo un servidor nuevo, sino la lista de servidores. Y nos gustaría tener
esto como una nueva lista de servidores. Aquí. Lo que nos gustaría
hacer es lo siguiente. Por lo que queremos instanciar
estos servidores. Vamos. Y tenemos un nuevo servidor, que va a tener
un nombre, que es como, ¿qué pasa con telar y
un sistema operativo, que va a ser cuando? 2019. Y haremos un poco más. Tan grandullón. Este va a ser un modelo CentOS
ocho y Ricky, que va a
ser, eso sería nueve. Y ahora lo que podemos
hacer es crear una consulta de servidor, que va a ser desde
el servidor en servidores. Y nos gustaría
tener el SO del servidor filtrado al IBM nueve y cerrar esto. Entonces tenemos esta lista y tenemos que agregar el nuevo servidor selecto, el nombre del servidor OS, y simplemente cerrarlo. Y después de eso, podemos usar
el servidor foreach var,
server query y simplemente usar el servidor de la línea derecha de la consola. Y vamos a darle
los conos son como de tres claves y ejecutarlo. Ahora, como pueden ver, aquí, tenemos el resultado del filtro. ¿ Y qué vemos aquí? Estamos usando dos espacios de nombres
adicionales. Uno se llama genérico y
el otro es cola enlazada. Y el primero nos proporciona la implementación de
la estructura de datos de lista, donde almacenamos nuestros servidores. Y los segundos anuncios, las capacidades de enlace a
nuestra aplicación después la inicialización de la
lista con los servidores. Y aquí es donde sucede
la magia. Así que primero definimos nuestra variable que contiene
la consulta es artes, y luego se realiza la consulta. Que busca servidores
más baratos que o no los más baratos, sino más bien el
sistema operativo siendo WAN 19. La palabra clave walk nos
permite decidir el tipo de cuerpo
durante el tiempo de ejecución. Y técnicamente eso es todo lo que quería
mostrarles en este video. Nos vemos en la siguiente.
30. C# funciones locales avanzadas: Hola ahí y bienvenidos de nuevo. En este video,
vamos a
hablar de funciones locales
en C-Sharp. Por lo que las funciones locales, esta característica se ha convertido en parte de C-sharp
con la versión 7. Y la idea detrás esta característica es la
definición de una función. Hicimos otra función. Y es similar a cómo funcionan los decoradores de
Python. Si está familiarizado con el concepto y si
desea redefinirlo, podríamos decir que la función
local es
una función privada de una
función y su alcance. Y se limita a la función dentro de la cual se definió. Diseccionaremos
más a fondo este tema en este video. Por lo que el tipo de función
de búsqueda se asemeja al tipo
de la función de contenedor. Sin embargo, no hay una
estricta aplicación
de reglas desde el lado del compilador. Y cuando tenemos
una función local, también
podemos usar modificadores asíncronos e
inseguros. Por lo que inseguro se refiere a punteros
C-sharp en asíncrono se refiere
a asíncrono. Y lugares comunes donde se definen las funciones
locales. Nuestros métodos constructores, fuente de acceso a la
propiedad, accesores de
eventos, expresiones
lambda, analizadores
phi o destructores y funciones locales. Y una característica muy útil de la función local
es que permiten las excepciones salgan a
la superficie inmediatamente cuando estamos usando iteradores, por
ejemplo, las excepciones sólo se salen a la superficie cuando las enumeramos. Entonces vamos a crear una
pequeña demostración. Aquí. Nos gustaría tener
un mensaje vacío, cadena, digamos. Y usamos la consola. ¿ Verdad? Línea. Decir. Usemos los conos o la clave de
lectura para adquirir entrada. Ahora bien, lo que quisiéramos
hacer es decir el mensaje, bienvenidos. Y si lo ejecutamos, deberíamos ver el
siguiente resultado. Ahora bien, esta es básicamente la forma más simple
de funciones locales. En nuestro caso, tenemos la
función llamada message, que toma una cadena
como argumento y envía a la
consola el mensaje. Y vamos a crear otra demostración
con ámbitos variables. Entonces, por ejemplo,
tenemos aquí int k es igual a 11 y el doble j
igual a noventa y nueve puntos nueve. Y tendríamos
el alcance vacío. Y usamos la
línea derecha de la consola para imprimir el nombre. El valor del nombre de. Esta debe ser una cuerda f. Y pasaríamos dos
argumentos también. Entonces en X en Y es X e Y. Y nos gustaría usar
la K y la J también. Vamos. K y J. J y K. Y no necesitamos ese nombre. En realidad, necesitábamos eso. Entonces ahora lo que nos gustaría
hacer es usar el alcance. Hagamos de esto una cadena en
lugar de 1299 y simplemente ejecutemos. Así como se puede ver aquí, las variables locales llamadas k y j son accesibles
para la función ya que se definen dentro de
la función contenedor. Y lo que nos gustaría
hacer es crear una función
genérica. Función genérica tan nula. Y tendremos el
valor con el valor X. Y vamos a este. Y tendríamos los conos
de la derecha es igual a éste como el anterior. Y llamaremos a esta función. Nueve, 11 que si lo ejecutas, el valor de x es 11. Funciones genéricas combinadas
tipo, seguridad y eficiencia. Y a menudo
se usan con colecciones y métodos que
operan sobre ellos. Y también podemos hacer referencia
al parámetro externo en función
local que se
declaran en el mismo ámbito. Entonces por ejemplo,
podríamos crear el vacío mi cadena x out string S. Y S es igual al signo de dólar. Este es el. Y ahora tendríamos el mensaje de
cadena igual a nulo. Y tendríamos el mensaje My
out 12 and out, la llamada a la función,
y simplemente usaríamos la consola ese mensaje de línea
derecha. Por lo que ahora lo ejecutamos. Se puede ver que el
valor de x es 12. La atmósfera es variable, captura el mensaje y
trabaja en tándem con la cuerda como argumento
de la función. Y podríamos usar también la palabra clave params void, mis antebrazos, armas de fuego en matriz. Y conos. Consiguió la línea brillante. Y aquí podríamos decir que sacó el número de la tubería. Y tendríamos elemento. Y para cada elemento en array. De esa manera, nuestro
bucle for se ve bien. Y tendríamos la prueba, que es un nuevo array entero
que tiene el 123456789. Y ahora podemos usar los
fondos de ayer. Y ahí vamos. Entonces básicamente así
es como podrías usar funciones locales en C-Sharp. Nos vemos en la siguiente.
31. C# Accesorios de eventos personalizados: Hola ahí y bienvenidos de nuevo. En este video vamos
a echar un vistazo a cómo se
pueden escribir accesores de eventos personalizados en C-Sharp. Por lo que con el fin de entender el eje de eventos del
cliente, lo que necesitamos
aclarar por qué son necesarios y los casos de uso. Aquí vamos a introducir el concepto de eventos
y echar un vistazo a los eventos y los accesores que pueden ser utilizados para
interactuar entre clases. Y qué son los eventos. Entonces tomemos un ejemplo animado. Contamos con una interfaz gráfica de
usuario que consta de botones, texto, cajas, etiquetas, etc. Cada componente se
compone de su propia clase. Cada clase proporciona
funcionalidad. Por ejemplo, puede
escribir en el cuadro de texto, hacer clic en un botón, y así sucesivamente. Y categorizamos las clases ya sea por editores
o suscriptores. El editor es una clase que envía o plantea los eventos. Y el suscriptor es el
que recibió el, recibe el evento
en base a sus acciones específicas. Por lo que hay algunas
reglas para los eventos. El editor determina
cuándo se plantea un evento, el suscriptor determina
qué acción se toma cuando se dispara
un evento específico
al que está suscrito. Evento con nuestros suscriptores nunca
se plantea. Y los eventos en su mayoría
se despiden debido a las interacciones del usuario ya sea en la aplicación web o la interfaz
gráfica de usuario. Por defecto y evento tiene múltiples suscriptores y
consigue manejar manejadores invocados sincrónicamente
a menos que se
definan de manera asíncrona
asíncrona. Los eventos se
basan en el controlador de eventos, delegado y la clase base de
registros de eventos. Para crear un evento, necesitamos crear un
delegado que mantenga los detalles de los
suscriptores de un evento y crear un
evento público que sea externamente visible para una clase y utilizado
para crear suscripciones. Después creamos el método en una clase que
disparará el evento en sí. Entonces, por ejemplo,
hagamos lo siguiente. Llamemos a esta
Clase pública una máquina. Y esta
máquina de clase pública se supone que tiene algo llamado utilización int
privada, que va a ser 0, int
privada utilización segura, que va a ser nivel de
utilización bajo el cual la máquina es segura
para ser operada. Y tendremos un delegado
público. Límite de estrés vacío x
c hizo controlador de eventos, que tendrá la
fuente del objeto y el evento args E. Y tendremos un
evento público límite de estrés excedido manejador. Tendremos un público
que vamos a anular ante el estrés. Nivel. C hizo evento args E. Y básicamente lo que
nos gustaría hacer es tener límite de estrés
superado signo de interrogación que. Invocar. Este E. Vamos a bajarlo aquí
para que sea más visible. Y tendremos un int público, cuatro meses, que
tendrá el getter. Y devolverá utilización. Y tendremos
el vacío estático. Maquina. El estrés
limitará x c hizo objeto, evento
fuente args e. y nos gustaría
tener la máquina, que es igual a la fuente de
la máquina. Unos. Muy bien, línea. Advertencia de nivel de estrés. Te gustaría
tener el Mac son ambos malos desde hace meses y
la persona firma. Ahora lo que podemos hacer es crear la
prueba de estrés del vacío público, int utilisation. Y ahora quisiéramos, tengo la vieja utilización igual para subrayar la utilización. Y subrayar
la utilización debe incrementarse con
la nueva utilización. Y si la utilización anterior es menor que igual
para ahorrar la utilización
y la utilización es
mayor que la utilización segura. Entonces podemos llamar al nivel de estrés superó a los perros nuevos. De acuerdo, así que básicamente
esta va a ser la prueba de esfuerzo
para nuestra clase. Y en nuestra función principal. Lo que podemos hacer es
crear una nueva máquina. Y podemos extraño nuevo
controlador de eventos límite de tensión a la máquina. Límite de estrés. Vamos. Z lo hizo. Y nos gustaría
usar los poemas esa línea derecha para decir
que la utilización es, esta va a ser
una máquina de f cuerdas que mal forman iones
con un signo de porcentaje. Y podemos usar la máquina. Esa prueba de esfuerzo. Digamos que esto
va a ser 60. Escribiremos
la utilización, luego crearemos otra
prueba de esfuerzo para la quinta. Y hagamos el 75 y utilicemos los foros o aceptemos
esperar el prompt. Ahora bien, si ejecutamos este ejemplo, se
puede ver que la utilización no
va a cambiar. Es decir, va a cambiar, pero una vez que hemos superado
la utilización, entonces obtenemos la advertencia para
que se plantee evento personalizado. Así que este fue básicamente un ejemplo que te muestra
cómo puedes escribir tus
accesores de eventos personalizados en C-Sharp. Nos vemos en la siguiente.
32. Conversiones definidas por el usuario con C#: Hola ahí y bienvenidos de nuevo. En este video vamos
a hablar de cómo
se pueden escribir conversiones personalizadas definidas por el usuario en C-Sharp. Se han ido esas
conversiones en C-Sharp o todos los días de peatones
a la mayoría de los desarrolladores. Y lo usamos para verificar
entradas sólidas desafiaron el flujo de trabajo de nuestra aplicación. Son convertidos integrados, que están integrados en conversiones y admiten instalaciones en C Sharp que
le permiten mantener flexibilidad y
consistencia en toda su aplicación de forma predeterminada, hay dos
tipos principales de conversiones. Uno se llama x más c, El otro está implícito. C-sharp también proporciona
una forma para que usted defina sus propias conversiones. Echemos un vistazo a las conversiones
explícitas. Entonces por ejemplo,
tenemos un flotador Pi, que es tres para F. Y
tenemos un doble B pi, que va a ser por. Y podemos usar la línea derecha de la
consola, la impresión por d pi. Echemos un vistazo a la salida. Por lo que como se puede ver, en el primer caso, tenemos los tres
puntos 14 como valor. Y el tercero. El segundo caso es un
poco más largo. Entonces, básicamente, lo que vemos es cómo la flotación
se convierte en doble. Esa es la diferencia
entre la precisión. Por eso vemos valores
diferentes. Y lo que también podemos
hacer es básicamente
seguir adelante y llamemos a
esto E pi, d Pi. Y aquí sólo decimos que
queremos tener un doble valor. Y este va a
ser el tres que 14. Y nos gustaría crear
una versión flotante de la misma. Y F DEP. Lo que nos gustaría
hacer es usar el flotador en la d, d, p, y.
y ahora podemos escribir
estos valores. Ejecutemos nuestro ejemplo. Ahora, como puedes ver, hemos utilizado la conversión
explícita para crear los nuevos valores. Ahora, lo que podemos hacer es
echar un vistazo a cómo
puedes definir tus propias conversiones
personalizadas. Entonces por ejemplo, tenemos la clase pública
llamada conversiones. Y tenemos el tipo personalizado
de clase pública. Y éste va a tener un número int público con
su getter y setter. El bool público, magia,
getter y setter. Y tendremos un operador int
estático, valor int tipo
personalizado. Dentro de esta función,
nos gustaría devolver un nuevo tipo personalizado con
el número igual a valor. Y la magia, era falsa. Y ese un operador booleano público, perdón,
n.Después de eso, podemos definir nuestro operador estático público X
con balas, int, tipo personalizado, magia. Y nos gustaría volver
del número mágico. De acuerdo, ahora
tenemos nuestra propia clase y podemos crear un entero
que se llama un número. Y va a
tener el valor tres. Después de eso, podemos crear una magia de tipo personalizado
igual a un número. Y podemos usar la línea derecha de la consola
para imprimir de int un número a magia con valor magic number. Y si cerramos esta
línea y la ejecutamos, se puede ver que hemos
convertido el entero tres a una
conversión definida por el usuario, que tiene el valor de tres. Así es técnicamente
como puedes crear tus propias
conversiones personalizadas definidas por el usuario en C-Sharp. Nos vemos la próxima vez.
33. C# avanzó el final: Bienvenido. Este es mi
video final de esta serie. Aquí en la serie, ha aprendido muchas
técnicas útiles en C-Sharp, cómo puede mejorar
su aplicación, cómo puede implementar características
avanzadas que le permitirán construir
aplicaciones. Hemos visto a través de
muchos ejemplos cómo puede utilizar
todo el arsenal que C-sharp tiene para
proporcionarle con el fin de hacer que sus programas o aplicaciones sean
más exitosos. Y todos estos ejemplos
se van a subir en un repositorio de GitHub que
podrás clonar y
reproducir los ejemplos que
vesa reproducir los ejemplos que
ves lo largo de los videos. Nos vemos en la siguiente. Y espero que esto haya sido
informativo para ustedes. Y me gustaría
agradecerles por ver. Adiós.