C#: How do I call a static method of a base class from a static method of a derived class?

Question

In C#, I have base class Product and derived class Widget.

Product contains a static method MyMethod().

I want to call static method Product.MyMethod() from static method Widget.MyMethod().

I can't use the base keyword, because that only works with instance methods.

I can call Product.MyMethod() explicitly, but if I later change Widget to derive from another class, I have to revise the method.

Is there some syntax in C# similar to base that allows me to call a static method from a base class from a static method of a derived class?

Answer 1

static methods are basically a method to fallback from object oriented concepts. As a consequence, they are not very flexible in inheritance hierarchies and it's not possible to do such a thing directly.

The closest thing I can think of is a using directive.

using mybaseclass = Namespace.BaseClass;

class MyClass : mybaseclass {

  static void MyMethod() {  mybaseclass.BaseStaticMethod();  }

}

Answer 2

Having into account that a Static method shoudn't relay in instance data... you should have a static "MyMethod" that behaves diferent based on a parameter or something like that.

Remember that the static method defined in one class is just a way to order your code... but it is the same if that method is placed elsewhere... because it don't relay on the object where it is placed.

EDIT: I think your best choise is to use Product.MyMethod explicitly... If you think it... it should't be probable that your Widget change its base clase... and also in that case it is a minor change in code.

Answer 3

Static methods are not polymorphic, so what you want to do is impossible.

Trying to find a way to treat static methods as polymorphic is possible but dangerous, because the language itself doesn't support it.

Some suggestions:

• Reflection
• Aliasing the base class (such as Mehrdad's example)

Answer 4

It can be done, but I don't recommend it.

public class Parent1
{
    public static void Foo()
    {
        Console.WriteLine("Parent1");
    }
}

public class Child : Parent1
{
    public new static void Foo()
    {
        Type parent = typeof(Child).BaseType;
        MethodInfo[] methods = parent.GetMethods();
        MethodInfo foo = methods.First(m => m.Name == "Foo");
        foo.Invoke(null, null);
    }
}

Answer 5

Static methods are "Class-Level" methods. They are intended to be methods that apply to all instances of a specific class. Thus, inheritance of this method does not make sense as it would change the meaning to apply to instances of the class. For instance, if you were looping through a collection of Products (some of Widget, some not) and called MyMethod on each Product then the method that was called would be determined by the instance of the class. This violates the purpose of static methods.

You can probably do something like you want more cleanly by simply not using static methods at all, because in your example it does not seem like MyMethod applies to all instances of Product. However, you can achieve the same affect you are describing by using an interface class like ‘IMyMethod’. This approach is still not using a static method. I guess I’m not seeing a need for a static method. Why do you want to use a static method to begin with?

Answer 6

My idea is to create a Key, Value Pair Enum. Can someone comment on this approach? Especially on the static methods. Is it a good idea to overload static methods?

public class NameValueEnum<K, V>
{
    private K _key;
    private V _value;

    private static IList<NameValueEnum<K, V>> _list = new List<NameValueEnum<K, V>>();
    private NameValueEnum() { }
    public NameValueEnum(K key, V value)
    {
        this._key = key;
        this._value = value;
        _list.Add(this);
    }

    public static NameValueEnum<K, V> Parse(K key)
    {
        NameValueEnum<K, V> nve= null;
        for (int i = 0; i < _list.Count - 1; i++)
        {
            nve = _list[i];

            if (nve._key.Equals(key))
            {
                return nve;
            }
        }
        return null;
    }

    public static NameValueEnum<K, V> Parse(V value)
    {
        NameValueEnum<K, V> nve = null;
        for (int i = 0; i < _list.Count - 1; i++)
        {
            nve = _list[i];
            if (nve._value.Equals(value))
            {
                return nve;
            }
        }
        return null;
    }
}

public sealed class Status : NameValueEnum<string, Guid>
{
    public static Status Active = 
            new Status("Active", new Guid("506182B0-A123-4C21-BD2B-B758F6F635F3"));
    public static Status InActive = 
            new Status("In-Active", new Guid("D83FAFF8-69B0-4CC8-BE24-B28B47D11A01"));
    public static Status Suspended = 
            new Status("Suspended", new Guid("8FDE34CB-DB0F-47C8-B8AA-0C7D269CD0C9"));

    private Status(String Key, Guid Value) : base(Key, Value) {}

    public static new Status Parse(String key)
    {
        return (Status)NameValueEnum<String, Guid>.Parse(key);
    }

    public static new Status Parse(Guid value)
    {
        return (Status)NameValueEnum<String, Guid>.Parse(value);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Program p = new Program();
        p.f1();
    }
    private void f1()
    {
        Status s =
            Status.Parse(new Guid("506182B0-A123-4C21-BD2B-B758F6F635F3"));
    }
}