C# variable Membre remplace utilisé par la méthode de classe de base

OK, donc j'avoue que dès le début qu'il est un peu tordu ... mais il ne servir une logique de but. Je suis à l'aide de C# pour un projet en cours et je vais essayer de trouver un moyen de remplacer un membre de la variable dans une classe dérivée, mais l'accès remplacés variable dans une méthode de classe de base. Pour rendre les choses plus “divertissant”, il serait préférable, si l'substituée membre de la variable statique (ce 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"
    };
}

Pensées, pourquoi cela ne fonctionne pas et un moyen de contourner cela?

  • Membre variables ne sont pas polymorphes comme des méthodes. Initialiser le tableau pour contenir les valeurs désirées dans chaque sous-classe.
InformationsquelleAutor | 2009-07-10
  1. 8

    Est-il une raison vous ne pouvez pas utiliser une propriété virtuelle? Que donnerait exactement la fonctionnalité que vous recherchez. Il ne serait pas seulement un champ.

    protected abstract string[] array { get; }

    ...

    protected override string[] array { get { return new string[]{"...","..."}; }}
    • Je suis en train de jouer avec ce droit maintenant ... vous avez raison, cela peut fonctionner ... toujours de jouer pour être sûr. Merci pour l'ajout de plus en plus confiance en ma pensée.
    InformationsquelleAutor JaredPar
  2. 1

    Pourquoi avez-vous besoin de remplacer la variable? La recherche à partir de votre code, il suffit de régler les valeurs suffirait, non?

    De Plus, les variables statiques sont liés à la classe (pas de l'instance), donc ce n'est pas substituables sur n'importe quelle situation.

    • vous êtes à la création d'une catégorie distincte pour tenir des données différentes, +1
    InformationsquelleAutor Adrian Godong
  3. 1

    N'ont tout simplement pas l'utiliser de nouveau. Définissez le tableau dans votre sous-classe' constructeur.

    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"
        };
    }
}
    • ce ne serait pas me permettre d'avoir un tableau statique
    InformationsquelleAutor McAden
  4. 1
    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, c'est le paramètre générique T, qui a essentiellement des fonctions comme un indice de la chaîne de tableaux.

    InformationsquelleAutor dtb
  5. 1

    Vous essayez d'obtenir le comportement polymorphique de la matrice, mais vous êtes à la définition d'une classe de comportement local.

    Le tableau doit être virtuelle ou de la méthode() dans la classe de base permettra de compiler pour toujours accéder au tableau de la classe de base - le tableau doit également être une propriété qui n'est pas un champ pour ce faire, c'est à dire,

    string[] _array = { ... }; /classe de base des valeurs locales
    virtuelles protégées string tableau [] { get { return _array; } } //rend le tableau des biens substituables

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

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

    afin d'obtenir l'effet souhaité

    InformationsquelleAutor Archangel