Refactorización y Organización de Código en C#
Contenido del curso
Wilson Alejandro Gonzalez Gaitan
Alonso Fabricio Samanez Nuñez
Sergio Sanc
Carlos Junior Guzman Rodriguez
Guillermo Ariel Roso Cornielle
Guillermo Acosta
Miguel Alexander Vásquez Ortega
Jose Antonio Diaz Urbano
Ian Vassallo
Platzi Team
Elvis Moreira
Usuario anónimo
User
Juan Romero
Byron Bustamante López
Jimmy Buriticá Londoño
Pablo Juarez Castillo
Candelario Soto
Pablo Andrade
Misael Juarez Gordillo
Juan Diego Oliveros Rios
Carlos Hugo Urzagasti
Juan David Amaya Cardenas
Carlos Hugo Urzagasti
sergio ignacio hernandez cisternas
Jimmy Buriticá Londoño
Training CIT
Francisco Javier Pineda Giraldo
Francisco Javier Pineda Giraldo
Luis Zerpa
John Davis
John Davis
Deleted .
Carlos Eduardo Gomez García
JUAN DAVID MARTINEZ GONZALEZ
Pau Egea Cortes
Considero que la refactorizacion que se define como una técnica de la ingeniería de software para reestructurar un código fuente, alterando su estructura interna sin cambiar su comportamiento externo, va a la mano con los principios solid que son
S-Responsabilidad simple Este principio trata de destinar cada clase a una finalidad sencilla y concreta.
O-Abierto/Cerrado Principio atribuido a Bertrand Meyer que habla de crear clases extensibles sin necesidad de entrar al código fuente a modificarlo. Es decir, el diseño debe ser abierto para poderse extender pero cerrado para poderse modificar.
L-Sustitucion Liskov Este principio fue creado por Barbara Liskov y habla de la importancia de crear todas las clases derivadas para que también puedan ser tratadas como la propia clase base. Cuando creamos clases derivadas debemos asegurarnos de no reimplementar métodos que hagan que los métodos de la clase base no funcionases si se tratasen como un objeto de esa clase base.
I-Segregacion del interface Este principio fue formulado por Robert C. Martin y trata de algo parecido al primer principio. Cuando se definen interfaces estos deben ser específicos a una finalidad concreta. Por ello, si tenemos que definir una serie de métodos abstractos que debe utilizar una clase a través de interfaces, es preferible tener muchos interfaces que definan pocos métodos que tener un interface con muchos métodos.
El objetivo de este principio es principalmente poder reaprovechar los interfaces en otras clases. Si tenemos un interface que compara y clona en el mismo interface, de manera más complicada se podrá utilizar en una clase que solo debe comparar o en otra que solo debe clonar.
D-Inversión de dependencias También fue definido por Robert C. Martin. El objetivo de este principio conseguir desacoplar las clases. En todo diseño siempre debe existir un acoplamiento pero hay que evitarlo en la medida de lo posible. Un sistema no acoplado no hace nada pero un sistema altamente acoplado es muy difícil de mantener
:thumbsup:
Excelente comentario. Gracias.
Se esta poniendo hardcore
Nota: Seria bueno colocar como nombre de espacio CoreEscuela.App a muestra clase EscuelaEngine por si queremos agregar mas motores a nuestro proyecto.
Realmente se esta volviendo confuso. No entiendo la técnica haberlo hecho "mal" para después refactorizar. Debería primero explicarse en base a la "buena practica" y después comparar con un código mal hecho. Otra cosa: los nombre del namespace las clases confunde, debería tener nombres mas representativos. Ademas, para ser "fundamentos" va un poco rápido, sin explicar ciertas cosas... bueno, igual seguimos.
y cierttas cosas como cuales? 😰
Precisamente al ser un curso básico se explican cosas de una forma básica, aunque ello conlleve a malas prácticas, lo importante es entenderlo poco a poco. Cuando ya ciertos conceptos se entienden se pasa a lo siguiente. Una vez se han asentado esos conocimientos y se entiende la base refactorizas el código para de una vez ver unas mejores prácticas. Es como cuando aprendes a ir en bicicleta con ruedas auxiliares y cuando sabes mantener el equilibrio las quitas.
Estaba teniendo problemas con el Namespace hasta que vi este post https://platzi.com/blog/namespace-en-c-sharp/
Genial haha
Para esta clase la premisa principal es la de Refactorizar el código Para: tenerlo ordenado, que a medida que vaya creciendo podamos tener un orden en nuestro código y sea más fácil de manejar
Lo primero que se hará es al ver la explicación en la carpeta donde está el proyecto crear otra más que se llamará Etapa 4
Dentro de esta carpeta de la misma manera que se hizo para Etapa 1 se digitará en la ventana de consola dotnet new console Una vez realizado esto se creará los archivos que tenía hasta el instante la Etapa1. Se copiará el contenido.
Posterior a esto se irá borrando el código que no queramos entre ellos los comentarios.
Se crea la clase EscuelaEngine.cs con una propiedad pública que pueda encapsular . Además en el constructor no se manipulará entrada y salida de datos debe ser tan rápido como sea posible, para ello se creará un método en donde contendrá la información de la escuela con sus cursos.
public void Inicializar() { Escuela= new Escuela("Elvis academy",2012,TiposEscuela.Primaria, pais:"Ecuador", ciudad:"Portoviejo" ); Escuela.Cursos=new List<Curso>(){ new Curso(){Nombre="101", Jornada=TiposJornada.Mañana}, new Curso(){ Nombre="201", Jornada=TiposJornada.Mañana}, new Curso {Nombre="301",Jornada=TiposJornada.Mañana }, new Curso(){ Nombre="401", Jornada=TiposJornada.Tarde}, new Curso(){ Nombre="501", Jornada=TiposJornada.Tarde}, }; }
Para finalizar en el programa principal se inicializa este método y se imprime los cursos con la función que teníamos ya realizada
var engine= new EscuelaEngine(); engine.Inicializar(); imprimirCursosEscuela(engine.Escuela)
Es importante refactorizar nuestro código para mantenerlo ordenado.
El constructor de una clase tiene que ser tan rápido como sea posible, tiene que estar desconectado de cualquier cosa que implique entrada y salida.
Huy profe Juan, muy buenos lineamientos de refactorización !! Gracias …
El método ImprimirCursosEscuela no debería ir en la clase EngineEscuela también? ya que forma parte de la lógica de negocio.
Pienso igual.
Un poco confuso pero estoy tratando hay vamos
Animo, solo ten paciencia y ganas de aprender.
En el minuto 3:05 abre un cuadro blanco para las posibles soluciones ¿Cómo se activa aquello?
Hola! Alguien me puede indicar como solucionar este error La verdad no se que hacer, ya intente cambiando la clase Curso a public y nada que me funciona
hola si bien no se puede ver el código deverias fijarte en alparte de referencias y hacer la referencia correspondiete por mas que tengas la clausula using .
Hola @Diiegor
¿que nivel de accesibilidad le diste a la clase Cursos ?
Asegurate se haberle puesto public , recuerdad que si no declaras la accesibilidad las clases o metodos por defecto quedan en private y no puedes accederlas desde otras clases.
por que los métodos la clases estáticas deben ser estáticos no lo explico dijo que lo iba hacer y no lo hizo alguien sabe
por fin pasamos a la etapa 4 del curso de este maravilloso lenguaje
Se nota lo que hemos aprendido durante el curso.
Ah alguien mas le tira error al crear la clase EscuelaEngine?? como lo solucionaron
Hola,
creo haber escrito el código con tanto cuidado como he tenido, se que generalmente los errores son por teclear mal, o por no definir correctamente las clases y métodos, el código compartido por Luis a la altura del video difiere, y no quiero utilizar ese código sin entenderlo.
podrían guiarme para resolver el problema que se me esta presentando?
por que al iniciar el List<Cursos> desde el método si funciona, y al iniciarlo desde el Constructor de la clase EngineEscuela, como se ve en el video, No?
Hago el codigo igual que el video y me da muchos errores. 1ro: el public class EscuelaEngine Error: class CoreEscuela.EscuelaEngine El espacio de nombres 'CoreEscuela' ya contiene una definición para 'EscuelaEngine' [etapa1, etapa1]csharp(CS0101)
2do public EscuelaEngine Error: EscuelaEngine.EscuelaEngine() El elemento propiedad "Escuela" que no acepta valores NULL debe contener un valor distinto de NULL al salir del constructor. Considere la posibilidad de declarar el elemento propiedad como que admite un valor NULL. [etapa1, etapa1, etapa1, etapa1, etapa1, etapa1, etapa1, etapa1]csharp(CS8618) El tipo 'EscuelaEngine' ya define un miembro denominado 'EscuelaEngine' con los mismos tipos de parámetro [etapa1, etapa1]csharp(CS0111)
3ro public void Inicializar Error: void EscuelaEngine.Inicializar() El tipo 'EscuelaEngine' ya define un miembro denominado 'Inicializar' con los mismos tipos de parámetro [etapa1, etapa1]csharp(CS0111)
4to Escuela. Dentro de inicializar. Error: Entidades.Escuela EscuelaEngine.Escuela { get; set; } "Escuela" no es NULL aquí.
Ambigüedad entre 'EscuelaEngine.Escuela' y 'EscuelaEngine.Escuela' [etapa1, etapa1, etapa1, etapa1]csharp(CS0229)
Alguien me puede ayudar me estoy volviendo loco con este profesor. Borra - hace. Borra - hace. Borra - hace. Y a mi me siguen saliendo errores
Pudiste solucionarlo?? me sale el mismo de "El espacio de nombres 'CoreEscuela' ya contiene una definición para 'EscuelaEngine' [etapa1, etapa1]csharp(CS0101)"
Bro, no se si ya hayas podido solucionar el error, pero te comparto lo que yo hice para resolver
¿La palabra reservada void es para definir un método que no retorne algo concretamente con return, o que igual puede retornar algún mensaje con el Console.Write por ej.., pero no tener explícitamente el return?
¡Hola! void es para expresar explícitamente que tu función no va a retornar nada. Un Console.Write no retorna nada, sino que escribe en la consola. Se dice que tu función retorna algo en el momento en el que escribes return, pero si tú lo escribes dentro de una función void lo más probable es que te de un error 👀
Buenas comparto codigo utilizado en todo el curso practico...
using System; using System.Runtime.Serialization.Json; using CoreEscuela; // See https://aka.ms/new-console-template for more information using CoreEscuela.Entidades; var engine = new EscuelaEngine(); Console.WriteLine("======================================="); Imprimir(engine.Escuela); static void Imprimir(Escuela escuela) { Console.WriteLine("======================="); Console.WriteLine("Cursos de la Escuela 12"); Console.WriteLine("========================="); if(escuela?.Cursos !=null) { foreach(var curso in escuela.Cursos) { Console.WriteLine($"Nombre: {curso.Nombre}, CursoId: {curso.CursoId}"); } } } // Console.WriteLine("Hello, World!"); /* Agregando datos Escuela */ // Escuela es = new Escuela("Escuela Basicas",1995,TiposEscuela.Primaria,ciudad: "Medellin", pais: "Colombia"); /* Agregando cursos Curso cursos1 = new Curso(); cursos1.Nombre="Pruebas"; cursos1.Jornada =TiposJornada.Manaña; var curso2 = new Curso() { Nombre = "102", Jornada = TiposJornada.Tarde }; */ /* agregando cursos utilizando arrays[] 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 }; */ /* Agregando cursos utilizando listas List<> 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"}); */ /*Agregando cursos Escuela //es.Cursos.Add(new Curso(){Nombre="401", Jornada = TiposJornada.Manaña}); */ /* Agregando cursos a otra lista existente listas1.AddRange(listas2); listas1.RemoveAll(delegate (Curso cur){ return cur.Nombre=="402"; }); */ /* Eliminar un curso con un nombre especifico listas1.RemoveAll((cur) => cur.Nombre.Equals("506")); */ // SALIDAS // Console.WriteLine(es.Nombres); // Console.WriteLine("======================================="); // Console.WriteLine(cursos1.Nombre + "," + cursos1.Jornada + "," + cursos1.CursoId); // Console.WriteLine($"{curso2.Nombre} , {curso2.Jornada} , {curso2.CursoId}"); // if(es?.Cursos != null){ // 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}"); // } // }
Haciendo esta clase me daba error con los namespace, el problema, visual estudio code no esta pensado para desarrollar c# y lo único que tube que hacer para arreglar el problema con los namespace fué reiniciar VSC y todo fue perfecto.
