Clase 24 de 32 • Fundamentos de C# con NET Core 2.1
Contenido del curso
Gerardo Diaz
David Ayala
Naolin Abraham Molina Espíritu
Juan Romero
Usuario anónimo
Juan David Avila Medrano
Eduardo Rasgado Ruiz
Kevin Villatoro
Víctor A. Echeverría
Giovanny Farto
Miguel Peláez
Leonardo Ernesto Solórzano Carrasquero
Jimmy Buriticá Londoño
Leonel Absalon Blanco Castillo
Ingrid Natalia Rodriguez Ovalle
ELKIN YESID MORENO VELEZ
Hairo Santana Calderon
Wilson Alejandro Gonzalez Gaitan
Giovanny Farto
Joel Rodríguez Díaz
Andrés Felipe Martínez Salazar
R PMdo
David Salcedo
Julian Andres Builes Cajiao
rafael malanco velazquez
JUAN DAVID MARTINEZ GONZALEZ
Gabriel Diego Cejas
John Alberto Carreño Lizcano
Juan Carlos Ortiz Huamán
Giovanny Farto
Juan Carlos Arrieta Rincòn
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!!!
X2
++
Por lo que infiero a partir de esta clase y de lo que he podido leer sobre delegados, entiendo que los delegados son un TIPO en .net cuya PRINCIPAL FUNCIÓN es la de permitir pasar metodos a otros métodos. Estos métodos se puede pasar como Métodos anónimos o como expresiones lambda. Veo que cuando se pasa de la declaración de un delegado al uso de una expresión lambada la cantidad de código se reduce sustancialmente. Sin embargo creo que las expresiones lambda favorecen la programación In LIne, esa que se requiere hacer al paso. Pero si se presentase el caso de necesitar pasar un mismo método como parámetoro a muchos otro métodos si sería más recomendable definir el método a pasar como parámetro en un único lugar del código. Es lo que creo … espero les sirva de algo !!
totalmente de acuerdo
Realmente un delegado no pasa la funcion, es mas bien un apuntador, envía la ubicación en memoria de la función.
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.
Yo creo que esta bien para ambos "Nuevos" y "Experimentados", ya que al hacerlo en la marcha de un proyecto aprendes de manera mas "Empírica" y no "Sistemática".
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.
Es verdad, no es necesario esos paréntesis en la expresión. Lo mas común es no usarlos a menos que la expresión tenga mas de un parámetro en el cual se usaría algo como (x,y) => .....
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.
Gracias por la recomendación. Además me parece más fácil de entender.
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.
Hola, quizá este foro te de ideas :) https://stackoverflow.com/questions/5873603/whats-the-point-of-a-lambda-expression
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?
en forma documental no te puedo dar una explicación “científica”, pero en forma practica te puedo comentar que a mi me ha sucedió en sentencias if, si hago la comparación cadena == “SI” hay ocasiones que me lo interpreta bien y otras mal, pero cuando utilizo el cadena.Equals(“SI”) en estos casos el resultado siempre es exacto, no se si tiene algo que ver a nivel de bits, bytes o algo parecido, el problema regularmente se me presenta solamente con variables tipo string, con variables booleanas, numéricas, etc nunca he tenido algún problema parecido
Lo que pasa es que el operador == y el método Equals por defecto verifican si 2 objetos son el mismo (es decir comprar las posiciones de memoria), por ejemplo
Curso c1 = new Curso{ Nombre = "202"}; Curso c2 = new Curso{ Nombre = "202"}; WriteLine(c1 == c2); WriteLine(c1.Equals(c1));
va a imprimir False en ambos casos , porque aunque los 2 objetos son creados de a misma forma y con los mismos valores son 2 instancias distindos y por tanto no son iguales.
Lo que pasa con string es que implementa una sobrecarga para el operador == y para el metodo Equals, para que no solo compare si son la misma instancia, si no que hace una compraracion de sus valores, puedes ver mas en esta discucion .
En c# se puede hacer sobrecarga de operadores, entonces puedes cambia la logica que usa el operador == para un objeto en concreto, por eso puede haber casos en los que el operador == y el metodo Equals hagan cosas distintas, para eso te recomiendo leer aí muestran algunos ejemplos de como sobrecargar el operador == y el metodo Equals.
Tambien te recomiendo leer esta pagina, es my corta y te dice en que momentos sobrecargar o l operador o el metodo
Espero que te ayude.
Me marca el siguiente error y no entiendo por qué si tengo el mismo código que el del curso:
El operador '==' no se puede aplicar a operandos del tipo 'string' y 'TiposJornada' [Etapa1]
¿Por que el código del curso no marca error?
Te falta especificar el tipo de jornada. Ejemplo: TiposJornada.tarde
//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");
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
:o 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 :/
