Factory method for generic interface

I think this code is mortally wounded but would like some opinions before I take a new approach.

I am writing a factory method for the following interface.

public interface ITransformer<I, O>
{
   O Transform(I input);
}

Here is a possible implementation of the interface

public class CarToTruckTransformer : ITransformer<Car, Truck>
{
    public Truck Transform(Car input)
    {
        Truck output = new Truck();
        output.Seats = input.Seats - 2;
        output.BedSize = input.TrunkSize;
        output.Gunrack = true;
        return output;
    }
}

The first factory I did looks like this

static class Tr开发者_开发技巧ansformerFactory
{
    public static ITransformer<I, O> GetTransformer<I, O>()
    {
        if (typeof(I) == typeof(Car) && typeof(O) == typeof(Truck))
        {
            return (ITransformer<I, O>)new CarToTruckTransformer();
        }
        else
        {
            return null;
       }
    }
}

But I have to know the exact types when I call the factory method so it seems less than ideal.

ITransformer<Car, Truck> transf = TransformerFactory.GetTransformer<Car, Truck>();

I have also toyed with the following, but I'm afraid this may be a gross misuse of the dynamic keyword.

public class TransformerFactory2
{
    public static dynamic GetTransformer(VehicleBase input, VehicleBase output)
    {
        if (input.GetType() == typeof(Car) && output.GetType() == typeof(Truck))
        {
            return (ITransformer<Car, Truck>)new CarToTruckTransformer();
        }
        else
        {
            return null;
        }
    }
}

But it does allow me to get the factory syntax that I want.

dynamic transf = TransformerFactory2.GetTransformer(car, truck);

I've also considered the first option but calling the factory method with reflection so I could dynamically assign the type variables.

Ultimately, I would like the entire "transform" process to be contained in one reusable method and just implement new transformers when needed but I'm not there yet.

Is there a better or safer approach for this kind of situation?

Thanks for reading.

This is way off topic if you are interested in exploring OOP and Patterns but this specific example you are describing can be fairly neatly described using Func<I,O> delegates.

e.g.

var car = getSomeCar();
car.select(c => new Truck{
   :
   :
});

And you define select as a generic extension method on I

e.g.

public static O select<I,O>(this I input, Func<I,O> project)
{
   return project(input);
}

Just a thought.

Edit

Just tested this and it should work fine :) Renamed transform to select to highlight the similarity to the Linq operator.