Asignación al campo de solo lectura estático de la clase base

Question

public class ClassA
{
    public static readonly string processName;
} 

public class ClassB : ClassA
{
    static ClassB()
    {
        processName = "MyProcess.exe";
    }
}

Recibo un error al compilar el código C # anterior.

El error dice: " No se puede asignar un campo de solo lectura estático (excepto en un constructor estático o un inicializador variable) "

Pero lo estoy asignando en un constructor estático.

La necesidad de tal variable estática es que la clase base tiene métodos que usan esta variable, pero las clases derivadas y la clase base deben tener valores diferentes para esta variable. Pero el valor es constante en todas las instancias de la clase respectiva. Debe ser de solo lectura porque no debe cambiarse en ningún lugar.

¿Cuál es el error en el código anterior? (Si hay alguno) No parece que pueda detectar uno. El mensaje de error no está ayudando. Como no estoy haciendo nada malo de acuerdo con eso.

Si hay un error, ¿cómo puedo implementar esta funcionalidad? Sé que una solución simple sería convertirla en una variable de instancia y asignarles diferentes valores en las clases derivadas. Pero eso es innecesario ya que el valor es constante en todas las instancias de la clase respectiva.

Answer 1

Sin embargo, está asignando en el constructor estático incorrecto . Solo se puede asignar en un constructor estático para el tipo que declara la variable .

Suponga que tiene otra clase derivada de ClassC que hace lo mismo: terminaría sobrescribiendo la variable, que debe ser de solo lectura. Aquí hay una variable estática única , sin importar cuántas clases derivadas tenga.

Una respuesta es evitar el uso de una variable estática pero poner una propiedad virtual en la clase base y hacer que cada clase derivada anule la propiedad para devolver una constante diferente:

public class ClassA
{
    public virtual string ProcessName { get { return "ClassAProcess"; } }
} 

public class ClassB : ClassA
{
    public override string ProcessName { get { return "MyProcess.exe"; } }
}

Básicamente, la opción sería separar " static " bits en una jerarquía separada: efectivamente, parece que desea polimorfismo sobre el tipo en lugar de instancias, y eso no es compatible con .NET.

Answer 2

En su ejemplo, solo existirá un solo campo, el de la clase base y no puede tener valores diferentes en un solo campo. Además de eso, solo puede inicializar readonly campos en la misma clase, no en clases derivadas. Una solución alternativa podría ser definir una clase genérica como:

static class ProcessNames<T> {
   public static string Value { get; set; }
}

y use ProcessNames<DerivedClassType>.Value en su lugar. Obviamente, el valor será accesible públicamente de esta manera.

Sin embargo, debería ver si definir el campo en cada clase derivada se ajusta por separado a su necesidad y solo recurrir a soluciones alternativas si no es así.

Answer 3

Hay muchas formas de desollar al gato. Aquí hay otra forma de hacerlo.

public class ClassA
{
    public string ProcessName{ get; private set;}

    public ClassA()
    {
        ProcessName = "ClassAProcess";
    }

    public ClassA(string processName)
    {
        ProcessName = processName;
    }
}

public class ClassB : ClassA
{
    public ClassB() : base("ClassAProcess")
    {
    }
}