Herstellung haben eine übergeordnete Klasse eine statische Variable, die für jede Unterklasse in c # anders

Question

Ohne Code in den Unterklassen , würde ich eine abstrakte Klasse wie für jede Unterklasse eine andere Kopie einer statischen Variablen haben. In C #

abstract class ClassA
{
    static string theValue;

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

und (zum Beispiel):

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

Meine aktuelle Lösung ist folgende:

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

Das funktioniert zwar gut, ich frage mich, ob es eine elegantere oder integrierte Möglichkeit, dies zu tun?

Dies ist ähnlich wie haben ich habe verschiedene Kopien einer statischen variablen für jede andere Art von Vererbungs Klasse , aber ich habe keine Kontrolle über die Unterklassen

Answer 1

  

Das funktioniert zwar gut, ich frage mich, ob es eine elegantere oder integrierte Möglichkeit, dies zu tun?

Es ist nicht wirklich eine eingebaute Möglichkeit, dies zu tun, wie Sie Art Grund OO Prinzipien zu verletzen hier. Ihre Basisklasse sollte keine Kenntnis von Subklassen in traditioneller objektorientierter Theorie hat.

Dass gesagt wird, wenn Sie dies tun müssen, ist Ihre Implementierung wahrscheinlich so gut, wie Sie bekommen werden, wenn Sie direkt eine andere Infos zu den Unterklassen hinzufügen. Wenn Sie diese Kontrolle zu müssen, und Sie können nicht Subklassen ändern, wird dies wahrscheinlich die beste Ansatz sein.

Answer 2

Es gibt einen eleganteren Weg. Sie können die Tatsache, dass die Statik in einem allgemeinen Basisklasse auszubeuten für jede abgeleitete Klasse eines anderen Typs verschieden sind

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

Für jedes Kind Klasse wird die statische int x für jeden eindeutigen T eindeutig sein Hier können zwei Kinder Klassen ableiten, und wir verwenden den Namen des Kindes Klasse, die als generische T in der Basisklasse.

public class ChildA: BaseClass<ChildA>
{
}

public class ChildB : BaseClass<ChildB>
{
}

Nun ist die statische MyProperty ist einzigartig für beide Childa und ChildB

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

Answer 3

Dies ist ein wenig anders als das, was für Sie fragen, aber vielleicht führt die gleiche Sache.

    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

Es gibt eine alternative Lösung, die als Sie könnte oder nicht besser sein könnte, je nach Anwendungsfall:

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

Dieser Ansatz wird in EqualityComparer<T>.Default verwendet. Natürlich ist es nicht für dieses Problem verwendet. Sie sollten wirklich überlegen GetValue abstrakt zu machen und es in jeder abgeleiteten Klasse überschreiben.

Answer 5

Was ist das?

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

Es funktioniert für mich. Wäre ja noch schöner mit Schnittstelle.