Constructores con parámetros opcionales en C#
Contenido del curso
Alexander Armúa Abregu
Cristhian Camilo Perez Veloza
ALEXANDER VASQUEZ MENDOZA
Carlos Orjuela
Marcel Solera
Alvaro Eduardo Garzón Pira
Aufsten Aufsten
Carlos Andres Dominguez Dominguez
Wellington Gabriel Muñoz Vargas
Luis Rodrigo Alvarez Herrera
Daniel Meza
Facundo Castro
Eddy Caceres
Dennis Paul Franklin Pineda Licona
J. Sebastián Botello. H.
Andrés Islas
Luis Edher Rodríguez Santiago
Andrés Islas
Erick Fernando Guzmán Valerio
Rosember Perez
Rosember Perez
Cristian Camilo Berrio Montoya
Bernardo Munz
Miguel Alexander Vásquez Ortega
Ricardo Londoño
Joaquin cruz
Oscar JG
Daniel Molina
Rafael Pardo Rodriguez
Pablo Juarez Castillo
Ana Lima
Carlos Junior Guzman Rodriguez
Ariel Ayala
Pablo Juarez Castillo
Cristian Palta
En mi caso, para utilizar el System.Enviroment.NewLine, lo guarde en una variable así no repito toda esa cadena constantemente.
public override string ToString() { string newLine = System.Environment.NewLine; return $"Nombre: \t\"{Nombre}\"{newLine}Tipo: \t\t\"{TipoEscuela}\"{newLine}Pais: \t\t\"{Pais}\"{newLine}Ciudad: \t\"{Ciudad}\""; }
bastante útil
Práctico
Personalmente las enumeraciones siempre las manejo en un solo archivo. Realmente no se si es una buena practica, pero me párese mas organizado:
Eje: En un archivo Tipos.cs, tengo el siguiente código
namespace CoreEscuela.Entidades { public enum TiposEscuela { Primaria, Secundaria, PreEscolar } public enum TiposCiudad { Bogota, Medellin, Tunja, Manizales, Otro } public enum TiposPais { Colombia, Otro } }
excelente idea, es mejor y ahi uno puede acceder de una a todas las enum, lo copiare.
¡Hola!
En general, es una buena práctica agrupar tipos relacionados en un solo archivo, para que sea más fácil de encontrar y mantener el código. Sin embargo, si en un archivo hay muchos tipos distintos, puede hacer que el archivo sea difícil de leer y comprender, especialmente si hay muchos miembros en cada tipo.
Si se trata de enumeraciones relacionadas a un mismo tema o concepto, como por ejemplo tipos de escuelas o países, agruparlas en el mismo archivo es una buena práctica, ya que hace que sea más fácil de encontrar y mantener el código relacionado. Sin embargo, si las enumeraciones son de diferentes conceptos y no están relacionadas entre sí, puede ser más fácil de entender si se agrupan en archivos separados.
Mi código comentado de este ejemplo, Espero a alguien le ayude 😃
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); /*Esta ↓ es otra forma de crear al constructor, este método recibe 3 parametros obligatorios (los 3 primeros) Y recibe 2 parametros opcionales los cuales les damos un valor inicial, en este caso estan vacíos Posteriormente asignamos los valores, se puede hacer de manera general o individual como se muestra */ public Escuela(string nombre, int año, TiposEscuela tipo, string pais="", string ciudad="" ){ (Nombre, AñoDeCreación) = (nombre, año); //podemos asignar de esta manera ///o de forma individual ↓ País = pais; Ciudad = ciudad; } /*Sobrescrimir métodos */ public override string ToString(){ string newline = System.Environment.NewLine; //Hace un salto de línea al igual que \n return $"Nombre: {Nombre} \nTipo: \"{TipoEscuela}\" {newline}País: {País}, Ciudad: {Ciudad}"; //El signo dolar antes de la cadena de texto nos permite utilizar variables especificadas /*Para poder utilizar caracteres como comillas ↑ se utiliza la diagonal → \ y el caracter: por ejemplo \" */ } } }
TipposEscuela.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 */ } }
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) { /*creamos una nueva instancia de la clase Escuela, recibe 5 parametros para el constructor (nombre, año de creación, tipo, pais, ciudad) Los 3 primeros son obligatorios, los dos posteriores son opcionales ya que tienen un valor inicial Para asignar un valor a los parametros opcionales se puede seguir el orden o especificar a que parametro queremos afectar de esta manera → nombreParametro:valor */ var escuela = new Escuela("Platzi Academy", 2012, TiposEscuela.Primaria, ciudad:"Toluca", pais:"México"); /*Asignación individual de valores sin parametros 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 /* 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*/ } } }
increible resumen de la clase lo tomare como ejemplo para todos mis futuros aprendizajes
La Tupla fue introducida en .NET Framework 4.0. Una tupla es una estructura de datos que contiene una secuencia de elementos de diferentes tipos de datos. Se puede usar donde desea tener una estructura de datos para contener un objeto con propiedades, pero no desea crear un tipo separado para él.
esto es la sobrecarga de metodos?
Sí, fue una sobrecarga de constructores
Hice el curso de introduccion a c# de ricardo celis, pero aca estoy, haciendo todo de vuelta se podria pensar que es una perdida de tiempo, pero estos pequeños detalles como el system.environment.newline son esas cositas que vale la pena invertir tiempo, ademas de que sirve de practica. Si estas leyendo esto y haces lo mismo que yo, opino que vas en buen camino
Algunas correcciones:
Dejo ejemplos de distintas maneras de concatenación "+", referencia de argumento e interpolación de cadenas.
public override string ToString() { return "Nombre: " + Nombre + System.Environment.NewLine + "Año Creación: " + AñoCreación; }
public override string ToString() { return string.Format("Nombre: {0}{1} Año Creación: {2}{1}", Nombre, System.Environment.NewLine, AñoCreación); }
public override string ToString() { return $"Nombre: {Nombre} {System.Environment.NewLine}Año Creación: {AñoCreación} "; }
Firma: La firma de un metodo es definido por sus parametros, se pueden sobrescribir lo que uno quiera siempre y cuando tengan diferentes parametros.
Hizo falta agregar TipoEscuela = tipos, o estoy en un error y me falto algo a mi? :)
Saludos.
Supongo que no debido a que si lo corres no marca error y si imprime el valor.
Muchas gracias. :)
De que sirve crear 2 constructores?
Puedes crear varios constructores para variar la forma en la que instancias la clase
Un ejemplo de usar dos constructores, uno donde le indicas que estrategia usar y otra donde tiene una estrategia predeterminada
public class Bodega { public IAlmacenamiento _strategia; public Bodega(IAlmacenamiento strategia){ _strategia = strategia; } public Bodega(){ _strategia = new AlmacenImpl(); } }
Algo importante a tener en cuenta, con los enums, son sus valores por defecto y como evitar los efectos secundarios…
Creo que nadie se dio cuenta, en el overload del método constructor de la clase escuela, no asignamos el argumento tipo a su parámetro TipoEscuela. y cuando ejecutamos la aplicación sucede el efecto secundario, imprime en pantalla que el tipo es Primaria cuando realmente si pusiéramos Secundaria como el primero de la lista de los enums nos imprimiría este en ves del que le pasamos como argumento a la creación de nuestro objeto. los invito a probarlo. dotnet-fiddle-example side-effects-code-project Esto es importante tenerlo en cuenta, para darle un mejor uso a los enums y evitar los efectos secundarios.
Asi es como resolvi tu commentario por si a laguien le sirve para atender el mensaje anterior.
namespace CoreSchoole.Entities { class School { string name; public string Name{ get { return "Copy:" + name; } set { name = value.ToUpper(); } } public int BuildYear {get; set; } public string Country { get; set; } public string City { get; set; } public SchoolTypes SchoolType { get; set; } // public School(string name, int year) => (Name, BuildYear)= (name, year); public School(string name, int year, SchoolTypes type, //SchoolTypes it the type of value for that value. like string for country. string country="", string city="" ) { (Name, BuildYear, SchoolType)= (name, year, type); Country = country; City = city; } public override string ToString() { return $" Name: {Name}\n Built: {BuildYear}\n City: {City}\n Country: {Country}\n Type: {SchoolType}"; } } }```
Si me percate de que faltaba ese dato, lo deje pasar y experimente con eso hasta darme cuenta de que el enum no cambiaba, entonces le asigne su variable en el construptor y listo, pero gracias por la info.
He aprendido:
Sobre la sobre carga de metodos --> con el segundo Constructor.
Como crear parametros opcionales . Como usar la coma ( para separar listas) y el punto y coma (para finalizar una
instrucción)
el uso del simbolo $ para con ayuda de los {} pueda usar de mejor forma la concatenación de cadenas.
Hola comunidad, me encuentro realizando este curso ya unos años de haber salido y no utilizo las mismas versiones, por lo cual tengo un problema.
public string País { get; set; }
pongo de esta forma mi string pero me marca error en todos mis strings. Aunque le ponga un valor como el siguiente.
public string Pais = "México";
me dice al momento de correr el dotnet run que
no se aceptan strinf con valores null
Si alguien me puede ayudar, se los agradecería
Me pasa lo mismo me marca error aún copiándolo literal del profesor... Ojalá conteste alguien.
los parámetros opcionales deben estar siempre al final por cierto.
Hola Daniel, no necesariamente, pueden estar al principio o en el medio del llamado a los parametros, PERO, recuerda que siempre debe estar referenciada (variable1 = valor1).
De lo contrario, todos los valores deben estar en orden
¿Que son tuplas?
Una Tupla es una estructura de datos que nos permite almacenar hasta 8 valores diferentes, de diferentes tipos, que están relacionados de algún modo y usando una sola variable.
Es un concepto muy sencillo que posibilita el manejo de manera conjunta de unos pocos datos relacionados sin necesidad de estar utilizando matrices (poco cohesionadas), colecciones (demasiado especializadas para esto) o creando nuestras propias clases (algo tedioso y que debería ser innecesario para cosas sencillas).
++III. ETAPA 1 – Creando la escuela++
A. CREACIÓN DE LA ESTRUCTURA BÁSICA DE LA ESCUELA Dentro de nuestro proyecto crearemos una carpeta llamada “Entidades” donde iremos guardando las entidades del proyecto como un Curso, una Escuela, etc. Dentro de cada archivo .cs añadiremos un espacio de nombres o namespace, este nos sirve para facilitar el encontrar objetos en nuestro proyecto. En la programación orientada a objetos los datos de una clase pueden ser protegidos del acceso directo o público, esto es el Encapsulamiento. Dentro de los métodos por los cuales va a acceder a la información se puede agregar cualquier tipo de lógica. Para que se pueda crear un objeto se hace uso de la palabra reservada new, esto invoca al método constructor de la clase.
B. USO DE NUMERACIONES Y EL MÉTODO TOSTRING 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. 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.
C. CREACIÓN DE PARÁMETROS Vamos a profundizar en cómo crear una lista de parámetros y la manera en que podemos hacer que esos parámetros sean opcionales. Para los parámetros opcionales basta con asignarle un valor por defecto en el método. Si queremos acceder a la variable de una clase dentro de la misma podemos usar la palabra this.
Parámetros de un método
Método constructor
Que bien que sigamos avanzando
buenas clases
