A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Uso de numeraciones y el m茅todo ToString

12/32
Recursos

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 鈥淭iposEscuela鈥 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 鈥淭oString鈥 con la palabra clave override.

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.

Aportes 80

Preguntas 11

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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*/
        }
    }
}

Que mas Cursos da El mismo profesor ?

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?

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 = 鈥渧alor 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(鈥渢exto 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 enumeracin 
    {
       Valor1 , 
        Valor2, 
        Valor3
    }

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

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}";
        }

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

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.

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);
        }
    }
}

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

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();
        }>

Si se quiere acceder al m茅todo del 鈥減adre鈥 se puede usar la palabra clave base, por ejemplo:

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

en este caso utilzo la funcionalidad 鈥減or defecto鈥 y la extiendo, imagino que esto lo vamos a ver en detalle mas adelante.

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(鈥淧latzi Academy鈥, 2012);
escuela.Pais = 鈥淧er煤鈥;
escuela.Ciudad = 鈥淟ima鈥;
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 鈥淭iposEscuela鈥 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 鈥淭oString鈥 con la palabra clave override.

-鈥淟o 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

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;
        }

Otra forma sobrescribir el metodo ToString es:

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

que es plus

Para escribir la diagonal invertida en Windows 10 pueden usar 鈥淎LT鈥+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茅 ?