substitute for static inheritance

Question

I currently have a number of classes (~20) that all do the same thing (abstractly), namely, generate an instance of a particular class from an xml file.

The way that they use the content of the xml file varies quite a bit, and the data gets stored into different substructures (fields, groups, etc) that are shared across the classes, so I took all of the parsing and field information out of the files, and created a helper class (as is the final constructed type)

All of the above classes and methods are static, as they have no need to contain any state.

I then wanted to have all the classes derive from one common class so that I am not referencing a seemingly unrelated class constantly, only to discover that inheritance and static do not work together well.

What is the appropriate way of setting this up? Its bascially a large set of factory methods for a type that require no state.

Update: The control flow is currently as follows:

1. Pick one of ~20 factory methods
2. Read in an XML file (all tags, attributes are the same across the files, but the files are distict across the methods).
3. Convert the content in the XML files to a class that has some data structures as members (List<Field>, List<Group>, Dictionary<string,string> etc). These data structures use types that are nested in the helper.
4. Add these collections to the uninitialized object.
5. Return the object to caller.

Right now, the 20 factory methods are thier own static classes, and all return objects of the same type, as even though there might be some semantic difference between the "types" all of the memebers and functions are the same. The code that parses the XML file is in a helper, as this logic is common to all of the factory methods. Step 3 has to be different for all the methods, so that part is found in the static classes.

Answer 1

I failed to understand why one might need 20 classes here. I think it takes one class with 20+ methods.

class XMLMaker {
  public OutputClassA ParseA(File input) { ... }
  public OutputClassB ParseB(File input) { ... }
  // etc, however many classes you need to create
  //
  // reusable helper methods for the public methods above
  protected XML.Node _ParseFoo(...) {...}
  protected string _ParseBar(...) {...}
  //
  // I can imagine you might want it, too:
  public OutputClass Parse(File input) {
    var file_kind = _DetectKind(input);
    if (file_kind == KIND_A) return ParseA(input);
    // etc
  }
}

I can also imagine that you can spread ParseA, ParseB, etc into a manageable set of separate files by making XMLMaker a partial class.

XMLMaker does not need to store any state, so it can be instantiated once by a caching factory, or by a DI mechanism.

Answer 2

I then wanted to have all the classes derive from one common class so that I am not referencing a seemingly unrelated class constantly, only to discover that inheritance and static do not work together well.

I was with you up to this point, but this bit sounds like a misuse of inheritance.

If you feel like your classes are too tightly bound to the helper class, concentrate on improving the public interface of the helper class.

Answer 3

1. Pick one of ~20 factory methods

This part is interesting and may hold the key to solving this problem. How do you 'pick' the appropriate factory method? Is there a Factory class? Without an example it's quite difficult to provide a concrete answer but the way I would envisage solving this problem is as follows:

public abstract class BaseClass
{
    //common code and maybe some abstract methods

    //This could (should?) go into it's own class.
    public static BaseClass Factory(File file)
    {
        if (something)
        {
            return Class1.Create(file) //or just call the constructor
        }
        if (somethingElse)
        {
            return Class2.Create(file)...
        }
    }
}

public class Class1 : BaseClass
{
    //private constructor so that you have to go through the Create() method
    private Class1()
    {}

    //variables/code for handling the file and populating the variables

    private void ParseFile(File file)
    {
    }

    public static Class1 Create(File file)
    {
        Class1 class1 = new Class1();
        class1.ParseFile(file);
        return class1;
    }
}

Obviously this is all pseudo-code!

I note that you say that the classes don't need to hold any state which is why they are static but something about that along with the need for inheritance doesn't quite add up. With my code you would call the Factory method on the base class (or in it's own class if you so desire) passing in each file and what you end up with is a list of BaseClasses which you pass back to the caller who presumably does something with them.

Perhaps if you could provide more detail of what you start with, what you want to end up with, and what you do in the middle we could offer some more concrete advice.

Answer 4

I then wanted to have all the classes derive from one common class so that I am not referencing a seemingly unrelated class constantly

That is your mental error here - you seem to believe that "inheritance" is somehow better for reuse than using a separate helper class. In fact, in most cases the opposite is the case, and since all of your classes are static, you won't get any benefits from inheritance, even if you could use that here. Your example shows exactly the kind of thinking which leads into typical wrong use of inheritance. Better give your helper class a better name so it does not seem to be so "unrelated".