c# - programacion - que es un constructor java

¿Cuál es el uso de constructores estáticos?

Question

Por favor explícame el uso del constructor estático. ¿Por qué y cuándo crearíamos un constructor estático y es posible sobrecargar uno?

Answer 1

¿Por qué y cuándo crearíamos un constructor estático ...?

Una razón específica para usar un constructor estático es para crear una clase de ''súper enumeración''. Aquí hay un ejemplo (simple, artificial):

public class Animals
{
private readonly string _description;
private readonly string _speciesBinomialName;
public string Description { get { return _description; } }
public string SpeciesBinomialName { get { return _speciesBinomialName; } }
private Animals(string description, string speciesBinomialName)
{
_description = description;
_speciesBinomialName = speciesBinomialName;
}
private static readonly Animals _dog;
private static readonly Animals _cat;
private static readonly Animals _boaConstrictor;
public static Animals Dog { get { return _dog; } }
public static Animals Cat { get { return _cat; } }
public static Animals BoaConstrictor { get { return _boaConstrictor; } }
static Animals()
{
_dog = new Animals("Man''s best friend", "Canis familiaris");
_cat = new Animals("Small, typically furry, killer", "Felis catus");
_boaConstrictor = new Animals("Large, heavy-bodied snake", "Boa constrictor");
}
}

Lo utilizarías de forma muy similar (en apariencia sintáctica) a cualquier otra enumeración:

Animals.Dog

La ventaja de esto sobre una enum regular es que puede encapsular información relacionada fácilmente. Una desventaja es que no puede usar estos valores en una declaración de switch (porque requiere valores constantes).

Answer 2

El constructor estático se usa para inicializar miembros de datos estáticos tan pronto como la clase se referencia por primera vez, mientras que un constructor de instancia se usa para crear una instancia de esa clase con palabra clave.

Fuente: http://www.c-sharpcorner.com/article/static-constructor-in-C-Sharp-and-their-usages/

Answer 3

1. Solo puede acceder a los miembros estáticos de la clase.

Motivo: el miembro no estático es específico de la instancia del objeto. Si se permite que el constructor estático funcione en miembros no estáticos, reflejará los cambios en toda la instancia del objeto, lo que no es práctico.

2. No debería haber ningún parámetro (s) en el constructor estático.

Motivo: Dado que CLR lo llamará, nadie puede pasarle el parámetro. 3.Sólo se permite un constructor estático.

Motivo: la sobrecarga necesita que los dos métodos sean diferentes en términos de definición de método / constructor, lo que no es posible en el constructor estático.

4. No debería haber ningún modificador de acceso a él.

Razón: Una vez más, la razón es que CLR realiza la misma llamada al constructor estático y no el objeto, no es necesario que tenga un modificador de acceso.

Answer 4

Desde Static Constructors (Guía de programación C #) :

Se utiliza un constructor estático para inicializar cualquier dato estático, o para realizar una acción particular que solo necesita ejecutarse una vez. Se llama automáticamente antes de que se cree la primera instancia o se haga referencia a cualquier miembro estático.

Los constructores estáticos tienen las siguientes propiedades:

• Un constructor estático no toma modificadores de acceso o tiene parámetros.

• Se llama automáticamente a un constructor estático para inicializar la clase antes de que se cree la primera instancia o se haga referencia a cualquier miembro estático.

• Un constructor estático no puede ser llamado directamente.

• El usuario no tiene control sobre cuándo se ejecuta el constructor estático en el programa.

• Un uso típico de los constructores estáticos es cuando la clase usa un archivo de registro y el constructor se usa para escribir entradas en este archivo.

• Los constructores estáticos también son útiles al crear clases de envoltorio para código no administrado, cuando el constructor puede llamar al método LoadLibrary .

Answer 5

Los constructores estáticos también son muy útiles cuando tienes campos estáticos que dependen unos de otros, por lo que el orden de inicialización es importante. Si ejecuta su código a través de un formateador / embellecedor que cambia el orden de los campos, entonces se encontrará con valores nulos donde no los esperaba.

Ejemplo: Supongamos que tenemos esta clase:

class ScopeMonitor
{
static string urlFragment = "foo/bar";
static string firstPart= "http://www.example.com/";
static string fullUrl= firstPart + urlFragment;
}

Cuando acceda a fullUr , será " http://www.example.com/foo/bar ".

Meses después, está limpiando su código y alfabetizando los campos (digamos que son parte de una lista mucho más grande, para que no note el problema). Tienes:

class ScopeMonitor
{
static string firstPart= "http://www.example.com/";
static string fullUrl= firstPart + urlFragment;
static string urlFragment = "foo/bar";
}

Su valor de fullUrl es ahora " http://www.example.com/ " ya que urlFragment no se había inicializado en el momento en que se configuró fullUrl . No está bien. Entonces, agrega un constructor estático para encargarse de la inicialización:

class ScopeMonitor
{
static string firstPart= "http://www.example.com/";
static string fullUrl;
static string urlFragment = "foo/bar";
static ScopeMonitor()
{
fullUrl= firstPart + urlFragment;
}
}

Ahora, sin importar en qué orden tenga los campos, la inicialización siempre será correcta.

Answer 6

No, no puedes sobrecargarlo; un constructor estático es útil para inicializar cualquier campo estático asociado con un tipo (o cualquier otra operación por tipo), útil en particular para leer los datos de configuración requeridos en campos de solo lectura, etc.

Es ejecutado automáticamente por el tiempo de ejecución la primera vez que se necesita (las reglas exactas allí son complicadas (ver "antes del campo"), y se cambian sutilmente entre CLR2 y CLR4). A menos que abuses de la reflexión, se garantiza que se ejecute a lo sumo una vez (incluso si dos hilos llegan al mismo tiempo).

Answer 7

puede utilizar constructor estático para inicializar campos estáticos. Se ejecuta en un tiempo indeterminado antes de que se usen esos campos. La documentación de Microsoft y muchos desarrolladores advierten que los constructores estáticos en un tipo imponen una sobrecarga sustancial.
Es mejor evitar constructores estáticos para obtener el máximo rendimiento.
actualización: no puede usar más de un constructor estático en la misma clase, sin embargo, puede usar otros constructores de instancia con (máximo) un constructor estático.

Answer 8

Constructor estático

Un constructor declarado utilizando un modificador estático es un constructor estático. Un constructor estático se usa para inicializar datos estáticos o para realizar una acción particular que debe realizarse solo una vez en el ciclo de vida de la clase. El constructor estático es el primer bloque de código que se ejecuta en clase. El constructor estático ejecuta una y solo una vez en el ciclo de vida de la clase. Se llama automáticamente. El constructor estático no toma ningún parámetro. No tiene especificadores de acceso. No se llama directamente.

Answer 9

using System;
namespace Constructor
{
class Test
{
//Declaration and initialization of static data member
private static int id = 5;
public static int Id
{
get
{
return id;
}
}
public static void print()
{
Console.WriteLine("Test.id = " + id);
}
static void Main(string[] args)
{
//Print the value of id
Test.print();
}
}
}
In the above example, static data member <id> is declared and initialized in same line. So if you compile and run this program your output would look similar to this :
Test.id = 5
Lets create one more class similar to class Test but this time the value of its static data member would depend on the value of static data member <id> of class Test.id.
//File Name : Test1.cs
using System;
namespace Constructor
{
class Test1
{
private static int id ;
//Static constructor, value of data member id is set conditionally here.
//This type of initialization is not possible at the time of declaration.
static Test1()
{
if( Test.Id < 10 )
{
id = 20;
}
else
{
id = 100;
}
Console.WriteLine("Static<Class> Constructor for Class Test1 Called..");
}
public static void print()
{
Console.WriteLine("Test1.id = " + id);
}
static void Main(string[] args)
{
//Print the value of id
Test1.print();
}
}
}
As you can see in the above static constructor, static data member <id> is initialized conditionally. This type of initialization is not possible at the time of declaration. This is where static constructor comes in picture