Uso de numeraciones y el método ToString

Otra forma de retornar los atributos es con StringBuilder

public override string ToString(){
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("Nombre: "+this.Nombre+"\n");
            sb.AppendLine("Pais: "+this.Pais+"\n");
            sb.AppendLine("Ciudad: "+this.Ciudad+"\n");
            sb.AppendLine("Año: "+this.AñoDeCreación+"\n");
            sb.AppendLine("Tipo de Escuela: "+this.TipoEscuelas+"\n");
            return sb.ToString();

        }

Ya que en la clase pasada definimos el contructor usando => pense que tambien se podrian usar en el metodo ToString y lo defini de esta forma:

public override string ToString() => $"{Nombre}: Tipo {TipoEscuela} \nCreada en: {AñoDeCreacion}";

Mi código comprobado y comentado del archivo Program.cs

using System;
using CoreEscuela.Entidades; //importamos el archivo del namespace CoreEscuela.Entidades para poder acceder y utilizar la clase Escuela

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            var escuela = new Escuela("Platzi Academy", 2012); //creamos una nueva instancia de la clase Escuela, recibe dos parametros para el constructor (nombre, año de creación)
            escuela.País = "Colombia"; //Definimos el atributo del país de la escuela
            escuela.Ciudad = "Bogota"; //Definimos el atributo de ka ciudad de la escuela
            escuela.TipoEscuela = TiposEscuela.PreEscolar;
            Console.WriteLine(escuela); //Escribimos la instancia de la escuela #endregion
            /* Por defecto imprimir una instancia ejecutara la funcion ToString lo cual nos mostrara el origen de la instancia, sin embargo esta función 
            se puede sobreescribir con override*/
        }
    }
}

Aquí les dejo una porción de mis notas con los códigos que hemos visto, espero les sirva y disculpen si obvie algunas cosas.
Códigos
** void**: Es un método que se usa para nombrar la función que creamos
Sintaxis :

public void nombre de la funcion()
        {
		}

class: Se usa para declarar una clase
Sintaxis:

class nombre de la clase()
        {
		}

namespace: Se usa para darle nombre al documento que tendrá un conjunto de clases las cuales poseerán un conjunto de atributos y/o métodos, y que tendrán objetos, es la punta de la jerarquía de un documento c#.
Sintaxis:

 	namespace nombre del namespace()
        {
		}

int: Se usa para declarar una variable de tipo entero
Sintaxis:

int Nombre de la variable = valor de la variable en número entero ;

string: Se usa para declarar una cadena de texto de ahí su nombre. el valor debe ser declarado dentro de la comillas.
Sintaxis:

string Nombre de la variable = “valor de la variable en caracteres ASCII”;

Console.WriteLine: Se usa para imprimir líneas de texto en la consola. puedes escribir el texto entre comillas o escribir el nombre de una variable de tipo string.
Sintaxis:

Console.WriteLine(“texto que se va a imprimir”);

get{}: Se usa para decir lo que se debe ejecutar cuando llamen la variable que lo contiene. junto con la instrucción return podemos encapsular otra variable privada y así invocarla correctamente.
Sintaxis:

get {return "copia:" + nombre; }

set{}: Se usa para permitir darle un valor a la variable del objeto creado. si junto a value agregamos un .ToUpper() los caracteres se volverán a mayúscula.
Sintaxis:

set {nombre = value.ToUpper() ; }

Constructor: Se usa para crear instancias (objetos) a partir de la clase.
Sintaxis:

//manera actual de hacerlo
 	public Escuela (string nombre, int año) => (Nombre, AñoDeCreación) = (nombre,año);
 
 
 
//manera clásica de hacerlo
public Escuela (string nombreDentroDelConstructor, int nombreDentroDelConstructor) 
{
	this.nombreDeLaVariable = nombreDentroDelConstructor
	nombreDeLaVariable = nombreDentroDelConstructor
}

public override: Tal como su nombre lo dice, se usa para sobrescribir un objeto(C# lo ve todo como un objeto), en el ejemplo se sobrescribe el método ToString
Sintaxis:

 	public override string ToString()
        {
            return $"Nombre: {Nombre}, TipoEscuela: {TipoEscuela} \nPaís: {País}, Ciudad: {Ciudad}";
        }

enum: Se usa para crear una lista con valores predeterminados, esto nos ayuda a evitar errores y problemas de información.
Sintaxis:

	public enum Nombre de la enumeración 
    {
       Valor1 , 
        Valor2, 
        Valor3
    }

Que mas Cursos da El mismo profesor ?

Si se quiere acceder al método del “padre” se puede usar la palabra clave base, por ejemplo:

public override string ToString() => $"{base.ToString()}: {Nombre}";

en este caso utilzo la funcionalidad “por defecto” y la extiendo, imagino que esto lo vamos a ver en detalle mas adelante.

Práctico y funcional con un par de variables extra

        public override string ToString()
        {
            return $"Nombre: {nombre}, Tipo: {tipo.ToString()}, Fundada: {año_creacion}\nPais: {pais}, Ciudad: {ciudad}, Dirección: {direccion}";
        }

estoy tomando el curso en noviembre del 2022 con las nuevas versiones de visual estudio y la verdad no aprendo por que hay muchos errores. se necesita una actualización del curso

Escuela.cs

namespace CoreEscuela.Entidades
{
    class Escuela
    {
      string nombre;
      public string Nombre
      {
        get{ return "Copia: " + nombre;}
        set{ nombre = value.ToUpper();}
      }

      public int AñoDeCreacion{get;set;}

      public string Pais { get; set; }
      public string Ciudad { get; set; }
      
      public TiposEscuela TipoEscuela{get;set;}

      public Escuela(string nombre, int año) =>(Nombre,AñoDeCreacion) = (nombre,año);

      public override string ToString()
      {
        return $"Nombre: {Nombre}, Tipo: {TipoEscuela} \n Pais: {Pais}, Ciudad: {Ciudad}";
      }
    }
}

TiposEscuela.cs

namespace CoreEscuela.Entidades
{

    public enum TiposEscuela
    {
        Primaria,
        Secundaria ,
        PreEscolar
    }
}

Program.cs

using System;
using CoreEscuela.Entidades;

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            var escuela = new Escuela("Escuela SCJ",2010);
            escuela.Pais = "Chile";
            escuela.Ciudad="Santiago";
            escuela.TipoEscuela = TiposEscuela.Primaria;
            Console.WriteLine(escuela);
        }
    }
}

Por si el teclado no ayuda, el atajo de la barra invertida es ALT+92 = \

Me surgió una duda, porque a la hora de hacer override a ToString(), a la hora de imprimir el objeto escuela a secas se imprime eso, no deberia estar en el Constructor para que se imprima?

Muy buen ejemplo de herencia, aun que falta un poco para llegar a ello.

En C# todo es un objeto.

Mi forma de sobrescribir el método toString por si a alguien le es útil

        public override string ToString()
        {   
            string _string = "";
            foreach(System.Reflection.PropertyInfo property in this.GetType().GetProperties())
            {
                _string+= property.Name +": " + property.GetValue(this,null)+"\n";
            }
            return _string;
        }

No ma nunca he utilizado el enum de esa manera tan básica, ayuda bastante.

Buen comienzo de proyecto

En C# todo es un objeto y por ello todo hereda de la clase Object, es así como todos los objetos tienen el método ToString.

otra forma de representar el toString:

public override string ToString() => $"Nombre{Nombre}, Tipo{tipoEscuela} \nPais{Pais}, Ciudad{ciudad}";

public override string ToString()
    {
      return $"Nombre: {Nombre}, Pais: {Pais}, Tipo de Escuela: {TipoEscuela}";
    }

https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/builtin-types/enum

Que buen video

Excelente clase

Cual seria la diferencia entre usar un override para asignar valores a un objeto y mostrarlos en pantalla a hacer lo mismo pero usando mas bien un metodo que me imprima en pantalla lo que deseo? o seria mas un tema de gustos?

Me sale un error en esta parte del codigo:

El resto del codigo

Ejemplo de implementacion de String

<  public override string ToString()
        {
            return base.ToString();
        }>

Mi código comprobado y comentado del archivo TiposEscuelas.cs

namespace CoreEscuela.Entidades
{
    /*Utilizamos la enumeración para poder crear un tipo persoanlizado de objeto */
    public enum TiposEscuela //Definimos el tipo, en este caso enum para enumerar el valor de nuestras variables
    {
        /*Definimos el valor de acuerdo a la enumeración*/
        Primaria,
        Secundaria,
        PreEscolar

        /*Si no se asigna un valor numerico se obvia por un valor ascendente y ordenado de numeración */

        /*En su defecto podemos asignar el valor manualmente
        Primaria = 2,
        Secundaria = 3,
        PreEscolar =1

         */

    }
}```

Mi código comprobado y comentado del archivo Escuela.cs

namespace CoreEscuela.Entidades
{
    class Escuela
    {   
        string nombre;
        public string Nombre{ 
            //definimos manualmente el metodo get y set
            get {return "Copia: "+nombre; }  //el método get se utiliza para retornar (consultar) el valor almacenado en el atributo (en este caso el nombre)
            set {nombre = value.ToUpper();}  //el método set se utiliza para asignar el valor  en el atributo (en este caso el nombre) posteriormente con la funcion ToUpper() tranformamos el string a letras mayusculas
        }

        public int AñoDeCreación {get; set;} //La manera corta para definir el método get y set

        public string País { get; set; }
        public string Ciudad { get; set; }

        public  TiposEscuela TipoEscuela{get; set;}

        //Constructor   Define los valores iniciales que necesita nuestra intancia para funcionar correctamente
        /* 
        public Escuela(string nombre, int año){
            this.nombre = nombre; //This para indicar que hablamos de la variable interna
            AñoDeCreación = año;

        }
        */
        //Manera corta de crear el Constructor    
        public Escuela(string nombre, int año) => (Nombre, AñoDeCreación) = (nombre, año);

        /*Sobrescrimir métodos */
        public override string ToString(){
            return $"Nombre: {Nombre} Tipo: {TipoEscuela} \nPaís: {País}, Ciudad: {Ciudad}"; //El signo dolar antes de la cadena de texto nos permite utilizar variables especificadas
        }
    }
}

como se llama esa opciòn que se utiliza en la siguiente linea de còdigo
escuela.TipoEscuela = TiposEscuela.prescolar

donde llamo al metodo que contiene la clase escuela y la iguala al tipo de dato o nombre del enum creada en otra casa para llamar una de sus propiedades?

Entonces al hacer un override sobre un string tambien se puede hacer sobre un entero un flotante?
Como lo entiendo es que si no quiero imprimir cada uno de los atributos, puedo mandar a llamar al objeto por mediod e un overide??

Excelente!

Tambien se pueden usar variables dentro de los strings de esta manera

return("{0},{1},{2}",valor0,valor1,valor2);

chutas …

 public override string ToString()
        {
            return $"Nombre: {Nombre}, Tipo: {TipoEscuela} \n Pais: {Pais}, Ciudad: {Ciudad}, Año: {AñoDeCreacion}" ;
        }```

Buenas clases

Gracias por los aportes

Una enumeración puede tomar como valor enteros, por ejemplo si se tiene:
secundaria, preparatoria, universidad. Cada una es un número:
0 1 2
Comenzando desde el 0.

Hola porfavor necesito su ayuda !!!

Lo hice yo por mi cuenta, lo copie 100% al profesor y dsp lo copie de un alumno que puso su codigo y asi y todo me sigue dando error el codigo a este punto y no lo puedo correr…

Muy interesante no sabia eso de la tuplas

namespace CoreEscuela.Entidades
{
class Escuela
{
  string nombre;
  public string Nombre
  {
      get{return nombre;}
      set{ nombre=value;}
  }
  public int añoDeCreacion{get; set;}
  public string pais { get; set; }
  public string Ciudad  { get; set; }
  public TiposEscuela TipoEscuela  { get; set; }
  public Escuela(string nombre,int año)=>(Nombre,añoDeCreacion)=(nombre,año);
  
  public override string  ToString()
  {
      return $"Nombre{Nombre}, Tipo{TipoEscuela} \n Pais{pais}, Ciudad{Ciudad}";
  }
}

}```

listos!

namespace CoreEscuela.Entidades
{
    public class Escuela 
    {
        public string Nombre { get; set; }
        public string Direccion { get; set; }
        public string Pais { get; set; }
        public string Ciudad { get; set; }
        public int AñoCreacion { get; set; }
        public TiposEscuela tipoescula { get; set; }

        public Escuela (string nombre, string direccion, string pais, string ciudad, int añoCreacion, TiposEscuela tipoEscula) => 
        (Nombre, Direccion, Pais, Ciudad, AñoCreacion, tipoescula) = 
        (nombre, direccion, pais, ciudad, añoCreacion, tipoEscula);

        public override string ToString() 
        {
            return "Nombre: " + Nombre + "\n" +
                   "Pais: " + Pais + "\n" +
                   "Ciudad: " + Ciudad + "\n" +
                   "Direccin: " + Direccion + "\n" +
                   "Año de creación: " + AñoCreacion + "\n" +
                   "Tipo de escuela: " + TiposEscuela.Secundaria;
        }
    }
}

namespace CoreEscuela.Entidades
{
    public enum TiposEscuela
    {
        Primaria,
        Secundaria,
        Preescolar
    }
}

using System;
using CoreEscuela.Entidades;

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            var Escuela = new Escuela("Iesfa", "Colombia", "Cartagena", "Cra. 8 #38 - 127", 1999, TiposEscuela.Secundaria);
            Console.WriteLine(Escuela);
        }
    }
}

amespace CorEscuela.Entidades
{
    public enum TiposEscuela
    {
       Primaria, Secundaria, Preescolar 
    }
}```

namespace CorEscuela.Entidades
{
    class Escuela
    {
        //encapsulamiento
        string nombreEscuela;
        public string NombreEscuela{
            get{return nombreEscuela;} 
            set{nombreEscuela = value;}
        }

        //opcion 2 de encapsulamiento
        public int añoCreacion{get;set;}
        //atajo de vsc "prop" crear rapidamente los metodos
        public string Pais { get; set; }
        public string Ciudad { get; set; }

        public TiposEscuela TipoEscuela{get; set; }

        public override string ToString()
        {
            return $"NombreEscuela: {NombreEscuela}, Tipo: {TipoEscuela}, \n Pais: {Pais} , Ciudad: {Ciudad} ";
        }

        //la palabra reservada "this" hace referencia al nombre de la variable dentro del mismo metodo
       /*  public Escuela(string nombreEscuela, int añoCreacion)
        {
            this.nombreEscuela = nombreEscuela;
            this.añoCreacion = añoCreacion;
        }*/

        //metodo corto de un constructor igualacion por tuplas

        public Escuela(string nombre, int año) => (NombreEscuela, añoCreacion) = (nombreEscuela, añoCreacion);



    }
}```

using System;
using CorEscuela.Entidades;

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Creacion de un Constructor
        
            var escuela = new Escuela("Platzi Academy", 2012);
            escuela.NombreEscuela="Platzi Academy"; 
            escuela.Pais="Colombia";
            escuela.Ciudad="Bogota";  
            escuela.TipoEscuela = TiposEscuela.Primaria;         
            Console.WriteLine(escuela);
            
        }
    }
}

¿override implica polimorfismo?

Explicacion del uso de override

me aparece _ Stack overflow. al ejecutar en ves del texto

using System;
using CoreEscuela.Entidades;

namespace Etapa1
{
class Program
{
static void Main(string[] args)
{
var escuela = new Escuela(“Platzi Academy”, 2012);
escuela.Pais = “Perú”;
escuela.Ciudad = “Lima”;
escuela.TipoEscuela= TiposEscuela.Primaria;
Console.WriteLine(escuela);

Bastante entreverada la clase

Perfecto

Super interesante eso hace que crear nuevas escuelas sea mas facil y que se reutilice el codigo creado

El signo dolar o pesos permite usar variables...

El signo dolar o pesos permite usar variables...

El signo dolar o pesos permite usar variables...

El signo dolar o pesos permite usar variables...

El signo dolar o pesos permite usar variables...

El signo dolar o pesos permite usar variables...

El signo dolar o pesos permite usar variables...

Muy buena clase.

Muy bien aclarando mas conceptos.

Muy interesante!

Muy bien es una excelente forma de aprender por proeyctos

Excelente clase.

Super, Entendí mucho mejor !!!

Genial!

muy bien

Muy buen curso excelente, aprendí cosas que no conocia.

Cada clase o estructura en C # hereda implícitamente la clase Object . Por lo tanto, cada objeto en C # obtiene el método ToString.

Excelente clase para el override de los métodos

Me gusto mucho la explicación del maestro en cuanto a sobre escribir ToString.

Muy bueno, Sabia ciertas cosas, pero poco a poco.

Ya hemos creado la estructura básica de la escuela, ahora vamos a explorar como se muestra la información en pantalla, además crearemos una nueva entidad llamada “TiposEscuela” que será de tipo enum.

Cuando imprimimos en consola la variable de nuestro objeto escuela vemos que por defecto nos describe el nombre completo del objeto, en este caso es el namespace donde se encuentra más el nombre de la clase. Para modificar esto podemos sobrescribir el método “ToString” con la palabra clave override.

-“Lo hice intencionalmente” JAJA

¿los enumerables simpre son string o pueden ser objetos? en caso de que puedan ser objetos estos ¿deben ser siempre del mismo tipo o pueden ser distintos tipos de objetos?

Copie la forma de hacer de Alexis, esa forma se me hace más elegante.

Por fin entendí lo que es polimorfismo sin que lo mencionara JAJAJAJA

Muy buen apunte el override de ToString

gracias

Espero les pueda ayudar, como a mí, el siguiente enlace:

https://docs.microsoft.com/es-mx/learn/modules/csharp-write-first/3-how-it-works

Otra forma sobrescribir el metodo ToString es:

Para hacer uso de el StringBuilder tenemos que utilizar el namespace System.Text;

Al profesor se le olvido asignar el valor de TipoEscuela en el constructor, y así el tipo enum siempre imprimirá la primera posición, este caso no se nota porque el profesor eligió la primer, pero el constructor debería estar así:

public School(string name, int year, SchoolTypes type, string country="")
        {
            (Name, InaugurationYear) = (name, year);
            Country = country;
            SchoolType = type;
        }

Para escribir la diagonal invertida en Windows 10 pueden usar “ALT”+92

Un tipo de enumeración (o tipo enum ) es un tipo de valor definido por un conjunto de constantes.

Buenas, tengo una duda, porque al hacer el override del metodo ToString() dentro de la clase escuela en Escuela.cs y despues mostrar con el Console.WriteLine(escuela); en el Program.cs automaticamente se muestra lo que hace la funcion ToString? No deberia ser ser asi?: Console.WriteLine(escuela.ToString()); En si mi duda es por que se ejecuta automaticamente el metodo ToString de la clase escuela al hacerle Console.WriteLine en el codigo program.cs

excelente primer acercamiento al override de métodos.

el metodo ToUpper no me funcionó en el set, pero lo puse en el get y si me funcionó, por qué ?