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

Question

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.

Answer 1

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

Answer 2

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.

Answer 3

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

Answer 4

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!

Answer 5

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

¿Qué es un Patrón de Diseño?

saludos<!-- -->

---

Leandro Tuttini

Blog
Buenos Aires
Argentina

Answer 6

En tal caso esteban el animal raro tambien cambio su forma de caminar...a "¿?".

Lo veo muy similar al override.
Cual es la diferencia?

Answer 7

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

Answer 8

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

Answer 9

Muchas Gracias Esteban por tu esfuerzo en darme otra explicación más.