Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Creación de parámetros

13/32
Recursos

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.

Aportes 69

Preguntas 16

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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

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

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?

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

Algunas correcciones:

  • El caracter \n signifca fin de linea para linux y windows
  • El caracter ‘’ se llama backslash (contraslash)

Hizo falta agregar TipoEscuela = tipos, o estoy en un error y me falto algo a mi? 😃

Saludos.

🤯

Muy bien la clase

😎

Es curioso que al pasar los parámetros opcionales del objeto, se use el símbolo de ‘:’ (dos puntos) para asignar el valor, en comparación a como se hace dentro del método que utilizan el ‘=’ (igual) para ciudad y país.

Eres un profesor genial y lo explicas con suma claridad y no te dejas ningún aspecto sin repasar. Muy contento!

El hecho de colocar un \ frente a una comilla se conoce como escapar la comilla.

Firma: La firma de un metodo es definido por sus parametros, se pueden sobrescribir lo que uno quiera siempre y cuando tengan diferentes parametros.

no usé el símbolo + en esta clase, pero es igual que en javascript, a diferencia de php que usamos un punto 😃

Me gustan las clases de c#

Les dejo mi resumen de la Etapa 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 dos parametros
            para el constructor (nombre, año de creacion, tipos de escuela con base en una enumeracion y parametros opcionales como pais y ciudad)*/
            var escuela = new Escuela("Platzi Academy", 2012, TiposEscuela.Primaria, ciudad:"Bogotá", pais:"Colombia");
            // escuela.Pais = "Colombia"; //Definimos el parametro del país de la escuela
            // escuela.Ciudad = "Bogota"; //Definimos el parametro de la ciudad de la escuela
            // escuela.TipoEscuela = TiposEscuela.Primaria; //Aqui le decimos al programa que el tipo de escuela primaria se guarde en el parametro del tipo de escuela de la escuela
            Console.WriteLine(escuela); //Nos muestra la información de escuela por función ToString
        }
    }
}

Escuela.cs

namespace CoreEscuela.Entidades
{
    class Escuela 
    {
        //Encapsular sirve para proteger el acceso directo a los datos
        string nombre; //Los atributos o campos en C# están acostumbradas a escribirse en minusculas

        /*En cambio las propiedades inician con una mayuscula
        Las propiedades se construyen asi:

        [nivel de acceso] [tipo de dato] [Nombre de la propiedad]
        {
          get { return [lo que quieres que devuelva];}
          set { [el atributo o campo que quieres que guarde el valor, es decir el encapsulado] = value; <-- value quiere decir valor que me han asignado }
        }
        */
        public string Nombre 
        {
          get { return "Copia: " + nombre; }
          set { nombre = value.ToUpper(); }
        }

        /* Hay otra manera de crear una propiedad con un shortcut:
            En lugar de escribir el campo y además la propiedad con el shortcut
            public [tipo de dato] NombreDeLaPropiedad {get; set;}
            hace exactamente lo mismo
         */
        public int AñoDeCreación { get; set; }

        public string Pais { get; set; }  

        public string Ciudad { get; set; }

        public TiposEscuela TipoEscuela{get; set;}

        /*
        Constructor de escuela convencional:
        Para poder ser un constructor debemos pasarle parametros 
        
        public Escuela(string nombre, int año)
        {
          this.nombre = nombre;
          AñoDeCreación = año;
        }
        */

        //Otra manera de crear el constructor es la siguiente y es llamada igualacion por tuplas: 
        public Escuela(string nombre, int año) => (Nombre, AñoDeCreación) = (nombre, año);

        /*Firma del metodo:
        Podemos crear tantos constructores como deseemos con el mismo nombre mientras
        reciba parametros diferentes lo mismo aplica para metodos*/
        public Escuela(string nombre, int año, TiposEscuela tipos, string pais = "", string ciudad="")
        {
          (Nombre, AñoDeCreación) = (nombre, año);
          Pais = pais;
          Ciudad = ciudad;
        }

        /*Sobreescribir ToString con override */
        public override string ToString()
        {
          /*El signo dolar antes de la cadena de texto nos permite utilizar variables especificadas */
          return $"Nombre: {Nombre}, Tipo: {TipoEscuela} \n País: {Pais}, Ciudad: {Ciudad}";
          /*Datos enriquecedores:
          1. Para poder imprimir comillas dentro de una instruccion con comillas podemos usar \" AlgunaPalabraChevere \" 
          2. Otra forma de usar \n (hacer un salto de linea) es usando {System.Environment.NewLine}
          Esto es util cuando programamos para otros SO ya que no es el mismo caracter */
        }
    }

}

TiposEscuela.cs

namespace CoreEscuela.Entidades
{   
      /*Utilizamos la enumeración para poder
      crear un tipo personalizado de objeto */
      public enum TiposEscuela
      {
          //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 */
      }
}

las clases son muy completas, estoy disfrutando mucho de este curso.

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.

Chicos les comparto mi cambio, dado que enum te genera automaticamente un index de cada valor podes ponerle el numero en vez del nombre de la variable .

<class Program
    {
        static void Main(string[] args)
        {
            var escuela = new Escuela("Plazo Academy",2012);
            escuela.Pais = "Colombia";
            escuela.Ciudad = "Bogota";
            escuela.TipoEscuela = 0;


            Console.WriteLine(escuela);
        }
    }>

para poder agrupar código, por ejemplo agrupara los iferentes constructores que hemos creado

#region Nombre
//Aquí va el código que queremos agrupar
#endregion

El metodo toString no me reconoce la propiedad ciudad saben a quepueda deberse?

namespace CoreEscuela.Entidades
{
    class Escuela
    {
        public string Nombre { get; set; }
        public int AñoDeCreacion { get; set; }
        public string Pais { get; set; }
        public string Ciudad { get; set; }

        public TiposEscuela TipoEscuela { get; set; }

        public Escuela(string nom, int año)
        {
            this.Nombre = nom;
            this.AñoDeCreacion = año;
        }


        public Escuela(string nom, int año, 
                        TiposEscuela tipos, string pais = "",   
                        string ciudad = "")
        {
            Nombre = nom;
            AñoDeCreacion = año;
            Pais = pais;
            
        }

        public  override string ToString()
        {
            return $"Escuela: {Nombre} del tipo {TipoEscuela}, fundada en {AñoDeCreacion} en {Pais} en la ciudad de {Ciudad}";
        }
    }
}

Utilicemos validaciones para imprimir solo los campos que tengan valores. Una manera básica sería algo así:

public override string ToString()
    {
        string returnValue = "";
        if (name.Length > 0)
        {
            returnValue = $"Name: {name}";
        }

        if (type.ToString().Length > 0)
        {
            returnValue += $", Type: {type}";
        }

        if (country.Length > 0)
        {
            returnValue += $", Country: {country}";
        }

        if (city.Length > 0)
        {
            returnValue += $", City: {city}";
        }

        return returnValue + "\n";
    }

En el siguiente constructor debería añadirse **TipoEscuela = tipo; **

   public Escuela(string nombre,int año, 
                  TipoEscuela tipo, 
                  string pais="",string ciudad ="")
   {
       (Nombre,AñoDeCreacion)=(nombre,año);         
       TipoEscuela = tipo;  
       Pais = pais;
       Ciudad = ciudad;
   }

Así, cuando desde Program envíe PreEscolar, Primaria, etc., se visualice:
Nombre: “Copy PLATZI SCHOOL”,
Tipo: PreEscolar
Pais: Ecuador, Ciudad: Quito

Caso contrario -independientemente del tipo de escuela que se escoja- se mostrará siempre Primaria.

Muy interesante para crear parametros mandatorios

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.

vamos muy Bien, Gracias 😃

<h3>Parámetros de un método</h3>
  • Al estar los parámetros con valores por defecto, significa que son parámetros prescindibles u opcionales.
  • Los parámetros opcionales no requieren estar en el mismo orden, pueden ser inicializados en cualquier orden al momento de instanciarlos.
<h3>Método constructor</h3>
  • Se pueden agregar tanto métodos constructores se necesite según la necesitad del programa.

Muy buena explicación de la clase es excelente

Ejemplo de codigo de ejemplo para pasar parametros opcionales

<public void pasarParametros(String uno="")
        {

        }>

En este caso en este capitulo considero que la clave es saber cuando utilizar this
this: Esta palabra clave se refiere a la instancia actual de la clase y también se usa como modificador del primer parámetro de un método de extensión.

Ejemplo de codigo

<public class Employee
{
    private string alias;
    private string name;

    public Employee(string name, string alias)
    {
        // Use this to qualify the members of the class 
        // instead of the constructor parameters.
        this.name = name;
        this.alias = alias;
    }
}>

Excelente, Buenísima explicación!
Ojala así fueran todos los que dan clases en la U.

C# es algo diferente a java, me confunde un poco

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.

buenas clases

genial!

Excelente el profesor, muy bien explicado todo lo visto hasta el momento.

muy interesante la verdad ya estoy comprendiendo mejor como funciona

Que bien que sigamos avanzando

Bien explicado como manejar los constructores y lo del método toString!!

Muy buenos datos

Hola chicos disculpen yo de nuevo. Me tira Stacl overflow y no se por que …

using System;
using CoreEscuela.Entidades;

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
        
        
            var escuela = new Escuela("Platzi Academy", 2012, TiposEscuela.PreEscolar,
                            ciudad: " Bogota " , pais: "Colombia"
                        );
            

            System.Console.WriteLine(escuela);
        }
    }
}

namespace CoreEscuela.Entidades//CoreEscuela es el espacio de nombre mayor y entidades es este en espesifico
{
    class Escuela
    {

        string nombre;
        public string Nombre 
        {   
            get{return nombre;} 
            set{Nombre = value.ToUpper();} 
        }

        public string Ciudad { get; set; }


        public string Pais { get; set; }


        public int AnioDeCreacion { get; set; }


        public TiposEscuela TipoEscuela { get; set; }



        public Escuela(string nombre, int anio)
        {
            this.nombre = nombre;//this.nombre es el nombre de la clase que es igual al nombre de atributo
            AnioDeCreacion = anio;

        }

        // public Escuela(string nombre, int anio) =>(Nombre, AnioDeCreacion) = (nombre, anio);


        public Escuela(string nombre, int anio, 
                TiposEscuela tipo, 
                string pais = "", string ciudad = "")
        {
            (Nombre, AnioDeCreacion) = (nombre, anio); /* asignacion por medio de tuplas*/
            Pais = pais;
            Ciudad = ciudad;

        }


        public override string ToString() //Este metodo es para poder imprimir completamente la escuela y no poner escuela.something
        {
        return $"Nombre:{Nombre} Tipo: {TipoEscuela} Pais: {Pais}  Ciudad: {Ciudad}";
        }

        






    }
}

Muy didactica y simple la clase. Tiene unas diferencias curiosas C# frente a Java, que lo hacen más simple para programar en menos tiempo…

Personalmente, me confunde el hecho de que las propiedades y metodos comiencen con mayúscula.

" "

Para mayor ampliación del por qué se utiliza el back slash, platzi tiene el curso de expresiones regulares. Si no lo han hecho, vayan a hacerlo, es una súper herramienta para todos los programadores. Un adelanto, el back slash sirve para escapar todos los caracteres especiales que no son alfanuméricos utilizados en programación como las comillas, y que puedan ser visualizados en pantalla.

\" sirve para dibujar literalmente una comillas como carácter especial y sin romper la estructura lógica del programa

Multiples constructores, su ejecución estará determinada por como lo implementamos en "programa"

Excelente clase! :3

Super, C# es muy interesante

Esto es lo mismo que polimorfismo?

Excelente clase jajaja super 😃 aprendí demasiado 😃

Mucha propiedad en el tema.

Interesante

Este profesor es un crack

Me esta gustando mucho C# excelente explicación del maestro

Me parece que faltó declarar TipoEscuela = tipo; dentro del último constructor

Este tipo enseña muy bien

Excelente Maestro!
Todo bien explicado 😃

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.

en el caso que quicera que del parámetro añodefundacion el cual es int fuese opcional no puedo ser 0 entonces trato de pasarlo como null pero me da error por que .dice algo como dato no nulleable así lo traduzco jejej

El uso de tuplas esta buenisimo!

public override string ToString()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            
            sb.AppendLine($"Nombre: {Nombre}");
            sb.AppendLine($"AnioFundacion: {AnioFundacion}");            
            sb.AppendLine($"Director: {Director}");
            sb.AppendLine($"Direccion: {Direccion}");            
            sb.AppendLine($"Estado: {Estado}");
            sb.AppendLine($"Pais: {Pais}");

            return sb.ToString();
        }```

Que genial curso ♥

Resumen de la clase.

<code>
 var escuela=new Escuela("Platzi Academy",2013,TiposEscuela.Primaria,"Colombia","bogota");
        

método constructor estructuras:

NivelDeAcceso NombreMetodo (TipodeVariable NombresDeVariable)
{
//Si se tiene mas de una variable o parametro se separan en comas
//parametro opcional seria: TipoVariable nombre = " " asignando un valor por defecto

}

string schoolNameVar;
        public string schoolName {get{return "Copy of: "+schoolNameVar;}set{schoolNameVar=value.ToUpper();}} 
//para poner en mayúsculas el valor introducido en la propiedad.