C# Variables de variables membres utilisées par la méthode de la classe de base

Question

OK donc j'admets tout de suite que c'est un peu vicieux ... mais ça sert un but logique. J'utilise C# pour un projet en cours et j'essaie de trouver un moyen de remplacer une variable membre dans une classe dérivée, mais j'accède à la variable surchargée dans une méthode de classe de base. Pour rendre les choses plus "divertissantes", il serait préférable que la variable membre surchargée soit statique (ceci n'est PAS montré dans l'exemple de code ci-dessous).

Voici mon exemple de code:

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" 
    }; 
} 

Toute pensée pour expliquer pourquoi cela ne fonctionne pas et une façon de contourner le problème?

Answer 1

Y a-t-il une raison pour laquelle vous ne pouvez pas utiliser une propriété virtuelle? Cela fournirait exactement la fonctionnalité que vous recherchez. Ce ne serait tout simplement pas un champ.

protected abstract string[] array { get; } 

...

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

Answer 2

Pourquoi avez-vous besoin de surcharger la variable? En regardant à partir de votre code, il suffit de définir les valeurs, non? De plus, les variables statiques sont liées à la classe (pas à l'instance), donc elles ne peuvent être écrasées dans aucune situation.

Answer 3

Il suffit de ne pas utiliser de nouveau. Définissez le tableau dans le constructeur de votre sous-classe.

EDIT: avec le code:

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" }; 
    } 
} 

L'important est le paramètre générique T qui fonctionne essentiellement comme un index des tableaux de chaînes.

Answer 5

Vous essayez d'obtenir un comportement polymorphe à partir du tableau, mais vous le définissez pour un comportement local de classe.

Le tableau doit être la méthode() virtuelle ou dans la classe de base compilera pour accéder toujours le tableau dans la classe de base - le tableau devrait également être une propriété non un champ pour ce faire, à savoir,

string [] _array = {...};/valeur de classe locale protected virtual string [] array {get {return _array; }} // rend la propriété de tableau Overridable

puis dans les sous-classes, vous aurez besoin de faire

string [] = _array {...}; // sous-classe de valeurs locales virtual string [] array {get {return _array; }} // cela remplace la propriété de classe de base

afin d'obtenir l'effet désiré