Is there a way to enforce the existence of a static member in a child class in C#?

For a tile-based game I'm using different classes to describe the behaviour of the different tile types. They (obviously) derive from a base class. Now I have the problem that sometimes I need to figure out whether the player has enough funds to pay for an upgrade to a certain tile type.

Since the cost of a tile type remains the same all the time, it would seem to make sense to make that static. Unfortunately, C# does not seem to allow the use of abstract classes or interfaces to enforce the existence of such a static field in a child class.

My "solution" was to get this data using reflection, but it seems to me rather ugly and potentially dangerous, since I might forget the static field in one of the child classes, which would bring down the whole thing …

The following code snippet is what I currently have; AllowedUpdates is a List<System.Type> containing the types a tile can be upgraded to.

foreach (Type t in AllowedUpdates) {

    // Get the Action Point Cost
    FieldInfo fi = t.GetField ("actionPointCost", BindingFlags.NonPublic | BindingFlags.Static);
    int cost = (int)fi.GetValue (null);

    // Check for any requirements
    bool requirementsFulfilled;
    try {
        // Get the static method that checks the necessary requirements.
        MethodInfo mi = t.GetMethod ("CheckRequirements", new Type[] { typeof(Dictionary<string, ProtoObject>) });
        object[] arguments = { neighbourFields };

        // Invoke this method
        object returnValue = mi.Invoke (null, arguments);
        requirementsFulfilled = (bool)returnValue;
    } catch (ArgumentNullException) {
        // This type has no special requirements, pass it.
        requirementsFulfilled = true开发者_JAVA技巧;
    } catch (NullReferenceException) {
        // No requirements needed, pass it.
        requirementsFulfilled = true;
    }
}

There must be a better way to do that. Is there a design pattern I overlooked?

You cannot enforce, either by an abstract base class or an interface, the existence of a static member on any derived class.

Reflection is not your best bet here. Reconsider your usage of static classes in this case. You might make the cost of a tile type an abstract read-only property. Derived classes will be forced to implement the property.

public abstract int ActionPointCost { get; }

No, this is not possible. You would either need to instantiate an instance and use an instance field/property (which could possibly be faster than the reflection you are currently doing). Or you can keep a Dictionary<Tile, int> that stores the value you need.

Refactor metadata about tiles to another class hierarchy where you have things like cost etc.

No. Interfaces and Abstract classes don't allow you to enforce that.

The reason is they are attached to instances of these classes than definitions of them. There is a good post by Eric Lippert on this but I can't find that link right now.

One way I think you could enforce is using Reflection on startup of your application. If every class that must have a specific static member does not have it, fail the application.

Other way could be using post-build action to check these constraints like Code Contracts do.

You came to the conclusion that a static field is the right design choice for this problem, but the implementation consists of very messy reflection to force the acceptance of your design choice.

I would argue that if the implementation becomes messy for no gain other than "it seems it should", then the design is wrong.

Make it a read-only instance field that must be set by the constructor. Seriously, you'll save yourself a headache.