Creando nuevos objetos

Página 1

Creando objeto Curso

Para la creación de un Id único nos apoyaremos de la clase Guid y el método NewGuid() para la creación de un código que no se repita, pero esto nos retorna un objeto, por lo que para emplearlo como string utilizaremos el método ToString()

public Curso() => UniqueId = Guid.NewGuid().ToString();

Para una creación más rápida de las clases que vayamos a crear en nuestro aplicativo instalaremos la extensión "C# Extensions".

A principio nos aparece un error Guid porque no se tiene importado el namespace que contiene a la clase, para esto nos posicionamos sobre el nombre de la clase y presionamos

Ctrl + .

no preguntara si queremos usar el namespace system y resionamos enter

En el Main instanciamos 3 cursos, asignandoles el nombre del curso despues de llamar al constructor vacio, por ejemplo para el primer curso

var curso1 = new Curso(){

Nombre = "101",

Jornada = TiposJornada.Mañana

};

Primero llamos constructor y antes de cerrar la instrucción abrimos corchetes ahí mismo setteamos el valor de la propiedad Nombre.

En Visual Code en la clase Curso para la creación del constructor escribimos

ctor

y presionamos enter y nos da la estructura del constructor

Para escribir en consola los datos del curso, hacemos lo siguiente, escribrimos

cw

y presionamos enter, esto nos autocompletará el System.Console.WriteLine

Podriamos concatenar manualmente los valores del curso

System.Console.WriteLine(curso1.Nombre + " , " + curso1.UniqueId);

pero tambien podríamos usar el $ para poner directamente las variables en la cadena de texto

System.Console.WriteLine($"{curso2.Nombre} , {curso2.UniqueId}");

Página 2

Arreglos

Un arreglo o array es un conjunto de datos del mismo tipo, contenidos en memoria y que podemos efectuar operaciones sobre este conjunto de datos como si fueran una misma entidad.

Un arreglo tiene la característica de ser finíto. Se debe de colocar la cantidad de datos que usarás y eso separa en la memoria el espacio equivalente total a la cantidad de elementos que tendrá el arreglo. Es decir, si tienes 4 elementos de 4 bits cada uno, se separá un espacio de 16 bits en total.

Crear un arreglo de objetos

var arregloCursos = new Curso[3];

// Se creo un arreglo de tres espacios de objetos de la clase Curso

arregloCursos[0] = new Curso(){

Nombre = "101"

};

// En la posición 0 se agrego un objeto Curso con nombre "101"

Formas de recorrer un arreglo

while (contador < arregloCursos.Length)

{

Console.WriteLine(arregloCursos[contador].Nombre);

contador++;

}

========================

foreach (var item in arregloCursos) {

Console.WriteLine($"Nombre: {item.Nombre}, Id: {item.UniqueId}");

}

========================

for (int i = 0; i < arregloCursos.Length; i++) { Console.WriteLine(arregloCursos[i].Nombre);

}

Formas más limpias de escribir un arreglo

Lo que incialmente escribrimos creando un arreglo de Cursos de tres posiciones, y luego asignamos a cada posición un Curso

var arregloCursos = new Curso[3];

arregloCursos[0] = new Curso()

{

Nombre = "101"

};

var curso2 = new Curso()

{

Nombre = "201"

};

arregloCursos[1] = curso2;

arregloCursos[2] = new Curso

{

Nombre = "301"

};

Lo podemos acomodar de una forma más limpia, creando en la clase escuela una propiedad de Cursos[] a la que le asignemos el arreglo de cursos, y finalmente queda de la siguiente forma

escuela.Cursos = new Curso[]

{

new Curso(){ Nombre = "101" },

new Curso(){ Nombre = "201" },

new Curso{ Nombre = "301" },

};

Se ve más compacto y facil de enteder.

Página 3

Recorrer arreglos

While

while(condition)

{

// TODO

}

Do While

do

{

// TODO

}while(condition)

For

for (int i = 0; condition ; i++) {

// TODO

}

ForEach

foreach (var item in Array) {

// TODO

}

Atajos

Shift + Alt + ⬇ = Copia la linea o las lineas sombreadas hacia abajo

Alt + ⬇ = Mueve la linea o las lineas sombreadas hacia abajo

Shift + Alt + F = Dar formato a documento

Página 4

Mejorando Impresión

Mejora en validación de objetos (not null)

escuela != null && escuela.Cursos != null

es igual a poner

escuela?.Cursos != null

esto lo que va a hacer es verificar que escuela no sea null antes de consultar si existe Cursos y si esta propiedad es diferente de null, si escuela es null simplemente no hace la compración y no pasa

Operadores condicionales

Igual -> ==

Diferente -> !=

O -> ||

And -> &&

Menor que <

Mayor que >

Menor igual que <=

Mayor igual que >=

MOD % [11 % 5 es igual a 1]

Negación -> !

Atajo

Shift + Alt + seleccionar con el cursos varias lineas = te permite hacer selección por columnas

Using static

Cuando usamos

using static NAMESPACE.CLASS

podemos llamar directamente a los métodos de la clase declarada

Es importante tener un código compacto siempre y cuando este favorezca la legibilidad del código.

Añadiendo al inicio de nuestro archivo la línea:

using static System.Console

Podremos escribir solo WriteLine cuando vayamos a imprimir algo en consola.

Página 5

Condicionales

Operador IF

if(condicionA){

// Si condiciónA se cumple Hago algo

}else if(condicionB){

// Si condiciónA no se cumple y condicionB se cumple Hago esto otro

}else{

// Si ni condiciónA ni condiciónB se cumplen Hago esto otro

}

Condiciones múltiples

if (condicionA && condicionB){

// Si se cumple condiciónA y tambien se cumple condicionB

}

if (condicionA || condicionB){

// Si se cumple condiciónA O se cumple condicionB, sino se cumple ninguna no entra

}

if(!condicionC){

// Si la condición C no se cumple, va a entrar, porque se está negando

}

Operador ternario

var name = (condicion) ? valor_si_se_cumple : valor_si_no_se_cumple;

var numero = (1 + 1 == 2) ? 0 : 1;

El valor de la variable numero será 0

var numero = (1 + 1 == 3) ? 0 : 1;

El valor de la variable numero será 1

Página 6

Tipos de operadores

Aritméticos

+,-,*,/,=,++,--

Lógicos

&&, ||, ==, !=, >, <, >=, <=

Binarios

&, |, ^ (XOR), >> (CORRIMIENTO DE BYTES A LA DERECHA),

<< (CORRIMIENTO DE BYTES A LA IZQUIERDA),

~ (NEGACIÓN BINARIA - convierte 101 en 010)

De palabra clave

new: para crear nuevas instanacias de un objeto,

typeof: tipo de variable,

sizeof: tamaño en bytes del valor almacenado, nameof, checked, unchecked, default

Operadores condicionales NULL ?. y ?[]

A?.B?.Do(C);

A?.B?[C];

B no se evalúa si A se evalúa como null

C no se evalúa si A o B se evalúan como null