Question

Abstract class:

abstract class PersistentList<T>

public static PersistentList<T> GetInstanceOfDerivedClass()
{
    //???
}

Derived class:

public class Managers : PersistentList<Manager> 

So, I’d like to:

Managers managers = Managers.GetInstanceOfDerivedClass();

Is that possible?

Choices are:

int clientID = 3;

Managers managers = Managers.For("Client", new { ClientID = clientID});

Managers managers = new Managers(new { ClientID = clientID });

Managers managers = new Managers();
managers.ClientID = clientID;
managers.Load("ForClient");
//alternatively:
Database.Load(managers, "ForClient");

//this works, however requires the above code in the constructor.
Managers managers = new Managers(clientID);

//If the static method on the abstract class (Managers.For) could determine
//the type calling, it would eliminate the need for repetitive constructors.

All the above are available, just trying to decide on a good technique.

Answer 1

I think this is about the simplest it’ll be if you need strong typing (i.e. that the method will return Managers, not just PersistentList<Manager> when requesting a Managers):

static class PersistentList
{
    public static T GetInstanceOfDerivedClass<T, U>() where T : PersistentList<U>
    {
        throw new NotImplementedException();
    }
}

Managers managers = PersistentList.GetInstanceOfDerivedClass<Managers, Manager>();

You might also do:

abstract class PersistentList<T, U> where T : PersistentList<T, U>
{
    public static T GetInstanceOfDerivedClass()
    {
        throw new NotImplementedException();
    }
}
public class Managers : PersistentList<Managers, Manager>
{
}

This lets you use the signature in your example, Managers.GetInstanceOfDerivedClass(). I find this design pattern confusing, however, and would discourage its use.