Expresiones lambda y delegados

Llevo varios años desarrollando en C# y es primera vez que veo de manera tan sencilla el tema de los delegados, ya he tenido a;os usando expresiones lambda pero ver este paso a paso es muy gratificante.

Empece a ver este curso para fortalecer conceptos básicos y revisar mis conocimiento!

EXCELENTE CURSO!!!

Super entendible el curso, considerando que soy programador entrando al mundo de C# para ampliar mis skills. Pero para novatos entrando al mundo de la programación, no lo se Rick…
Yo agradezco al team Platzi de todas formas porque el enfoque con el que entra este curso acelera el aprendizaje de C# para ponerlo a la de ya en la práctica.

Se puede instalar el paquete C# XML Documentation Comments, para que automaticamente escribiendo /// sobre el método, esto te construya la sección de documentación de las clases y métodos.

Creo que tambien puede evitar el uso de (). Lo podria resumir a simplemente lo siguiente:
escuela.Cursos.RemoveAll(x => x.Nombre.Equals(“301”));
Usando expresiones Lambda.

Sería bueno que se explicara cuando se debe utilizar el == y el Equals en tipos de datos string, ya que la comparación no es exactamente la misma.

Les recomiendo utilizar la expresion lambda que se usa al final de una vez asi cuando les toque hacer operaciones hacia base de datos usando LinQ van a estar familiarizados y se les hara super facil.

El video donde da una breve explicación o menciona los delegados esta interesante, sería bueno poder tener más ejemplos de como se implementan o cuando se implementan, ventajas o usos reales que se les da.

Inferencia de tipos : Los inferencia de tipos es una característica predominante de los lenguajes de programación funcionales tales como C#. La inferencia de tipos asigna automáticamente un tipo de datos a una función sin necesidad de que el programador lo escriba.

El profe debio empezar por los comentario ajajaja.

Definición Una expresión lambda es una función o método anónimo con el que podemos crear tipo delegados y árboles de expresiones

Ejemplo de una expresión lamba

<string[] digits = { "zero", "one", "two", "three", "four", "five",   
            "six", "seven", "eight", "nine" };  
  
    Console.WriteLine("Example that uses a lambda expression:");  
    var shortDigits = digits.Where((digit, index) => digit.Length < index);  
    foreach (var sD in shortDigits)  
    {  
        Console.WriteLine(sD);  
    }  
  >

Podrían explicar las diferencias entre Equals y ==, según cada tipo de dato?

aqui les dejo un resumen de mis apuntes por si les interesa:

Delegados:

<code>         
public delegate void MyDelegate(int a, int b); // declaracion del delegado y sus parametros, funciona para cualquier tipo de metodo; un delegado es una funcion que se puede asignar a una variable
        public static void Main(string[] args)
        {
            MyDelegate del = new MyDelegate(Add); // se asigna la funcion Add a la variable del
            del(10, 20);
            del = new MyDelegate(Subtract); // se asigna la funcion Subtract a la variable del
            del(10, 20);
            del = new MyDelegate(Multiply); // se asigna la funcion Multiply a la variable del
            del(10, 20);
            del = new MyDelegate(Divide); // se asigna la funcion Divide a la variable del
            del(10, 20);
        }
        public static void Add(int a, int b)
        {
            Console.WriteLine(a + b);
        }
        public static void Subtract(int a, int b)
        {
            Console.WriteLine(a - b);
        }
        public static void Multiply(int a, int b)
        {
            Console.WriteLine(a * b);
        }
        public static void Divide(int a, int b)
        {
            Console.WriteLine(a / b);
        }

Lambda:

<code> 

public static void Main(string[] args)
        {
            List<entry> entries = new List<entry>
            {
                new entry { name = "John", lastname = "Doe" },
                new entry { name = "Jane", lastname = "Will" },
                new entry { name = "Joe", lastname = "Black" },
                new entry { name = "Jack", lastname = "White" },
                new entry { name = "Jill", lastname = "Valentine" },
                new entry { name = "Juan", lastname = "Perez" },
        };
            // Ordena la lista de forma ascendente y es una funcion anonima
            //===================================================================================================

            //entries.Sort(compareEntries); 

            //===================================================================================================

            // ordena la lista de forma descendente y es una funcion anonima
            //===================================================================================================

            //entries.Sort(delegate (entry x, entry y) 
            //{
            //    return $"{x.name} {x.lastname}".CompareTo($"{y.name} {y.lastname}");
            //}
            //);

            //===================================================================================================

            // lambda expresion para ordenar la lista, lambda se utiliza para ordenar una lista de objetos o una lista de entradas
            //===================================================================================================
            
            entries.Sort((x, y) => $"{x.name} {x.lastname}".CompareTo($"{y.name} {y.lastname}"));

            //===================================================================================================

            // se realiza un foreach para imprimir la lista en consola
            // ==================================================================================================

            foreach (entry entry in entries)
            {
                Console.WriteLine($"{entry.name} {entry.lastname}");
            }

            //===================================================================================================

            Console.ReadKey(); // se pone para que no se cierre la consola
        }

        //private static int compareEntries(entry e1, entry e2)
        //{
        //    return $"{e1.name} {e1.lastname}".CompareTo($"{e2.name} {e2.lastname}");
        //}

Comparto parte del contenido del curso

using System.Runtime.Serialization.Json;
// See https://aka.ms/new-console-template for more information
using CoreEscuela.Entidades;

Console.WriteLine("Hello, World!");
Escuela es = new Escuela("Escuela Basicas",1995,TiposEscuela.Primaria,ciudad: "Medellin", pais: "Colombia");

Curso cursos1 = new Curso();
cursos1.Nombre="Pruebas";
cursos1.Jornada =TiposJornada.Manaña;


var curso2 = new Curso()
{
    Nombre = "102",
    Jornada = TiposJornada.Tarde
};

var arrayCursos = new Curso[3];

arrayCursos[0] = new  Curso(){
    Nombre = "301",
    Jornada = TiposJornada.Noche
} ;

var cursos2 = new Curso(){
    Nombre="302",
    Jornada = TiposJornada.Noche
};
arrayCursos[1] = cursos2;

arrayCursos[2] = new Curso(){
    Nombre = "303",
    Jornada = TiposJornada.Noche
};

var listas1 = new List<Curso>(){
    new Curso(){Nombre = "505"},
    new Curso(){Nombre = "506"},
    new Curso(){Nombre = "507"}

};

var listas2 = new List<Curso>(){
    new Curso(){Nombre="401"},
    new Curso(){Nombre="402"}
};
listas1.Add(new Curso{Nombre="508"});



//es.Cursos.Add(new Curso(){Nombre="401", Jornada = TiposJornada.Manaña});
listas1.AddRange(listas2);

listas1.RemoveAll(delegate (Curso cur){
                return cur.Nombre=="402";
                });

listas1.RemoveAll((cur) => cur.Nombre.Equals("506"));

Console.WriteLine(es.Nombres);
Console.WriteLine("=======================================");
Console.WriteLine(cursos1.Nombre + "," + cursos1.Jornada + "," + cursos1.CursoId);
Console.WriteLine($"{curso2.Nombre} , {curso2.Jornada} , {curso2.CursoId}");
ImprimirCurosNoche(arrayCursos);
Console.WriteLine("========================================");
foreach(var list in listas1){
     Console.WriteLine($"Salon: {list.Nombre} ");
}

void ImprimirCurosNoche(Curso[] arrayCursos)
{
    foreach(var curso in arrayCursos){
        Console.WriteLine($"Nombre: {curso.Nombre} , Jornada: {curso.Jornada}, Id: {curso.CursoId}");
    }
}
 output 

Hello, World!
Escuela Basicas
=======================================
Pruebas,Manaña,be479669-8ae6-4e95-9ecd-c9ae4086db3b
102 , Tarde , 61618250-2e95-4888-bd26-8c14f6d513d0
Nombre: 301 , Jornada: Noche, Id: d423e6ec-cd6b-476e-b33f-d4223ffb1da7
Nombre: 302 , Jornada: Noche, Id: 85978e34-115f-461f-833f-531a0bf39520
Nombre: 303 , Jornada: Noche, Id: d446dffc-d8f4-4650-9ddf-b003d5663ca6
========================================
Salon: 505
Salon: 506
Salon: 507
Salon: 508
Salon: 401
Salon: 402
PS C:\Users\juand\OneDrive\Documents\Cursos\Net6\FundamentosCore2.1> dotnet run
Hello, World!
Escuela Basicas
=======================================
========================================
Salon: 505
Salon: 507
Salon: 508
Salon: 401

Esto es muy parecido a la función filter de JavaScript :

escuela.Cursos.RemoveAll((cur)=> cur.Nombre == "501" && cur.Jornada == TiposJornada.Mañana );

Me gusto mucho la manera como el profe explica conceptos complejos

😮 no sabia que en C# se podian hacer los arrow function de javascript, me esta gustando mas este curso.

Escribir comentarios a metodos es de gran ayuda ya que luego el propio editor te indica los comentarios que escribiste; no solo para el metodo si no tambien para cada uno de los parametros del mismo.
Por ejemplo:
Comentas este codigo a nivel de metodo:

Y cuando un programador hace uso del ese metodo, aparecerá facilmente la ayuda sobre ese metodo:

Estos comentarios se pueden aplicar a clases, metodos, propiedades, eventos, variables, etc, etc.

Me dejo loco el Delegate 😕

Un poco mejor la aclaración de este video que el anterior

  NuevaLista.RemoveAll(cur => cur.Nombre.Equals("301"));

Es parecido a una arrow function en js. Es clarísimo todo lo que hablas.

Excelente clase, las Expresiones lambda es justo lo que necesitaba aprender.

Cuando lleva solo un parámetro de entrada no es necesario los paréntesis de cur
escuela.Cursos.RemoveAll( cur => cur.Nombre == “Informatica 1”);

aqui les dejo otro ejemplo:

bueno siempre hay opiniones diversas, como la que yo escuche del tio BOB: "Un codigo comentado, es un codigo ue no transmite lo que hace "

Si quieren mas información este link es de mucha ayuda 😄
[https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/operators/lambda-expressions](Expresiones lambda C#)

Excelente clase

Estaria bien explicar un poco mas las expresiones Lambda

Interesante pero parece un poco complejo

😎

Es posible tener un segundo parametro de entrada para el caso de la expresion Lambda?

Muy buena clase

Vean el curso de python, ahí hablan sobre las funciones lambda
https://platzi.com/clases/python/

Vamos sigamos

Explicas muy bien saludos

Ok eso de los comentarios esta bueno, gracias!

Gracias muy claro

Excelente!

Interesante!

Buenas clases

Aprendere? ajaja

wow me hice un poco de bola pero con algunos ejercicios supongo que lograré entender lo mejor

Un chingo que digerir 😃 pero si que esta chido 😃 estoy aprendiendo demasiado 😃

//Definir un Delegado
escuela.Cursos.RemoveAll(delegate (Curso cur){
	return cur.Nombre == "301";
});

//Definir una expresión Lambda
escuela.Cursos.RemoveAll((cur) => cur.Nombre == "301");

Excelente!

Un poco confuso al inicio

De los comentarios faltó las regiones xD

Excelente, sin duda hay que estudiar un poco más para entender mejor los delegados.

Logré optimizar mi código con esta clase. Antes recorría posiciones con un ciclo for y con una condicional eliminaba.

Nunca habia implementado una expresion lambda pense que era mas complicado pero no fue asi gracias profe Juan Carlos

escuela.Cursos.RemoveAll((cur)=> cur.Nombre == "501" && cur.Jornada == TiposJornada.Mañana );```

Muy bueno este modulo se explica bastante y este curso vale oro

Una expresión lambda es una función anónima que puedes usar para crear delegados, son bastante útiles pues tu código queda de forma más compacta, pero solamente si esta función se utilizara en un solo lugar.

En C# puedes comentar de distintas formas:

Con // para comentar una sola línea.
Con /* y */ para comentar varias líneas.
Con /// para comentar lo que hace un método especifico.

A ver si entendí: El delegado es como una condición que se debe cumplir para que efectúe una acción dentro de una colección?

Por ejemplo: Creó una coleccion para agregar productos. a esta coleccion le asigno la palabra clave ADD y el delegado sera que cuando exista un producto que sea aceite de motor este sea añadido a la coleccion?

Que complicado X.X

Siempre a la mano la Documentación

Un delegado es un tipo que representa referencias a métodos con una lista de parámetros determinada y un tipo de valor devuelto. Cuando se crea una instancia de un delegado, puede asociar su instancia a cualquier método mediante una signatura compatible y un tipo de valor devuelto. Puede invocar (o llamar) al método a través de la instancia del delegado.

Delegate y Lambda que buen ejemplo.

que tan bueno es usar doxygen ¿?, ¿existe algo mejor para la documentación de código ?

las LAMBDAS son funciones ANONIMAS.

es un .Map de javascript o .filter

Repetire estas clases hasta que me quede bien claro, se nota que es muy bueno pero por mi falta de experiencia tengo que asimilarlo bien

escuela.Cursos.RemoveAll((Curso curs) => curs.Nombre == “102”);

Lo que se hace en el min 3:23 es en realidad un metodo aninimo, no una expresion lambda. Aunque en efecto una expresion lambda es tambien es definida como una funcion anonima, pero tienen sus diferencias. Las funciones/metodos anonimos se usan cuando vas a usar un metodo solo para algo especifico en el codigo, es decir, no vuelves a utilizar el metodo para otra cosa, y las expresiones lambda igual, pero se usan cuando tienes poco codigo en el metodo.

Resumen Etapa 3

Inferencia de Tipos. Estudiar este tema.