C# | Constructores

Un constructor es un método especial de la clase que se invoca automáticamente cada vez que se crea una instancia de la clase. Al igual que los métodos, un constructor también contiene la colección de instrucciones que se ejecutan en el momento de la creación del objeto. Se utiliza para asignar valores iniciales a los miembros de datos de la misma clase. 

Ejemplo :  

class Geek
{   
  .......
  // Constructor
  public Geek() {}
  .......
}

// an object is created of Geek class,
// So above constructor is called
Geek obj = new Geek(); 

Puntos importantes para recordar sobre los constructores

• El constructor de una clase debe tener el mismo nombre que el nombre de la clase en la que reside.
• Un constructor no puede ser abstracto, final y sincronizado.
• Dentro de una clase, solo puede crear un constructor estático.
• Un constructor no tiene ningún tipo de devolución, ni siquiera void.
• Un constructor estático no puede ser un constructor parametrizado.
• Una clase puede tener cualquier número de constructores.
• Los modificadores de acceso se pueden usar en la declaración del constructor para controlar su acceso, es decir, qué otra clase puede llamar al constructor. 
   

Tipos de constructor

1. Constructor predeterminado
2. Constructor parametrizado
3. Copiar constructor
4. Constructor Privado
5. Constructor estático

Constructor predeterminado

Un constructor sin parámetros se denomina constructor predeterminado. Un constructor predeterminado tiene todas las instancias de la clase que se inicializarán con los mismos valores. El constructor predeterminado inicializa todos los campos numéricos a cero y todos los campos de strings y objetos a nulos dentro de una clase.

Ejemplo : 

// C# Program to illustrate calling
// a Default constructor
using System;
namespace DefaultConstructorExample {
 
class Geek {
 
    int num;
    string name;
 
    // this would be invoked while the
    // object of that class created.
    Geek()
    {
        Console.WriteLine("Constructor Called");
    }
 
    // Main Method
    public static void Main()
    {
 
        // this would invoke default
        // constructor.
        Geek geek1 = new Geek();
 
        // Default constructor provides
        // the default values to the
        // int and object as 0, null
        // Note:
        // It Give Warning because
        // Fields are not assign
        Console.WriteLine(geek1.name);
        Console.WriteLine(geek1.num);
    }
}
}

Producción : 

Constructor Called

0

Nota: Esto también mostrará algunas advertencias de la siguiente manera: 

prog.cs(8, 6): warning CS0649: Field `DefaultConstructorExample.Geek.num' is never assigned to, and will always have its default value `0'
prog.cs(9, 9): warning CS0649: Field `DefaultConstructorExample.Geek.name' is never assigned to, and will always have its default value `null'

Constructor parametrizado

Un constructor que tiene al menos un parámetro se llama constructor parametrizado. Puede inicializar cada instancia de la clase a diferentes valores.

Ejemplo :  

// C# Program to illustrate calling of
// parameterized constructor.
using System;
namespace ParameterizedConstructorExample {
 
class Geek {
 
    // data members of the class.
    String name;
    int id;
 
    // parameterized constructor would
    // initialized data members with
    // the values of passed arguments
    // while object of that class created.
    Geek(String name, int id)
    {
        this.name = name;
        this.id = id;
    }
 
    // Main Method
    public static void Main()
    {
 
        // This will invoke parameterized
        // constructor.
        Geek geek1 = new Geek("GFG", 1);
        Console.WriteLine("GeekName = " + geek1.name +
                         " and GeekId = " + geek1.id);
    }
}
}

Producción : 

GeekName = GFG and GeekId = 1 

Copiar constructor

Este constructor crea un objeto copiando variables de otro objeto. Su uso principal es inicializar una nueva instancia a los valores de una instancia existente. 

Ejemplo : 

// C# Program to illustrate calling
// a Copy constructor
using System;
namespace copyConstructorExample {
 
class Geeks {
 
    private string month;
    private int year;
 
    // declaring Copy constructor
    public Geeks(Geeks s)
    {
        month = s.month;
        year = s.year;
    }
 
    // Instance constructor
    public Geeks(string month, int year)
    {
        this.month = month;
        this.year = year;
    }
 
    // Get details of Geeks
    public string Details
    {
        get
        {
            return "Month: " + month.ToString() +
                     "\nYear: " + year.ToString();
        }
    }
 
    // Main Method
    public static void Main()
    {
 
        // Create a new Geeks object.
        Geeks g1 = new Geeks("June", 2018);
 
        // here is g1 details is copied to g2.
        Geeks g2 = new Geeks(g1);
 
        Console.WriteLine(g2.Details);
    }
}
}

Producción : 

Month: June
Year: 2018

Constructor Privado

Si se crea un constructor con un especificador privado, se lo conoce como Constructor privado. No es posible que otras clases se deriven de esta clase y tampoco es posible crear una instancia de esta clase. 

Puntos para recordar :  

• Es la implementación de un patrón de clase singleton.
• use un constructor privado cuando solo tengamos miembros estáticos.
• El uso de un constructor privado impide la creación de instancias de esa clase.

Ejemplo : 

// C# Program to illustrate calling
// a Private constructor
using System;
namespace privateConstructorExample {
 
public class Geeks {
 
    // declare private Constructor
    private Geeks()
    {
    }
 
    // declare static variable field
    public static int count_geeks;
 
    // declare static method
    public static int geeks_Count()
    {
        return ++count_geeks;
    }
 
    // Main Method
    public static void Main()
    {
 
        // If you uncomment the following
        // statement, it will generate
        // an error because the constructor
        // is unaccessible:
        // Geeks s = new Geeks(); // Error
 
        Geeks.count_geeks = 99;
 
        // Accessing without any
        // instance of the class
        Geeks.geeks_Count();
 
        Console.WriteLine(Geeks.count_geeks);
 
        // Accessing without any
        // instance of the class
        Geeks.geeks_Count();
 
        Console.WriteLine(Geeks.count_geeks);
    }
}
}

Producción : 

100
101

Constructor estático

Static Constructor debe invocarse solo una vez en la clase y ha sido invocado durante la creación de la primera referencia a un miembro estático en la clase. Un constructor estático son campos o datos estáticos inicializados de la clase y para ser ejecutados una sola vez. 

Puntos para recordar :  

• No se puede llamar directamente.
• Cuando se está ejecutando, el usuario no tiene control.
• No requiere modificadores de acceso ni ningún parámetro.
• Se llama automáticamente para inicializar la clase antes de que se cree la primera instancia.

Ejemplo :

// C# Program to illustrate calling
// a Static constructor
using System;
namespace staticConstructorExample {
 
class geeks {
 
    // It is invoked before the first
    // instance constructor is run.
    static geeks()
    {
 
        // The following statement produces
        // the first line of output,
        // and the line occurs only once.
        Console.WriteLine("Static Constructor");
    }
 
    // Instance constructor.
    public geeks(int i)
    {
        Console.WriteLine("Instance Constructor " + i);
    }
 
    // Instance method.
    public string geeks_detail(string name, int id)
    {
        return "Name:" + name + " id:" + id;
    }
 
    // Main Method
    public static void Main()
    {
 
        // Here Both Static and instance
        // constructors are invoked for
        // first instance
        geeks obj = new geeks(1);
 
        Console.WriteLine(obj.geeks_detail("GFG", 1));
 
        // Here only instance constructor
        // will be invoked
        geeks obj1 = new geeks(2);
 
        Console.WriteLine(obj1.geeks_detail("GeeksforGeeks", 2));
    }
}
}

Producción : 

Static Constructor
Instance Constructor 1
Name:GFG id:1
Instance Constructor 2
Name:GeeksforGeeks id:2