Refactorizar a escuela engine

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

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.

Estaba teniendo problemas con el Namespace hasta que vi este post https://platzi.com/blog/namespace-en-c-sharp/

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.

• A continuación se creará una carpeta que se llamará app, aquí irá la lógica de la aplicación.
• En esta carpeta crearemos el motor de la aplicación con un archivo que se llamará EscuelaEngine.cs
• Siguiendo con los cambios a implementar se cambia el namespace en Program.cs se llamará CoreEscuela. Posterior a este cambio se deberá verificar si está cambiado automáticamente el namespace para los otros archivos.

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.

El método ImprimirCursosEscuela no debería ir en la clase EngineEscuela también? ya que forma parte de la lógica de negocio.

Un poco confuso pero estoy tratando hay vamos

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

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.

No se si a alguein mas le aparezcan errores al crear la clase, EscuelaEngine, especificamente el error CS0101, les comparto la solucion que aplique y que me funciono

• 1 Cree un proyecto en blanco en una carpeta de nombre “CoreEscuela”
• 2 Abri el proyecto en VSC y comence a crear las clases correspondientes del proyecto y a copiarlas y pegarlas en el nuevo proyecto (en la carpeta “CoreEscuela”), ejecute y sin errores…

Opte por realizar esto ya que al solucionar el error CS0101, me salian mas errores asociados a: [etapa1, etapa1], y en vista de que VSC me creo muchos archivos en los cuales ya estaba seteado el nombre “Etapa1”, opte mejor por copiar el codigo de las clases en un proyecto nuevo para no estar editando manualmente cada archivo que se genero con “Etapa1” en el codigo

Muy bien

Hola, unas dudas.

Por lo que puedo notar, refactorizar es como re-organizar el código o mejor dicho, el proyecto. Esto me refiero porque bueno, hemos creado una nueva carpeta, un nuevo archivo donde haremos una especie de núcleo (engine) y ahí empezamos la lógica como tal del proyecto. Mientras que claro, los demás módulos cumplen funcionalidades más específicas.

Me imagino, que trabajando con un Framework (en este caso .NET o ASP.NET) no haría falta esto no? ya que vendría todo organizado?

Excelente!

Muy bien

Genial, muchas gracias. la refactorización es clave.

como se le hacía para importar o usar una clase, cuando se posiciona el cursor en la clase Cursos ?

Buenas clases

muy bueno

Refatorizar es importante para ordenar el código a medida que va creciendo un proyecto

Muy bueno lo de refactorizar, ¿Hay alguna convencion para la organización de las carpetas?

Muy buena refactorizacion del código excelente

Atajo para crear un constructor en C#

Genial, esta mejorando todo cada clase :0

El proceso de refactorización es muy importante sobre todo se se hace trabajo colaborativo o se desarrolla profesionalmente.

me siento estancado y he buscado por todo el error, considero que todo esta bien ,ayuda
Unhandled exception. System.NullReferenceException: Object reference not set to an instance of an object.
at CoreEscuela.Program.ImprimirCursosEscuela(Escuela Escuelita) in C:\Users\Juan Perdomo\platzi\c_char\etapa4\Program.cs:line 32
at CoreEscuela.Program.Main(String[] args) in C:\Users\Juan Perdomo\platzi\c_char\etapa4\Program.cs:line 17

Nunca me a funcionado lo de agregar los using con CTRL … me toca agregarlos manualmente.

Muy interesante la refactorización del código, se entendió perfecto

Le paso a alguien que renombraron el namespace de Etapa1 a CoreEscuela y les marcaba error en las líneas de: var engine = new EscuelaEngine(); ?

Estoy buscando en todo el código que borre de mas, que me me faltaba y nada, hasta volví a ver el video desde 0 para comparar, no entendía porque me marcaba ese error hasta que lo intente correr así y funciono por lo que así lo deje (ya era bastante tarde).

Hoy me llevo la sorpresa que cuando abro mi proyecto como por arte de magia ya no me arroja el error… 🤬 que alguien me explique!!!

El constructor debe ser lo más rápido como sea posible. Por lo tanto debe estar desconectado de cualquier cosa que implique entrada y salida. (Conexiones de red, archivos .. etc)