anulaciones de variables C# miembros utilizados por el método de la clase base

Question

OK así que admiten la derecha de la parte superior que esto es un poco chiflado ... pero sirve un propósito lógico. Estoy usando C# para un proyecto actual y estoy tratando de encontrar una manera de anular una variable miembro en una clase derivada, pero accedo a la variable anulada en un método de clase base. Para hacer las cosas más "entretenidas", sería preferible si la variable miembro anulada fuese estática (esto NO se muestra en el código de ejemplo a continuación).

Aquí está mi código de ejemplo:

class baseclass 
{ 
    protected string[] array = null; 

    public string method() 
    { 
     string str = ""; 
     foreach (string x in this.array) 
     { 
      str += x + " "; 
     } 

     return str; 
    } 
} 

class subclass1 : baseclass 
{ 
    new string[] array = new string[] 
    { 
     "class1value1", 
     "class1value2", 
     "class1value3", 
     "class1value4" 
    }; 
} 

class subclass2 : baseclass 
{ 
    new string[] array = new string[] 
    { 
     "class2value1", 
     "class2value2", 
     "class2value3", 
     "class2value4" 
    }; 
} 

¿Alguna idea de por qué esto no funciona y una manera de conseguir alrededor de él?

Answer 1

¿Hay alguna razón usted no puede utilizar una propiedad virtual? Eso proporcionaría exactamente la funcionalidad que está buscando. Simplemente no sería un campo.

protected abstract string[] array { get; } 

...

protected override string[] array { get { return new string[]{"...","..."}; }} 

Answer 2

¿Por qué necesita para anular la variable? Mirando desde su código, simplemente establecer los valores sería suficiente, ¿no?

Además, las variables estáticas están ligados a la clase (no es el caso), por lo tanto, no es reemplazable en cualquier situación.

Answer 3

Simplemente no utilice nueva. Establezca la matriz en el constructor de su subclase.

EDIT: con el código:

class subclass1 : baseclass 
{ 
    public subclass1() 
    { 
     array = new string[] 
     { 
      "class1value1", 
      "class1value2", 
      "class1value3", 
      "class1value4" 
     }; 
    } 
} 

class subclass2 : baseclass 
{ 
    public subclass2() 
    { 
     array = new string[] 
     { 
      "class2value1", 
      "class2value2", 
      "class2value3", 
      "class2value4" 
     }; 
    } 
} 

Answer 4

class BaseClass 
{ 
    public virtual string Method() 
    { 
     return string.Empty; 
    } 
} 

abstract class BaseClass<T> : BaseClass where T : BaseClass<T> 
{ 
    protected static string[] strings; 

    public override string Method() 
    { 
     return string.Join(" ", strings); 
    } 
} 

class Subclass1 : BaseClass<Subclass1> 
{ 
    static Subclass1() 
    { 
     strings = new[] { "class1value1", "class1value2", "class1value3" }; 
    } 
} 

class Subclass2 : BaseClass<Subclass2> 
{ 
    static Subclass2() 
    { 
     strings = new[] { "class2value1", "class2value2", "class2value3" }; 
    } 
} 

La parte importante es el parámetro genérico T que básicamente funciona como un índice para las matrices de cadenas.

Answer 5

Usted está tratando de obtener un comportamiento polimórfico de la matriz, pero se está definiendo por el comportamiento local de clase.

La matriz tiene que ser virtual o método() de la clase base compilará para acceder siempre la matriz en la clase base - la matriz también debe ser no una propiedad de un campo para hacer esto, es decir,

string [] _array = {...};/valores locales de la clase base cadena virtual protegida [] matriz {get {return _array; }} // hace que la propiedad de matriz reemplazable

luego en las subclases, tendrá que hacer

string [] _array = {...}; // valores locales de la subclase cadena virtual [] matriz {get {return _array; }} // Esto anula la propiedad de la clase base

con el fin de obtener los