Can I have a base class where each derived class has its own copy of a static property?

Question

I have something like the following situation below:

class Base
{
     public static int x;
     public int myMethod()
     {
          x += 5;
          ret         


        

Answer 1

I usually implement subclass specific stuff as an abstract get property

public class Base
{
    // You must pick one option below

    // if you have a default value in the base class
    public virtual int x { get { return 7; /* magic default value */} }

    // if you don't have a default value
    // if you choose this alternative you must also make the Base class abstract
    public abstract int x { get; }
}

public class DerivedA : Base
{
    public override int x { get { return 5; } }
}

public class DerivedB : Base
{
    public override int x { get { return 10; } }
}

Answer 2

You will need to redefine and hide the field and method in all derived types.

Example:

class DerivedA : Base
{
  public new static int x;
  public new int myMethod()
  {
    x += 5;
    return x;
  }
}

Note: don't do it this way. Fix your design.

Edit:

Actually, I have a similar construct. I solve it with an abstract (if you need a default value, use virtual) property which then gets used from the base class:

public abstract class Base
{
   public abstract string Name { get; }

   public void Refresh()
   {
     //do something with Name
   }
}

public class DerivedA
{
  public override string Name { get { return "Overview"; } }
}

You should be able to adjust that for your use case. You can of course make the property protected if only deriving classes should be able to see it.

Answer 3

Well, yes, you can, but it revolves around a bit of a trick with generics.

It is much better if you fix your design so that you don't need that static field, or at least not per descendant, but here goes:

class Base<TDescendant>
    where TDescendant : Base
{
     public static int x;
     public int myMethod()
     {
          x += 5;
          return x;
     }

}

class DerivedA : Base<DerivedA>
{
}

class DerivedB : Base<DerivedB>
{
}

This relies on the fact that a generic type with static fields will get a separate copy of those static fields for each type you invoke it with.

However, if you intend to descend from DerivedA or DerivedB, it gets tricky, so I wouldn't recommend going down this lane.

Answer 4

Static dictionary with Type as keys should do. I mean avoid logic repetition and different values for each derived type but shared among instances.

public class Base
{
    private static Dictionatry<Type,int> _values;

    public int MyMethod()
    {
        _values[this.GetType()]+=5;
        return _values[this.GetType()];
    }
}