Hacer una superclase tiene una variable estática que es diferente para cada subclase en C#

Question

Sin ningún código en las subclases, me gustaría que una clase abstracta tenga una copia diferente de una variable estática para cada subclase. En C#

abstract class ClassA 
{ 
    static string theValue; 

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

y (por ejemplo):

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

Mi solución actual es la siguiente:

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

Aunque esto funciona bien, me pregunto si hay una manera más elegante o forma incorporada de hacer esto?

Esto es similar a Can I have different copies of a static variable for each different type of inheriting class, pero no tengo ningún control sobre las subclases

Answer 1

Aunque esto funciona bien, me pregunto si hay una manera más elegante o incorporada de hacer esto?

En realidad, no hay una forma integrada de hacerlo, ya que estás violando los principios básicos de OO aquí. Su clase base no debería tener conocimiento de subclases en la teoría tradicional orientada a objetos.

Dicho esto, si debe hacer esto, su implementación es probablemente tan buena como la que obtendrá, a menos que pueda agregar otra información a las subclases directamente. Si necesita controlar esto, y no puede cambiar las subclases, este será probablemente su mejor enfoque.

Answer 2

Hay una solución alternativa que podría o no podría ser mejor que el suyo, dependiendo del caso de uso:

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

Este enfoque se utiliza en EqualityComparer<T>.Default. Por supuesto, no se usa para este problema. Realmente debería considerar hacer GetValue abstracto y anularlo en cada clase derivada.

Answer 3

Esto es un poco diferente de lo que está pidiendo, pero quizás logra lo mismo.

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

¿Qué tal esto?

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

Funciona para mí. Sería aún mejor con Interface.