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.

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

llego el diablo cargado de bugs ! … jajajaja

alguien me puede puede explicar mas a fondo que significa el

escuela?.Courses !=null 

?

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.

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

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

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

Aca hice una ligera modificacion al costructor de Curso

public string UniqueId { get; private set; }
public string Nombre { get; set; }
public Curso(string nombre)
        {
            UniqueId = Guid.NewGuid().ToString();
            Nombre = nombre;
        }

luego en Program.cs el array queda asi

escuela.Curso = new Curso[3]{
    new Curso("101"),
    new Curso("201"),
    new Curso("301")
};

El operador condicional ?:, también conocido como operador condicional ternario, evalúa una expresión booleana y devuelve el resultado de una de las dos expresiones, en función de que la expresión booleana se evalúe como true o false

Yo lo tenía así,

y siguiendo las instrucciones del profe refactoricé así:

Con el lanzamiento de C# 9.0, se introdujo el patrón de constante nula negada.
Por lo tanto además de poder escribir “!= null” se puede escribir “is not null” o también para el “== null” se puede escribir “is null”.

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($@“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.