propiedad - Constructor estático en C#

metodo constructor c#

Question

Estoy tratando de usar un constructor estático como el siguiente:

public static DataManager()
{
    LastInfoID = 1;
}

y obteniendo este error:

modificadores de acceso no están permitidos en constructores estáticos

Me gustaría saber cuál es mi problema.

Answer 1

El constructor estático no tiene modificador de acceso: es solo:

static DataManager() // note no "public"
{
    LastInfoID = 1;
}

Esto se debe a que nunca se llama explícitamente (excepto quizás a través de la reflexión), sino que es invocado por el tiempo de ejecución; un nivel de acceso no tendría sentido.

Answer 2

El problema es que el campo o propiedad LastInfoID no se declara como static en su clase y puede acceder solo a miembros estáticos desde un constructor estático. También elimine la palabra clave public de la declaración:

static DataManager()
{
    LastInfoID = 1;
}

Answer 3

Eliminar el public . La sintaxis para un constructor estático es:

class MyClass 
{
    static MyClass() 
    {
        // Static constructor
    }
}

Answer 4

Para dar a alguien aquí una respuesta más clara, sin un ejemplo, piense por qué tendría que acceder a un constructor estático desde el exterior. Las clases estáticas se crean en la memoria tras la ejecución de la aplicación, es por eso que son estáticas. En otras palabras, NUNCA necesitaría llamar a uno explícitamente y, si lo hace, decir a través de la reflexión (que no sé si le dejará), entonces está haciendo algo mal.

Cuando creas una nueva instancia de una clase, el constructor existe como una forma de inicializar todas las variables internas y de realizar cualquier tipo de procesamiento necesario para hacer que la clase funcione de la manera prevista. Tenga en cuenta que si no especifica un constructor, el compilador creará uno por usted. Por esta razón, todavía necesita crear una clase con un "()" como este

     new MyClass();

porque está llamando al constructor predeterminado (siempre que no tenga uno sin parámetros definido). En otras palabras, la razón por la que un constructor no estático debe definirse como público es porque debe llamarlo explícitamente. Si la memoria me sirve bien, C # no compilará en un código que intente llamar a un constructor (a través de malloc) que no esté definido como público.

Los constructores en una clase estática existen para propósitos de "configuración". Por ejemplo, puedo tener una clase estática que se supone que es el puente entre mi código y un archivo del que estoy guardando y leyendo datos constantemente. Puedo definir un constructor que, tras la creación del objeto, se asegurará de que el archivo exista y, si no lo hace, crea uno predeterminado (muy útil en sistemas web que se trasladan a otros servidores).

Answer 5

using System;

public class Something
{
    //
    private static  DateTime _saticConstructorTime;
    private         DateTime _instanceConstructorTime;
    //
    public static DateTime SaticConstructorTime
    {
        set { _saticConstructorTime = value; }
        get { return _saticConstructorTime ; }
    }
    public DateTime InstanceConstructorTime
    {
        set { _instanceConstructorTime = value; }
        get { return _instanceConstructorTime; }
    }
    //Set value to static propriety 
    static Something()
    {
        SaticConstructorTime = DateTime.Now;
        Console.WriteLine("Static constructor has been executed at: {0}",
                        SaticConstructorTime.ToLongTimeString());
    }
    //The second constructor started alone at the next instances
    public Something(string s)
    {
        InstanceConstructorTime = DateTime.Now;
        Console.WriteLine("New instances: "+ s +"/n");
    }
    public void TimeDisplay(string s)
    {
        Console.WriteLine("Instance /""+ s + "/" has been created at: " + InstanceConstructorTime.ToLongTimeString());
        Console.WriteLine("Static constructor has been created at: " + SaticConstructorTime.ToLongTimeString() + "/n");
    }
}
//
class Client
{
    static void Main()
    {
        Something somethingA = new Something("somethingA");
        System.Threading.Thread.Sleep(2000);
        Something somethingB = new Something("somethingB");

        somethingA.TimeDisplay("somethingA");
        somethingB.TimeDisplay("somethingB");
        System.Console.ReadKey();
    }
}
/* output :

Static constructor has been executed at: 17:31:28
New instances: somethingA

New instances: somethingB

Instance "somethingA" has been created at: 17:31:28
Static constructor has been created at: 17:31:28

Instance "somethingB" has been created at: 17:31:30
Static constructor has been created at: 17:31:28
 */