Inicializando arreglos y mejorando impresión

El carácter ? usado dentro de una condicional que contenga como parámetro de evaluación un objeto con un atributo, sirve para indicarle a C# que solamente después de verificar la condición en el objeto y esta sea verdadera, pase a verificar la condición en el atributo.

Con Ctrl + d pueden seleccionar palabras iguales en diferentes lineas. Se posicionan en la palabra que desean seleccionar y presionan Ctrl + d y se van seleccionando las palabras iguales que va encontrando el editor.

"?"
No se va a verificar Cursos salvo que escuela sea diferente de null.

 if (escuela?.Cursos != null)  {

 }

Es muy distinto tener un arreglo sin posiciones a tener un arreglo nulo
arreglo = null → arreglo nulo
arreglo = new arreglo → arreglo sin posiciones
la diferencia es que el arreglo sin posiciones ya está inicializado, “existe” dentro del flujo de mi programa, mientras que el arreglo nulo no.

• Corto circuito de expresión de evaluaciones
  Cuando se tienen dos condiciones por validar en una instrucción if usando la expresión **and ** el programa evaluará en orden las condiciones y en caso de que la primera sea falsa ya no evaluará la segunda y se saltara el bloque de codigo.
  en caso de que se usará un **or **si la primera condición verdadera ya no evalúa la segunda entrará al bloque de codigo.

Muy bien! creo que me estoy enamorando de C#!

llego el diablo cargado de bugs ! … jajajaja

alguien me puede puede explicar mas a fondo que significa el

escuela?.Courses !=null 

?

En este caso las condicionales que podremos encontrar son
Igual ==
Diferente !=
O ||
And &
equals

escuela?.Cursos != null que clase de brujeria es esta 😁

Gracias, después de varios videos donde a mi parecer se iba por encima y sin profundizar lo importante, ya veo ahora algunas cosas nuevas de .net que no había usado antes.

En caso de que alguno no lo sepa visual code nos permite acceder rápidamente a los elementos del mismo nombre con [Ctrl ] + [D ] sobre la palabra o lo seleccionado

También se puede simplificar las sentencias if para evaluar si es null utilizando ?? así:

private static void ImprimirCursosEscuela(Escuela escuela)
{
System.Console.WriteLine(“Cursos de la escuela”);
foreach (var curso in escuela?.Cursos?? new Curso[0])
{
WriteLine([email protected]“Nombre: {curso?.Nombre},
id: {curso?.UniqueId}”);
}
}

También podemos hacer algo como

static void ImprimirCursosEscuela(Escuela escuela)
{
    WriteLine("--------------------");
    WriteLine("Cursos de la escuela");
    WriteLine("--------------------");

    if (escuela.Cursos != null)
    {
        foreach (var item in escuela.Cursos)
        {
            Console.WriteLine($"ID: {item.ID} Nombre: {item.Nombre}");
        }
    }
    else
    {
        return;
    }
}

El metodo para imprimir los cursos de la escuela:

private static void ImprimirCursos(Escuela escuela)
    {
        System.Console.WriteLine("CURSOS DE LA ESCUELA");
        System.Console.WriteLine("====================");
        System.Console.WriteLine("nombre\t"+"id");
        if (escuela != null && escuela.cursos != null)
        {
            foreach (var curso in escuela.cursos)
            {
                System.Console.WriteLine($"{curso.name}\t{curso.UniqueId}");
            }
        }
    }

y pumm … se toteó ! ; jajajaj me totie de la risa pero que buena pedagogia tienes !

Me tomó algo de tiempo hacer el condificional con el ?. Pero ya más claro y definitivamente si se sabe usar, queda mucho más legible el código.

Excelente

Nos tocó un QA diablo 😄 😄 😄

que seria lo mas conveniente? realizar todas estas validaciones dentro de nuestra funcion? o que el mismo objeto se encargue de esto?

Corto circuito de expresión de evaluaciones. Termino.

Buen tip el Alt+Shift para seleccionar varias lineas paralelas

static void Main(string[] args)
        {
            var escuela1 = new Escuela("Platzi Academy", 1994, TiposEscula.Universidad, ciudad: "Mexico");      //no olvidad agregar el namespace "using CoreEscuela.Entidades" 
            var escuela2 = new Escuela("Platzi University", 2000, TiposEscula.Universidad, ciudad: "Canada");

            //Array OTHER WAY to create
            var arregloCursos = new Curso[4]{
                        new Curso(){Nombre = "101"},
                        new Curso(){Nombre = "201"},
                        new Curso() { Nombre = "301", Jornada = TiposJornada.Tarde },
                        new Curso("The best curse ever", TiposJornada.Noche)
            };

            //Array OTHER WAY to create. NOT UED in this example
            Curso[] arregloCursos2 = {
                        new Curso(){Nombre = "401"},
                        new Curso(){Nombre = "501"},
                        new Curso() { Nombre = "601", Jornada = TiposJornada.Tarde },
                        new Curso("The best curse ever", TiposJornada.Noche)
            };
            //escuela1.Cursos = null;
            escuela1.Cursos = arregloCursos;

            escuela2.Cursos = new Curso[]{
                        new Curso(){Nombre = "C"},
                        new Curso(){Nombre = "C++"},
                        new Curso() { Nombre = "C#", Jornada = TiposJornada.Tarde },
                        new Curso("The best curse ever", TiposJornada.Noche)
            };

            ImprimirCursosEscuela(escuela1);
            ImprimirCursosEscuela(escuela2);
        }

        private static void ImprimirCursosEscuela(Escuela escuela)
        {
            //if(escuela != null && escuela.Cursos != null) //Corto circuito de expresion de evaluaciones
            if (escuela?.Cursos != null)
            { //Solo se verificara cursos, si escuela tambien es diferente de null.
                WriteLine("===================================");
                WriteLine($"======{escuela.Nombre}======");
                WriteLine("===================================");

                foreach (var curso in escuela.Cursos)
                {
                    WriteLine($"Nombre: {curso.Nombre}, Id: {curso.UniqueId}, Jornada: {curso.Jornada}");
                }
            }
            else
            {
                WriteLine("Esta escuala no existe o no tiene cursos");
                return;
            }
        }```

Alguien le sale algún error al intentar agregar la propiedad curso[] en Escuela.cs?

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.

Que signigica el simbolo ?

vaya vaya

Excelente!

// 'alt' + 'shift' ==> "seleccionar varias lineas"```

Excelente!

Teclas rápidas cuando el código está desordenado:

alt + shift + f ==> ' para ordenar el código ;)'

Aporte rápido:

Se puede optimizar un poco más el código si se utiliza la palabra reservada return seguido del if.

            if(escuela?.Cursos == null) return;
            foreach (var curso in escuela.Cursos)
            {
                WriteLine($"Nombre del curso: {curso.Nombre}, Id: {curso.UniqueId}");
            }

¿verdad?

Buenas clases

Muy bueno, pero creo que es mejor utilizar la List, del especio de nombre Generic

static void Main(string[] args)
{
var escuela = new Escuela(“Telesup-Platzi”, 2012, TiposEscuela.Primaria,
ciudad: “Lima”, pais: “Peru”);

        var arregloCursos = new Curso[3] {

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

        };
        
                          
        Console.WriteLine(escuela);
        System.Console.WriteLine("=======================");
        ImprimirCursosForEach(arregloCursos);

Le agregue un else para que el usuario sepa por que no imprime en el caso no tenga cursos la escuela.

 private static void PrintCoursesSchool(School escuela)
        {
            WriteLine("==================");
            WriteLine("Cursos de la escuela");
            WriteLine("=====================");
            if (escuela?.Courses != null)
            {
                foreach (var curso in escuela.Courses)
                {
                    WriteLine($"Nombre: {curso.Name}, ID: {curso.UniqueId}");
                }
            }
            else
            {
                WriteLine("Tu escuela no tiene cursos");
            }

        }

Vemos como hacer mas compacto nuestro código, en que casos es mejor y, vemos el uso del operador de interrogación.

excelente cursos y tips para programar

Como los cursos pertenecen a una escuela, yo coloque el método de imprimir cursos en escuela, no le envio parametros, por que esta tomándolo de this, de esta manera.

public void ImprimirCursos(){
WriteLine("=");
WriteLine(“Cursos en la escuela”);
WriteLine("=");
if(this?.Cursos!= null){
foreach (var curso in this.Cursos)
{
WriteLine($“Nombre: {curso.Nombre} ID: {curso.UniqueId}”);
}
}
}

aunque en este caso this? esta muy muy redundante, ya que si no tienes definida la escuela (instanciando) no deberías poder listar cursos.

private static void ImprimirCursosEscuela(Escuela escuela)
{
WriteLine("=");
WriteLine(“Cursos De La Escuela”);
WriteLine("=");

        if (escuela.cursos != null)
        {



            foreach (var cursos in escuela.cursos)
            {
                WriteLine($"Nombre {cursos.Nombre}, Id {cursos.UniqueId}");

            }

        }
        else
        {
            WriteLine("No Existe Ningun Curso");
        }
    }

Mi codigo

 if (escuela?.Cursos == null)
            {
                return;
            }

 foreach (var curso in escuela.Cursos)
{
   WriteLine($"Nombre {curso.Nombre}. Id {curso.UniqueId}");
 }```

entre mas compacto se el codigo mejor siempre y cuando sea legible.

Muy bien como controlar la evaluación de los datos nulos en los parámetros

En mac para seleccionar texto en columna es Shift + Option y arrastrar con el mouse

Un poco largo pero muy buen material

Con qué fin usamos la palabra static?

el operador ?, creo que es opcional osea si hay null o no hay null, igual se ejecuta…
si alguien puede saber mejor gracias

    private static void ImprimirEscuelas(Escuela escuela)
        {
            Console.WriteLine("===================================");
            Console.WriteLine($"Escuela {escuela.Nombre}");
            Console.WriteLine("===================================");
            Console.WriteLine(escuela);
            Console.WriteLine($"============= Cursos =============");
            ImprimirCursos(escuela.Cursos);
            Console.WriteLine();
        }

Para abreviar los WriteLines.

 Console.WriteLine("=======\nCursos de la escuela\n=======");

Se totió, jajajajajajaja. Made in Colombia.

Falto resolver la duda de la comparación entre el for y el foreach. una explicación de porque el for es mas rápido?

Existen muchísimas formas de hacer lo mismo, seria interesante q se explique una forma mas practica, creo q el resto de formas se usara en dependencia con el proyecto q se haga

El código compacto es valido siempre y cuando favorezca la legibilidad del código.

Yo lo plantee así para agregar el arreglo de cursos:

escuela.Cursos = new Curso[]{
	new Curso{Nombre = "101"},
        new Curso{Nombre = "201"},
        new Curso{Nombre = "301"}
};

Excelente Clase.

Maneras de inicializar arrays con objetos

Les recomiendo si quieren guardar código para futuras referencias pero que no haga tanto ruido usar regions.

#region Long version array definition

//var courses = new Course[3];

//courses[0] = new Course()
//{
//    Name = ".NET 101"
//};

//var secondCourse = new Course()
//{
//    Name = "C# 101"
//};

//courses[1] = secondCourse;

//courses[2] = new Course
//{
//    Name = "Object Oriented Programming"
//};
            
#endregion```

Usando Visual Studio Community, no he probado en Code.