Faire une superclasse ont une variable statique qui est différent pour chaque sous-classe c #

Question

Sans code dans les sous-classes , je voudrais une classe abstraite d'avoir une autre copie d'une variable statique pour chaque sous-classe. En C #

abstract class ClassA
{
    static string theValue;

    // just to demonstrate
    public string GetValue()
    {
        return theValue;
    }
    ...
}
class ClassB : ClassA { }
class ClassC : ClassA { }

et (par exemple):

(new ClassB()).GetValue(); // returns "Banana"
(new ClassC()).GetValue(); // returns "Coconut"

Ma solution actuelle est la suivante:

abstract class ClassA
{
    static Dictionary<Type, string> theValue;
    public string GetValue()
    {
        return theValue[this.GetType()];
    }
    ...
}

Bien que cela fonctionne très bien, je me demande s'il y a une façon plus élégante ou intégrée de le faire?

Ceci est similaire à Can J'ai différentes copies d'une variable statique pour chaque type de héritant de classe, mais je n'ai aucun contrôle sur les sous-classes

Answer 1

  

Bien que cela fonctionne très bien, je me demande s'il y a une façon plus élégante ou intégrée de le faire?

Il n'y a pas vraiment un moyen intégré de le faire, comme vous êtes genre de violation des principes de base OO ici. Votre classe de base ne devrait pas avoir connaissance des sous-classes dans la théorie traditionnelle objet orientée.

Cela étant dit, si vous devez faire cela, votre mise en œuvre est probablement aussi bon que vous allez obtenir, à moins que vous pouvez ajouter d'autres informations pour les sous-classes directement. Si vous avez besoin de contrôler cela, et vous ne pouvez pas changer les sous-classes, ce sera probablement votre meilleure approche.

Answer 2

Il y a une façon plus élégante. Vous pouvez exploiter le fait que dans une classe statique générique de base sont différentes pour chaque classe dérivée d'un autre type

public abstract class BaseClass<T> where T : class
{
    public static int x = 6;
    public int MyProperty { get { return x; } set { x = value; } }
}

Pour chaque classe enfant, l'int x statique sera unique pour chaque T unique, Deux classes laisse dériver d'enfants, et nous utilisons le nom de la classe enfant comme T générique dans la classe de base.

public class ChildA: BaseClass<ChildA>
{
}

public class ChildB : BaseClass<ChildB>
{
}

Maintenant, le MyProperty statique est unique pour les deux Childa et ChildB

        ChildA TA = new ChildA();
        TA.MyProperty = 8;
        ChildB TB = new ChildB();
        TB.MyProperty = 4;

Answer 3

est un peu différent de ce que vous demandez, mais accomplit peut-être la même chose.

    class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine((new B()).theValue);
        Console.WriteLine((new C()).theValue);
        Console.ReadKey();
    }
}

public abstract class A
{
    public readonly string theValue;

    protected A(string s)
    {
        theValue = s;
    }
}

public class B : A
{
    public B(): base("Banana")
    {
    }
}

public class C : A
{
    public C(): base("Coconut")
    {
    }
}

Answer 4

Il y a une solution de rechange qui pourrait ou ne pourrait pas être meilleur que le vôtre, selon le cas d'utilisation:

abstract class ClassA
{
    private static class InternalClass<T> {
        public static string Value;
    }
    public string GetValue()
    {
        return (string)typeof(InternalClass<>)
              .MakeGenericType(GetType())
              .GetField("Value", BindingFlags.Public | BindingFlags.Static)
              .GetValue(null);
    }
}

Cette approche est utilisée dans EqualityComparer<T>.Default. Bien sûr, ce n'est pas utilisé pour ce problème. Vous devriez vraiment envisager de faire abstraction de GetValue et le remplacer dans chaque classe dérivée.

Answer 5

Qu'en est-ce?

    class Base {
    protected static SomeObjectType myVariable;

    protected void doSomething()
    {
    Console.WriteLine( myVariable.SomeProperty );
    }
    }

    class AAA : Base
    {
    static AAA()
    {
    myVariable = new SomeObjectType();
    myVariable.SomeProperty = "A";
    }
    }

    class BBB : Base
    {
    static BBB()
    {
    myVariable = new SomeObjectType();
    myVariable.SomeProperty = "B";
    }
    }

Il fonctionne pour moi. Ce serait encore plus agréable avec l'interface.