C#: Can a base class use a derived class's variable in a static function?

Question

Is there anyway of having a base class use a derived class's static variable in C#? Something like this:

class Program
{
    static void Main(string[] args)
    {
        int Result = DerivedClass.DoubleNumber();
        Console.WriteLine(Result.ToString());   // Returns 0
    }
}

class BaseClass
{
    public static int MyNumber;

    public static int DoubleNumber()
    {
        return (MyNumber*2);
    }
}

class DerivedClass : BaseClass
{
    public new static int MyNumber = 5;
}

I'm trying to have it return 10, but I'm getting 0.

Here's where I'm using this: I have a class called ProfilePictures with a static function called GetTempSavePath, which takes a user id as an argument and returns a physical path to the temp file. The path base is a static variable called TempPath. Since I'm using this class in multiple projects and they have different TempPaths, I'm creating a derived class that sets that variable to whatever the path is for the project.

See Also

Why can’t I declare C# methods virtual and static?

Answer 1

This kinda works:

public class ClassA
{
    protected static int num = 5;

    public static int GetNum()
    {
        return num;
    }
}

public class ClassB : ClassA
{
    static ClassB()
    {
        num = 6;
    }
}

However, note the difference when you call ClassB.GetNum() before and after instantiating one object. The static initializer doesn't run until you create at least one, so you'll get 5 if nothing has been created, and 6 if at least one object has.

Answer 2

Using too much of static members is also not recommended if they are going to encapsulate a logic of an entire object. For example your code can be rewritten correctly in following manner... and this is the most recommended in oops,

class Program
{
    static void Main(string[] args)
    {
        int Result = DerivedClass.Instance.DoubleNumber();
        Console.WriteLine(Result.ToString());   // Returns 0
    }
}

class BaseClass
{
    protected BaseClass(){} // this enforces that it can not be created

    public int MyNumber;

    public virtual int DoubleNumber()
    {
        return (MyNumber*2);
    }
}

public class DerivedClass : BaseClass
{
    // this also ensures that it can not be created outside
    protected DerivedClass(){
        MyNumber = 5;
    }

    // only way to access this is by Instance member...
    public static DerivedClass Instance = new DerivedClass();
}

This is how we access configuration values and many other single instance static objects provided by .Net Library.

Answer 3

Apart from the fact that has already been pointed out... that static variables are tied or bound to the specific class declaring them and cannot be overridden. Overriding/Polymorphism needs instances to work.

Your problem can be solved with a change in design.

string ProfilePictures.GetTempSavePath(SomeType UserId, string sBasePath)

if it just needs these 2 variables to compute the return value, you can keep it as a utility/static method. Now you can feed in different base paths..

Now it seems from your question, that you need to use this class in multiple projects (which have fixed base paths) and kind of hardcode the base path so that you dont have to specify it for each call. Type/Class hierarchies should be defined based on behavior and not on data. Variables can handle change in data. Hence I'd suggest holding the basepath value as a static member variable, which is initialized from a resource file (DoubleClick your project properties node > Settings > Add a new Settings file > add a new setting called BasePath - string - Application scope - VALUE=C:\Users). Now you just need to tweak the app.config file for each project, no code changes, no hardcoding and not more than one type needed.

public class PathHelper
{
  static string _sBasePath;
  static PathHelper()
  {
     _sBasePath = Properties.Settings.Default.BasePath;
  }

  static string GetTempSavePath(string sUserId)
  {
     // dummy logic to compute return value, replace to taste
     return Path.Combine(_sBasePath, sUserId.Substring(0, 4));
  }
}

Hope that made sense

Answer 4

Static members are not virtual, so you can not override them.

When you call DerivedClass.DoubleNumber you are actually calling BaseClass.DoubleNumber as the DerivedClass class doesn't have that method. Also, the use of MyNumber in that method is always going to be BaseClass.MyNumber no matter how you call the method.

What you are looking for is a virtual property that you can override in a derived class. As a virtual member can not be static, you need to use an instance of the class. If it's not practical to keep a reference to the instance, you can use the singleton pattern.

Answer 5

The problem is that you're re-declaring the static variable in the derived class. The MyNumber declaration in DerivedClass hides the declaration in the base class. If you remove that declaration, then references to the "MyNumber" in derived class static functions will refer to the base class variable. Of course, if you remove the declaration then you can't use a static initializer in the derived class.

You might want to consider requiring users to instantiate an instance of ProfilePictures rather than provide a static function for GetTempSavePath. That way you could overide the GetTempSavePath method to provide the correct TempPath. Or, you could simply set the value of the static path value in your derived class constructor.

Although it is possible to use inheritance with static members, you can't relly have polymorphic behavior without a "this" pointer.

Answer 6

Provide a virtual method that returns the class static.

class BaseClass
{
    public virtual int GetMyNumber() { return MyNumber; }
}

You might want to use a virtual property instead...