How can I downcast an instance generated by static method?

Question

I have a problem with a C# program that includes the following :

class Program
{
    static void Main(string[] args)
    {
        Child childInstance = Child.ParseFromA(@"path/to/Afile") as Child;
    }
}

class Parent{
    int property;

    public static Parent ParseFromA(string filename)
    {
        Parent parent = new Parent();
        // parse file and set property here...
        return parent;
    }
}

class Child : Parent
{
    public void SomeAdditionalFunction() { }
}

When running this code, childInstance becomes null.

I tried below assignment with explicit cast, but ended with an exception :
Child childInstance = (Child)Child.ParseFromA(@"path/to/Afile");

Since I want to parse some types of files into Parent and Child instance, I want to keep the design that generates instances by static methods.

How should I get a proper childInstance?

Answer 1

You cannot downcast it. Once an object has been created as a Parent, it will always be a Parent. It's like trying to downcast a new object() to a string: That just won't work - which character sequence should this string represent?

Thus, your only solution is to create the correct object. The only option I see in your case is to make your static method generic:

public static T ParseFromA<T>(string filename) where T : Parent, new()
{
    T t = new T();
    // parse file and set property here...
    return t;
}

Usage:

Child childInstance = Parent.ParseFromA<Child>(@"path/to/Afile");

The generic constraint T : Parent ensures that T is a subtype of Parent, and new() ensures that T has a parameterless constructor.

Answer 2

If you insist on using static methods and do not want to use reflection or generics, then you can also consider using new keyword:

class Parent
{
    public static Parent ParseFromA(string filename)
    {
        Parent parent = new Parent();
        parent.Parse(filename);
        return parent;
    }

    protected virtual void Parse(string fileName)
    {
        ...
    }
}

class Child : Parent
{
    public new static Child ParseFromA(string filename)
    {
        Child child = new Child();
        child.Parse(filename);
        return parent;
    }

    protected override void Parse(string fileName)
    {
        base.Parse(fileName);
        SomeAdditionalFunction();
    }
}

Personally I would just use instance methods.

var child = new Child(...);
child.Parse(...);

An extra line of code is a small price to pay for cleaner code, IMHO. static keyword does not play well with inheritance, as you can see. You can also always wrap instance method into extension method, if you want a one-liner after all:

public static class ParentEx
{
    public static T ParseFile<T>(this T source, string fileName) : where T : Parent
    {
        source.Parse(fileName);
        return source;
    }
}

and then

var child = new Child().ParseFile(fileName);