Question

I currently have an inheritance structure where the return type of a method is being left as an open generic so that each class can return an object from the corresponding level of another structure. For example, lets say we had a VehicleFactory where TVehicle:Vehicle that could ProduceVehicle TVehicle. I also have CarFactory:VehicleFactory where TVehicle:Car.

Car inherits from Vehicle, so all this is valid and allows me to know that my CarFactory must produce Cars and my Vehicle factory may produce any kind of vehicle. The problem I have run in to is that I need a way to instantiate a VehicleFactory as a CarFactory when it is being run by Ford, but as a BoatFactory when being run by Wave Runner.

I thought I could do this by creating an interface that matched the functionality of VehicleFactory and writing a MakeFactory method that returns an IVehicleFactory (which would return vehicles non-genericly). Since CarFactory returns cars, which are vehicles, it fulfills the interface and all should be right in the world. The unexpected problem is that VehicleFactory fails to meet the interface that is closed as TVehicle being Vehicle, despite the fact that TVehicle must be a Vehicle.

Does anyone know why this is or if there is another way to work around this limitation? If there isn’t a way around this limitation directly, are there any alternative methods for having a shared set of functionality ensure that it is always instantiated as one of two or more sets of more specific classes. (Where Vehicle is the shared layer and Car and Boat are the context specific layers.)

class Vehicle
{
}

class Car : Vehicle
{
}

interface IVehicleFactory
{
     Vehicle ProduceVehicle();
}

class VehicleFactory<TVehicle> : IVehicleFactory
    where TVehicle:Vehicle
{
    public virtual TVehicle ProduceVehicle()
    {
    }
}

class CarFactory<TVehicle> : VehicleFactory<TVehicle>
    where TVehicle : Car
{
    public override TVehicle ProduceVehicle()
    {
    }
}

And the code using it

static IVehicleFactory CreateVehicleFactory()
{
    if(somecondition)
    {
         Return new CarFactory<Car>();
    }
    else
    {
         Return new BoatFactory<Boat>();
    }
}

Adding some more detail to clarify the problem.

The use of the term factory is not intended to imply a factory pattern. It is actually a repository that is retrieving a “vehicle.” The type of vehicle is an application specific version of a library with a common shared base code. The repositories for each application Car and Boat may have different logic for the same retrieval and may be dependent on fields in the Car or Boat variant of their object. I need a way to build a factory which can look at the context of the application I am in and return the appropriate repository (BoatFactory or CarFactory), such that the shared code at the Vehicle level will properly use any application specific overridden functionality.

Answer 1

Well, while I don’t have a solution to how to make it work yet, (at least not in full), I think I now understand the problem. One of my initial assumptions appears to have been incorrect. I was under the impression that a less specific return type on an interface could be fulfilled by a more specific type. ie, an interface defining SomeBaseClass as a return type for a method can not be implemented by a class that implements the method returning SomeChildClass where SomeChildClass inherits from SomeBaseClass.

The use of covariant generics (via the out keyword) does provide some manner of ability to circumvent this by allowing the interface to be generically defined, however for my purposes, this falls apart when I hit results that need to be IList based (which requires an invariant type parameter).

Ultimately, the best it appears that can be done is that I can make it so that CarFactory only understands that it is working with a vehicle (by removing the additional where condition on the TVehicle generic parameter), requiring a cast within CarFactory, however when ever CarCompany instantiates CarFactory, it can still make it as CarFactory and the client code itself will not have to worry about a cast.

It’s not ideal, but I think it may be the best possible due to C#’s lack of covariant return types.

interface IVehicleFactory<TVehicle> where TVehicle:Vehicle
{
    TVehicle SomeMethod();
}

VehicleFactory<TVehicle> : IVehilceFactory<TVehicle> where TVehicle:Vehicle
{
    TVehicle SomeMethod()
    {
    }
}

CarFactory<TVehicle> : IVehicleFactory<TVehicle> where TVehicle:Vehicle
{
    TVehicle SomeMethod()
    {
       ~~Always returns car and uses cast from Vehicle when necessary.
    }
}

class VehicleFactory<TVehicle>
{
   static IVehicleFactory<TVehicle> CreateContextSpecificFactory()
   {
       if(someCondition)
       {
            return new CarFactory<TVehicle>;
       }
   }
}

class CarCompany
{
    CarFactory<Car> carFactory = new CarFactory<Car>;
    Car car = carFactory.SomeMethod();
}

class VehicleCompany
{
    VehicleFactory<Vehicle> vehicleFactory = VehicleFactory<Vehicle>.CreateContextSpecificFactory();
}