none
¿Cual es la diferencia entre inicializar propiedades en el constructor o asignarles un valor de inicio en la declaracion de la clase?

    Pregunta

  • Buenos Días:

      Aprendiendo conceptos básicos de la POO en C# me encuentro en esta vida que llevo con la siguiente duda:

    ¿Cual es la diferencia entre inicializar propiedades en el constructor o asignarles un valor de inicio en la declaracion de la clase? Ejemplo:

    Si tengo una clase declarada de esta forma simple:

    class Superman
    {
        public String traje="excentrico";
        private String amor="Luisa Lane";
    }   // vemos en este caso que tengo dos propiedades a los cuales les asigne un valor de inicio a su propiedad.

    Podría también declarar la misma clase de esta forma:

    class Superman
    {
            public String traje;
            private String amor;

         Superman() // le ponemos un constructor para inicializar variables  
        {
            this.traje="excentrico";
            this.amor="Luisa Lane";
        }  
    }   // vemos en este caso que inicialize las propiedades en el constructor


    Ok, después de explicar esas dos sencillas clases, la duda es ¿Cuál es la diferencia entre inicializar las variables como en la primera forma y entre la segunda forma?

    Muchas Gracias.
    miércoles, 06 de enero de 2010 15:28

Respuestas

  • hola

    en realidad este punto asm que nada es mas un tema de gusto que una regla hay quienes les gusta suar propeidades hay quienes les gusta pasar datos por constructor y hay quienes implementan todo junto para que uno elija

    por ejemplo

    public class Ambiente
    {
        public int ancho {get; set;}
        public int largo {get; set;}
        public int CantPuertas {get; set;}

        public Ambiente()
        {
        }
       
        public Ambiente(int ancho, int largo, int cantpuertas) : this(ancho, largo)
        {
            this.CantPuertas = cantpuertas;
        }
       
        public Ambiente(int ancho, int largo)
        {
            this.ancho = ancho;
            this.largo = largo;
        }
    }

    como veras aqui hay constructores que llaman a constructores

    en este caso esta implementado completo y el usaurio podria ahcer

    Ambiente amb = new Ambiente(10, 10);
    amb.CantPuerts = 3;

    o tambien podria hacer

    Ambiente amb = new Ambiente(10, 10, 3);

    o es mas si a algun programador no el gustan o no tiene la info al momento de construir el ambiente puede crear la instancia
    sin parametros

    Ambiente amb = new Ambiente();
    amb.ancho = 10;
    amb.largo = 10;
    amb.CantPuerts = 3;


    en este link esta muy bien explicado

    Utilizar constructores (Guía de programación de C#)

    Constructores (Guía de programación de C#)


    veras lago raro hay constructores privados, o sea no permiten crear una instancia de la clase desde fuera
    esto se usa por ejemplo en el patron Singleton

    pore so como te decia por ahi las cosas ahora estan un poco en el aire con ejemplo que no convencen pro cuando veas temas de patrones alli te cerrara todo ya qeu es toda esta teoria aplciada a caso puntuales para resolver problemas de diseño<!-- -->



    saludos<!-- -->

    Leandro Tuttini

    Blog
    Buenos Aires
    Argentina
    miércoles, 06 de enero de 2010 16:49
  • Iván,

    Aquí te dejo un ejemplo, similar al que dejó Leandro, como para que tengas otro ejemplo.

    using System;
    
    namespace ConsoleApplication2
    {
        class Persona
        {
            public string Nombre { get; set; }
    
            public Persona() { }
    
            public Persona(string nombre)
            {
                Nombre = nombre;
            }
    
            public virtual void Saludar()
            {
                Console.WriteLine(String.Format("Hola, soy {0}.", Nombre));
            }
            public virtual string Saludo()
            {
                return String.Format("Hola, soy {0}.", Nombre);
            }
        }
    
        class Empleado : Persona
        {
            public string Cargo { get; set; }
    
            public Empleado() { }
    
            public Empleado(string nombre, string cargo)
            {
                Nombre = nombre;
                Cargo = cargo;
            }
    
            public override void Saludar()
            {
                Console.WriteLine(base.Saludo() + String.Format(" Y soy {0}.", Cargo));
            }
    
            public override string Saludo()
            {
                return base.Saludo() + String.Format(" Y soy {0}.", Cargo);
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                // PERSONA
                // Sin constructor sería
                Persona p1 = new Persona();
                p1.Nombre = "Pablo";
                p1.Saludar(); // Mismo comportamiento que "Console.WriteLine(p1.Saludo());"
    
                // Con el constructor
                Persona p2 = new Persona("Paula");
                p2.Saludar(); // Mismo comportamiento que "Console.WriteLine(p2.Saludo());"
    
                // EMPLEADO
                // Sin constructor
                Empleado e1 = new Empleado();
                e1.Nombre = "Pablo";
                e1.Cargo = "Gerente de sistemas";
                e1.Saludar(); // Mismo comportamiento que "Console.WriteLine(e1.Saludo());"
    
                // Con constructor
                Empleado e2 = new Empleado("Paula", "Gerente de marketing");
                e2.Saludar(); // Mismo comportamiento que "Console.WriteLine(e2.Saludo());"
    
                Console.ReadKey();
            }
        }
    }


    Respecto del uso de la keyword virtual/new
    - Al declarar un método como virtual, se está habilitando el override de dicho método. Si nosotros desearamos escribir un método con la misma firma (nombre, cantidad y tipo de parámetros) y NO utilizamos la keyword new, ésto provocaría un warning durante la compilación, que nos diría que estamos ocultando un miembro de la clase base, que si realmente es lo que queremos, utilicemos la keyword new.

    En resumen, el uso del new quita la aparición del warning, ya que la ejecución del código con o sin el uso del new sería la misma.

    Prueba éste ejemplo para que veas el comportamiento.

    using System;
    
    namespace ConsoleApplication2
    {
        class Persona
        {
            public Persona() { }
    
            public virtual void Saludar()
            { Console.WriteLine("Hola!"); }
        }
    
        class Empleado : Persona
        {
            public Empleado() { }
    
            // --------------------------------------------- //
            // Warning	1
            // ConsoleApplication2.Empleado.Saludar()
            // hides inherited member 
            // ConsoleApplication2.Persona.Saludar().
            // To make the current member override that 
            // implementation, add the override keyword. 
            // Otherwise add the new keyword.
    
            //public override void Saludar()
            public void Saludar()
            {
                Console.WriteLine("Hola!!!");
            }
            // --------------------------------------------- //
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                Persona p = new Persona();
                p.Saludar();
    
                Empleado e = new Empleado();
                e.Saludar();
    
                Console.ReadKey();
            }
        }
    }

    Saludos,
    Esteban.
    Blog
    miércoles, 06 de enero de 2010 19:56

Todas las respuestas

  • al nivel en el que estas aprendiendo no hay ninguna diferencia. 

    sin embargo profundizando más y si algún día quieres entrar en temas mucho más avanzados encontraras cosas como el tema de BeforeFieldInit que se presenta cuando utilizas campos estáticos con constructores estáticos.



    Colabora con la comunidad, si éste mensaje te ha sido de utilidad, márcalo como respuesta correcta.
    Juan Carlos Ruiz Pacheco
    Ingeniero de Sistemas
    Microsoft MVP C#
    MCP,MCTS,DCE+Platino,OCA,OCP
    Visita Mi Blog C# XNA Sistemas Operativos
    miércoles, 06 de enero de 2010 15:41
  • Gracias Juan Carlos.

    Para poder aprender en temas mas avanzados, estas cosas simples, me deben quedar  bien entendidas.
    Todavía estoy sufriendo con entender bien bien la diferencia entre un metodo declarado con new y entre un metodo con override, ya he leido algo de documentacion y en teoria he aprendido que "new" hace que el metodo sea un metodo totalmente diferente y nuevo, del que se heredo, de tal forma que oculta el metodo heredado, como quien llega y dice quitate que yo voy primero, aunque en teoria entiendo que el original sigue existiendo. y el override hacer que el metodo se Reescriba.

    Todo eso en teoria..por que en la practica...todavia no me encuentro un ejemplo practico que me ayude a verlo.

    Muchas Gracias.. en todos estos conceptos ando apenas amigo, gracias por tu ayuda.
    miércoles, 06 de enero de 2010 15:50
  • Hola Iván,

    Te dejo un ejemplo, y te aclaro que justamente, hacer un override, sobreescribe la implementación; por otra parte, haciendo un new ocultas el método de la clase base y haces una implementación totalmente independiente del método oculto.

    using System;
    
    namespace ConsoleApplication2
    {
        class Animal
        { public virtual void Moverse() { Console.WriteLine("Soy un animal y me muevo."); } }
    
        class Pato : Animal
        {
            // Reescribo el método
            public override void Moverse()
            {
                base.Moverse();
                Console.WriteLine("Pero como soy un pato, nado.");
            }
        }
    
        class Perro : Animal
        {
            // Reescribo el método
            public override void Moverse()
            {
                base.Moverse();
                Console.WriteLine("Y como soy un perro, camino.");
            }
        }
    
        class Paloma : Animal
        {
            // Reescribo el método
            public override void Moverse()
            {
                base.Moverse();
                Console.WriteLine("Como soy una paloma, vuelo.");
            }
        }
    
        class AnimalRaro : Animal
        {
            // Oculto el método
            public new void Moverse()
            {
                Console.WriteLine("¿?.");
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                Animal animal = new Animal();
                Pato pato = new Pato();
                Perro perro = new Perro();
                Paloma paloma = new Paloma();
                AnimalRaro animalRaro = new AnimalRaro();
    
                animal.Moverse();
                pato.Moverse();
                perro.Moverse();
                paloma.Moverse();
                animalRaro.Moverse();
    
                Console.ReadKey();
            }
        }
    }

    Te dejo un link con un tutorial para ayudar al entendimiento de dichas keywords.

    Tutorial de versiones [http://msdn.microsoft.com/es-es/library/aa288479(VS.71).aspx]


    Espero te sirva, cualquier duda, responde al thread.

    Saludos.
    -
    Esteban Murchio.

    Por favor recuerda marcar las respuestas si te han sido de utilidad, y desmarcarlas si no proveen ayuda alguna.
    Blog
    • Editado Esteban M miércoles, 06 de enero de 2010 16:15 Agregado de tutorial
    • Marcado como respuesta Ivan Caballero miércoles, 06 de enero de 2010 16:43
    • Desmarcado como respuesta Leandro TuttiniMVP jueves, 07 de enero de 2010 17:35
    miércoles, 06 de enero de 2010 16:08
  • Muchas Gracias Esteban por tu gran esfuerzo en el codigo que me regalaste para lograr entender el asunto. Lo voy a leer. y tambien la liga que me enviaste.

    ME tengo que hacer un experto de POO en C#, y solo con la ayuda de ustedes y mi esfuerzo puedo.

    Gracias!
    miércoles, 06 de enero de 2010 16:44
  • hola

    en realidad este punto asm que nada es mas un tema de gusto que una regla hay quienes les gusta suar propeidades hay quienes les gusta pasar datos por constructor y hay quienes implementan todo junto para que uno elija

    por ejemplo

    public class Ambiente
    {
        public int ancho {get; set;}
        public int largo {get; set;}
        public int CantPuertas {get; set;}

        public Ambiente()
        {
        }
       
        public Ambiente(int ancho, int largo, int cantpuertas) : this(ancho, largo)
        {
            this.CantPuertas = cantpuertas;
        }
       
        public Ambiente(int ancho, int largo)
        {
            this.ancho = ancho;
            this.largo = largo;
        }
    }

    como veras aqui hay constructores que llaman a constructores

    en este caso esta implementado completo y el usaurio podria ahcer

    Ambiente amb = new Ambiente(10, 10);
    amb.CantPuerts = 3;

    o tambien podria hacer

    Ambiente amb = new Ambiente(10, 10, 3);

    o es mas si a algun programador no el gustan o no tiene la info al momento de construir el ambiente puede crear la instancia
    sin parametros

    Ambiente amb = new Ambiente();
    amb.ancho = 10;
    amb.largo = 10;
    amb.CantPuerts = 3;


    en este link esta muy bien explicado

    Utilizar constructores (Guía de programación de C#)

    Constructores (Guía de programación de C#)


    veras lago raro hay constructores privados, o sea no permiten crear una instancia de la clase desde fuera
    esto se usa por ejemplo en el patron Singleton

    pore so como te decia por ahi las cosas ahora estan un poco en el aire con ejemplo que no convencen pro cuando veas temas de patrones alli te cerrara todo ya qeu es toda esta teoria aplciada a caso puntuales para resolver problemas de diseño<!-- -->



    saludos<!-- -->

    Leandro Tuttini

    Blog
    Buenos Aires
    Argentina
    miércoles, 06 de enero de 2010 16:49
  • En tal caso esteban el animal raro tambien cambio su forma de caminar...a "¿?".

    Lo veo muy similar al override.
    Cual es la diferencia?
    miércoles, 06 de enero de 2010 17:06
  • hola

    el tema es que el ejemplo de Esteban no ataca el tema de los constructores
    como veras todas las clases ni siquierea define uno, usan el que esta por defecto si parametros

    este mas bien corresponderia a tu pregunta en un post anterior sobre herencia


    saludos
    Leandro Tuttini

    Blog
    Buenos Aires
    Argentina
    miércoles, 06 de enero de 2010 17:09
  • Iván,

    Aquí te dejo un ejemplo, similar al que dejó Leandro, como para que tengas otro ejemplo.

    using System;
    
    namespace ConsoleApplication2
    {
        class Persona
        {
            public string Nombre { get; set; }
    
            public Persona() { }
    
            public Persona(string nombre)
            {
                Nombre = nombre;
            }
    
            public virtual void Saludar()
            {
                Console.WriteLine(String.Format("Hola, soy {0}.", Nombre));
            }
            public virtual string Saludo()
            {
                return String.Format("Hola, soy {0}.", Nombre);
            }
        }
    
        class Empleado : Persona
        {
            public string Cargo { get; set; }
    
            public Empleado() { }
    
            public Empleado(string nombre, string cargo)
            {
                Nombre = nombre;
                Cargo = cargo;
            }
    
            public override void Saludar()
            {
                Console.WriteLine(base.Saludo() + String.Format(" Y soy {0}.", Cargo));
            }
    
            public override string Saludo()
            {
                return base.Saludo() + String.Format(" Y soy {0}.", Cargo);
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                // PERSONA
                // Sin constructor sería
                Persona p1 = new Persona();
                p1.Nombre = "Pablo";
                p1.Saludar(); // Mismo comportamiento que "Console.WriteLine(p1.Saludo());"
    
                // Con el constructor
                Persona p2 = new Persona("Paula");
                p2.Saludar(); // Mismo comportamiento que "Console.WriteLine(p2.Saludo());"
    
                // EMPLEADO
                // Sin constructor
                Empleado e1 = new Empleado();
                e1.Nombre = "Pablo";
                e1.Cargo = "Gerente de sistemas";
                e1.Saludar(); // Mismo comportamiento que "Console.WriteLine(e1.Saludo());"
    
                // Con constructor
                Empleado e2 = new Empleado("Paula", "Gerente de marketing");
                e2.Saludar(); // Mismo comportamiento que "Console.WriteLine(e2.Saludo());"
    
                Console.ReadKey();
            }
        }
    }


    Respecto del uso de la keyword virtual/new
    - Al declarar un método como virtual, se está habilitando el override de dicho método. Si nosotros desearamos escribir un método con la misma firma (nombre, cantidad y tipo de parámetros) y NO utilizamos la keyword new, ésto provocaría un warning durante la compilación, que nos diría que estamos ocultando un miembro de la clase base, que si realmente es lo que queremos, utilicemos la keyword new.

    En resumen, el uso del new quita la aparición del warning, ya que la ejecución del código con o sin el uso del new sería la misma.

    Prueba éste ejemplo para que veas el comportamiento.

    using System;
    
    namespace ConsoleApplication2
    {
        class Persona
        {
            public Persona() { }
    
            public virtual void Saludar()
            { Console.WriteLine("Hola!"); }
        }
    
        class Empleado : Persona
        {
            public Empleado() { }
    
            // --------------------------------------------- //
            // Warning	1
            // ConsoleApplication2.Empleado.Saludar()
            // hides inherited member 
            // ConsoleApplication2.Persona.Saludar().
            // To make the current member override that 
            // implementation, add the override keyword. 
            // Otherwise add the new keyword.
    
            //public override void Saludar()
            public void Saludar()
            {
                Console.WriteLine("Hola!!!");
            }
            // --------------------------------------------- //
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                Persona p = new Persona();
                p.Saludar();
    
                Empleado e = new Empleado();
                e.Saludar();
    
                Console.ReadKey();
            }
        }
    }

    Saludos,
    Esteban.
    Blog
    miércoles, 06 de enero de 2010 19:56
  • Muchas Gracias Esteban por tu esfuerzo en darme otra explicación más.
    jueves, 07 de enero de 2010 16:57