Sobrecargas de métodos

Adiós legibilidad!

Creo que en la sobre carga hay que pasar los parametros opcionales para que funcione correctamente.

public List<ObjetoEscuelaBase> GetObjetosEscuela(
            bool traeEvaluaciones = true,
            bool traeAlumnos = true,
            bool traeAsignaturas = true,
            bool traeCursosX = true)
        {
            return GetObjetosEscuela(out int dummy,out dummy, out dummy,out dummy,
                traeEvaluaciones:traeEvaluaciones,
                traeAlumnos:traeAlumnos,
                traeAsignaturas:traeAsignaturas,
                traeCursos:traeCursosX);
        }

La sobrecarga se define la sobrecarga consiste en crear más de un procedimiento, constructor de instancia o propiedad en una clase con el mismo nombre y distintos tipos de argumento

Ejemplo

<
        private int sumar()
        {
            return 1;
        }

        private int sumar(int a, int b)
        {
            return 1;
        }

        private double sumar(int a)
        {
            return 1D;
        }>

Si quisiera evaluar todas las combinaciones posibles, ¿también debería hacer sobrecarga de método con todas las posibilidades?

La sobrecarga de métodos es básicamente tener el mismo nombre de método con diferentes parámetros por ejemplo:

/De acuerdo al numero de parametros, cambia la firma de cada metodo/
public int metodo_uno(){ return 0;}
public int metodo_uno(int parametroUno){return parametroUno * 2;}

Creo que para una mayor legibilidad de los métodos debemos tener como máximo 6 parámetros en nuestros métodos, si por algunas razón sobrepasamos los 6 parámetros seria conveniente crear una clase Filtro que contenga todas las propiedades que necesitamos buscar

Muy interesante, aprendí algo nuevo 😄.

Aquí no hay rastro del principio DRY!

Hay cosas interesantes en este curso, pero muy mal explicadas. Pesima pedagogía para explicar y eso que el profe es evangelista de Microsoft.

Me estresa mucho ver ese código tan desordenado xD

definitivamente no veo como seguir el curso al mismo ritmo de la escritura que va haciendo Juan Carlos, ni el còdigo publicado en la parte inferior de cada video, no coincide, Frustante…

Para este ejemplo en particular, es muy difícil hacer sobrecarga, por las multiples combinaciones posibles. El profesor olvido pasar los parámetros opcionales.

La sobrecarga de métodos es la creación de varios métodos con el mismo nombre pero con diferente lista de tipos de parámetros.
Ejemplo:

public (List<ObjetoEscuelaBase>, int) GetObjetosEscuela(
            bool traeEval = true
            ,bool traeAlum = true
            ,bool traeAsig = true
            ,bool traeCursos = true
        ){
            return GetObjetosEscuela(out int dummy, out  dummy, out  dummy, out  dummy);
        }

public (List<ObjetoEscuelaBase>, int) GetObjetosEscuela(
            out int conteoEvaluaciones
            ,bool traeEval = true
            ,bool traeAlum = true
            ,bool traeAsig = true
            ,bool traeCursos = true
        ){
            return GetObjetosEscuela(out conteoEvaluaciones, out int dummy, out  dummy, out  dummy);
        }

public (List<ObjetoEscuelaBase>, int) GetObjetosEscuela(
            out int conteoEvaluaciones
            ,out int conteoAlumnos
            ,bool traeEval = true
            ,bool traeAlum = true
            ,bool traeAsig = true
            ,bool traeCursos = true
        ){
            return GetObjetosEscuela(out conteoEvaluaciones, out conteoAlumnos, out int dummy, out  dummy);
        }

public (List<ObjetoEscuelaBase>, int) GetObjetosEscuela(
            out int conteoEvaluaciones
            ,out int conteoAlumnos
            ,out int conteoAsignaturas
            ,bool traeEval = true
            ,bool traeAlum = true
            ,bool traeAsig = true
            ,bool traeCursos = true
        ){
            return GetObjetosEscuela(out conteoEvaluaciones, out conteoAlumnos, out conteoAsignaturas, out int dummy);
        }

public (List<ObjetoEscuelaBase>, int) GetObjetosEscuela(
            out int conteoEvaluaciones 
            ,out int conteoAlumnos
            ,out int conteoAsignaturas
            ,out int conteoCursos
            ,bool traeEval = true
            ,bool traeAlum = true
            ,bool traeAsig = true
            ,bool traeCursos = true
        )
        {
            //Asignación múltiple
            conteoEvaluaciones = conteoAsignaturas = conteoAlumnos = 0;
           
            var listaObj = new List<ObjetoEscuelaBase>();
            listaObj.Add(Escuela);
           
            if(traeCursos)
                listaObj.AddRange(Escuela.Cursos);
           
            conteoCursos = Escuela.Cursos.Count;
            foreach (var curso in Escuela.Cursos)
            {
                conteoAsignaturas += curso.Asignaturas.Count;
                conteoAlumnos += curso.Alumnos.Count;

                if(traeAsig)
                    listaObj.AddRange(curso.Asignaturas);
                if(traeAlum)
                    listaObj.AddRange(curso.Alumnos);
               
                if(traeEval)
                {
                    foreach (var alumno in curso.Alumnos)
                    {
                        listaObj.AddRange(alumno.Evaluaciones);
                        conteoEvaluaciones+= alumno.Evaluaciones.Count;
                    }
                }

            }
            return (listaObj, conteoEvaluaciones);
        }

🤯

excelente idea de utilizar de wrappers para cumplir principio DRY y hacer la terea mas facil y mas elegante al programador

Falto pasar los parámetros opcionales para que la funcionalidad quede completa. De la manera que esta siempre se asumirá que todos son true, lo cual quita la funcionalidad inicial de dichos parámetros.

Precisamente iba a preguntar si los parámetros de salida se podían hacer opcionales.

trabajar con envoltorios.

ajja me deje el metodo anterior y me salieron 6 sobrecargas xd :v

Es muy interesante usar la sobrecarga de métodos para decidir que parámetros se desean. Aquí les dejo mis métodos.

        public List<ObjetoEscuelaBase> GetObjetosEscuela(
            bool traeEvaluaciones = true, bool traeAlumnos = true, bool traeAsignaturas = true, bool traeCursos = true)
        {   return GetObjetosEscuela(out int dummy, out dummy, out dummy, out dummy,traeEvaluaciones,traeAlumnos,traeAsignaturas,traeCursos);}

        public List<ObjetoEscuelaBase> GetObjetosEscuela(
            out int conteoEvaluaciones,
            bool traeEvaluaciones = true, bool traeAlumnos = true, bool traeAsignaturas = true, bool traeCursos = true)
        {   return GetObjetosEscuela(out conteoEvaluaciones, out int dummy, out dummy, out dummy,traeEvaluaciones,traeAlumnos,traeAsignaturas,traeCursos);}

        public List<ObjetoEscuelaBase> GetObjetosEscuela(
            out int conteoEvaluaciones, out int conteoCursos,
            bool traeEvaluaciones = true, bool traeAlumnos = true, bool traeAsignaturas = true, bool traeCursos = true)
        {   return GetObjetosEscuela(out conteoEvaluaciones, out conteoCursos, out int dummy, out dummy,traeEvaluaciones,traeAlumnos,traeAsignaturas,traeCursos);}

        public List<ObjetoEscuelaBase> GetObjetosEscuela(
            out int conteoEvaluaciones, out int conteoCursos, out int conteoAsignaturas,
            bool traeEvaluaciones = true, bool traeAlumnos = true, bool traeAsignaturas = true, bool traeCursos = true)
        {   return GetObjetosEscuela(out conteoEvaluaciones, out conteoCursos, out conteoAsignaturas, out int dummy,traeEvaluaciones,traeAlumnos,traeAsignaturas,traeCursos);}

muy útil la sobrecarga para no estar repitiendo código.

Muy útil la sobrecarga

Sobrecargas de métodos

Vamos a optimizar nuestro código, para ello vamos a sobrecargar nuestro método GetObjetoEscuela para los casos donde necesitemos menos parámetros de salida.

Excelente curso sobre la sobrecargar para el uso de variables de salida

WOW!! Eso fue genial! Aunque demasiado codigo, no?

La sobrecarga de métodos en este ejemplo que estamos trabajando, permite que copiemos el método pero definiendo en cada una de las copias qué parametros de salidas necesitemos.
En primera instancia podemos copiar el método y que no se necesite ningún parámetro de salida

public List<ObjetoEscuelaBase> GetObjetoEscuela(
           bool traeEvaluaciones=true,
           bool traeeAlumnos=true,
           bool traeAsignaturas=true,
           bool traeCursos=true
           
       )
       {
           return GetObjetoEscuela(out int dummy,out dummy, out dummy, out dummy);
       }

Con dos parámetros de salida

public List<ObjetoEscuelaBase> GetObjetoEscuela(
           out int conteoEvaluaciones,
           out int conteoCursos,
           bool traeEvaluaciones=true,
           bool traeeAlumnos=true,
           bool traeAsignaturas=true,
           bool traeCursos=true![](url)
           
       )
       {
           return GetObjetoEscuela(out conteoEvaluaciones,out conteoCursos, out int dummy, out dummy);
       }

A la hora de definir el objeto nos mostrará que tenemos 5 sobrecargas y que le podemos pasar los parámetros según cada sobrecarga indique

los parametros de salida no se pueden colocar como opcionales