C# access children's static member in parent

Question

I have a class Foo, which is a base class for a lot other classes such as Bar and Baz, and I want to do some calculation within Foo using the static members in Bar and Baz, as shown below:

public class Foo{
    public result1 {
         get{
             return field1;
         }
    }
}

public class Bar : Foo{
    public const int field1 = 5;
}

public class Baz : Foo{
    public const int field1 = 10;
}

The only solution I can think of is wrap all the fields in a container, add an extra identifier for each object, and use a function to return the fields, like so

Bar : Foo{
    public readonly int id = 0;
    public static Wrapper wrapper;
}

public Wrapper GetWrapper(int id){
    switch(id){
        case 0:
            return Bar.wrapper;
    }
}

However, as you can see, I need to maintain one additional class and function, and I'd rather not to fragment my code. Is there any alternative?

Answer 1

I always feel like a jerk when I answer my own question... Yet didn't see what I was expecting so I might as well just share what I've got after a night of mind boggling.

The reason I don't want to make the calculation abstract/virtual is because there are many subclasses and the formula is the same for all of them. I just refuse to type the same code 10-20 times repeatedly.

Couldn't make the static fields non static either, as they should be accessible at a class level plus they can get big, and they are the same for all instances.

The only solution I can come up that minimizes code fragment is something like this

public class Foo {
    public class Wrapper {
        Fields...
    }
    public Wrapper wrapper; // reference
    public int result1 { get; }
}

public class Bar : Foo {
    public static Wrapper subclassWrapper; // put in the implementation
    public Bar() : base(){
        wrapper = subclassWrapper;
    }
}

So each instance now needs to hold an extra reference, however I don't need to keep a function. The wrapper is kept within the base class so it is less fragmented.

Answer 2

Edit

What you are asking for, i.e. accessing a static or const value in a subclass from a base class is technically possible, but doing so will violate the principals of good SOLID OO design. Also, since you will need an instance of a specific subclass in order to be able to 'reason over' the type of the subclass in order to obtain the appropriate field1, there's little point approaching this problem statically.

Instead, the common, cleaner, approach here is to use subtype polymorphicism which will allow a calling method in the base class, or a method in an external class altogether, to access the appropriate value for 'field1' based on the subclass. This allows control over the value returned to remain inside the appropriate subclasses (i.e. as per your words, the code won't become "fragmented").

Alternative solution using subclass polymorphicism (recommended)

A subclass polymorphic approach (i.e. with the virtual/abstract and override keywords) will allow you to encapsulate the retrieval of a value (or object) which is customizable for each subclass. Here, the abstraction remains conceptually at "give me an integer value", and then the sub-class-specific implementations of 'how' to return the value can be abstracted (hidden) from the caller. Also, by marking the base property as abstract, you will force all subclasses to implement the property, so that the requirement to provide a value isn't forgotten about.

i.e. I would recommend a polymorphic approach like this:

public abstract class Foo
{
    public abstract int Result { get;  }
}

public class Bar : Foo
{
    // This is implementation specific. Hide it.
    private const int field1 = 5;

    public override int Result 
    { 
        get { return field1; }
    }
}

public class Baz : Foo
{
    public override int Result 
    { 
        // No need for this implementation to be a constant ...
        get { return TheResultOfAReallyComplexCalculationHere(); }
    }
}

If there are no other reusable concrete methods on the base class Foo, then you could also model the abstraction as an interface, with the same effect:

public interface IFoo
{
    int Result { get;  }
}

Approaching this problem without polymorphicism (Not recommended)

Any compile-time attempt to access static fields on subclasses will typically require code somewhere to switch (or map) on the actually type of the subclass instance, e.g.:

public class Foo
{
    public int result1 
    {
         get
         {
             switch(this.GetType().Name)
             {
                case "Bar":
                    return Bar.field1;
                case "Baz":
                    return Baz.field1;
                default:
                    return 0;
             }
         }
    }

    public void MethodRequiringValueFromSubclass()
    {
        Console.WriteLine(result1);
    }
}

public class Bar : Foo
{
    public const int field1 = 5;
}

public class Baz : Foo
{
    public const int field1 = 10;
}

The problem here is that the Open and Closed principal is violated, as each time a new sub class is added, the result1 method would need to be changed to accomodate the new class.

Answer 3

Instead of making Foo abstract as other answers suggested you can use virtual and override result1 in each child class

public class Foo
{
    public virtual int result1 { get; }
}

public class Bar : Foo
{
    public const int field1 = 5;

    public override int result1
    {
        get { return field1; }
    }
}

public class Baz : Foo
{
    public const int field1 = 10;

    public override int result1
    {
        get { return field1; }
    }
}

If you want default result1 to return something else than 0 you can give it another value

public class Foo
{
    public virtual int result1 { get; } = -1;
}

Answer 4

You either add constructor parameter to your Foo class which can be passed from inheritors, thus you don't need extra classes also you'll have less coupling

public class Foo
{
    private readonly int _field1;
    public Foo(int field1)
    {
         _field1 = field1;
    }
}

or you can use it exactly from inheritors type as static/const members are members of class type

public class Foo
{
    public result1 
    {
         get
         {
             return Bar.field1;
         }
    }
}

but this gives your code less flexibility and more coupling.

Also you have an option by using virtual properties which you can implement in derrived classes and use in base:

public class Foo
{
    public virtual int Field { get { return 0; } }
}

Answer 5

I'd suggest to use abstract function rather that using static member.

public abstract class Foo{
    public result1 {
         get{
             return get_field1();
         }
    }
    protected abstract int get_field1();
}

public class Bar : Foo{
    public const int field1 = 5;
    protected override int get_field1() { return field1;}
}

public class Baz : Foo{
    public const int field1 = 10;
    protected override int get_field1() { return field1;}
}