Question

I’m trying to make an app I’m designing more generic and implement the command pattern into it to use manager classes to invoke methods exposed by interfaces.

I have several classes with the GetItem() and GetList() methods in them, some are overloaded. They accept different parameters as I was trying to use dependency injection, and they return different types. Here are a couple of examples:

 class DatastoreHelper
    {
        public Datastore GetItem(string DatastoreName)
        {
            // return new Datastore(); from somewhere
        }
        public Datastore GetItem(int DatastoreID)
        {
            // return new Datastore(); from somewhere
        }
        public List<Datastore> GetList()
        {
           // return List<Datastore>(); from somewhere
        }
        public List<Datastore> GetList(HostSystem myHostSystem)
        {
           // return List<Datastore>(); from somewhere
        }

    }
    class HostSystemHelper
    {
        public HostSystem GetItem(int HostSystemID)
        {
          //  return new HostSystem(); from somewhere
        }
        public List<HostSystem> GetList(string ClusterName)
        {
            //return new List<HostSystem>(); from somewhere
        }
    }

I’m trying to figure out if I could use a generic interface for these two methods, and a manager class which would effectively be the controller. Doing this would increase the reuse ability of my manager class.

  interface IGetObjects
    {
        public object GetItem();
        public object GetList();
    }

class GetObjectsManager
{
    private IGetObjects mGetObject;
    public GetObjectsManager(IGetObjects GetObject)
    {
        this.mGetObject = GetObject;
    }
    public object GetItem()
    {
        return this.mGetObject.GetItem();
    }
    public object GetList()
    {
        return this.GetList();
    }
}

I know I’d have to ditch passing in the parameters to the methods themselves and use class properties instead, but I’d lose the dependency injection. I know I’d have to cast the return objects at the calling code into what they’re supposed to be. So my helper classes would then look like this:

class DatastoreHelper
{
    public string DatastoreName { get; set; }
    public string DatastoreID { get; set; }
    public object GetItem()
    {
        // return new Datastore(); from somewhere
    }
    public List<object> GetList()
    {
       // return List<Datastore>(); from somewhere
    }

}
class HostSystemHelper
{
    public int HostSystemID { get; set; }
    public string ClusterName {get; set;}
    public object GetItem()
    {
      //  return new HostSystem(); from somewhere
    }
    public List<object> GetList()
    {
        //return new List<HostSystem>(); from somewhere
    }
}

But is the above a good idea or am I trying to fit a pattern in somewhere it doesn’t belong?

EDIT: I’ve added some more overloaded methods to illustrate that my classes are complex and contain many methods, some overloaded many times according to different input params.

Answer 1

The first code samples look quite similar to the Repository Pattern. I think this is what are you trying to apply. The last sample is not good and Jon told you why. However, instead of reinventing the wheel, read a bit about the Repository (lots of questions about it on SO) because, if I understood correctly, this is what you really want.

About reuse, not many things and especially persistence interface are reusable. There is the Generic Repository Pattern (I consider it an anti-pattern) which tries to accomplish that but really, do all the application needs the same persistence interface?

As a general guideline, when you design an object, design it to fullfil the specific application needs, if it happens to be reused that’s a bonus, but that’s not a primary purpose of an object.