There are always workarounds for genuinely type-safe scenarios - but
your modifications don't amount to a contradiction, since your code
doesn't enable covariance :)

-- Barry

Thanks David!

Your suggestions helped me quite a bit.  I've taken your sample code
and added a driver for it to see how it works and it works great!

Below is the sample working code + driver in case anyone else runs
across a similar issue.

using System;

namespace Sample
{
   // Base class for all Model objects.
   abstract class Model { }

   abstract class Dao { }

   // Base class for all Data Access Objects.
   abstract class Dao<TModel> : Dao where TModel : Model
   {
       public abstract TModel Get();
   }

   // Person model.
   class Person : Model { }

   // Data Access Object for a Person model.
   class PersonDao : Dao<Person>
   {
       public override Person Get()
       {
           return new Person();
       }
   }

   // Thing model.
   class Thing : Model { }

   // Data Access Object for a Thing model.
   class ThingDao : Dao<Thing>
   {
       public override Thing Get()
       {
           return new Thing();
       }
   }

   // Factory that returns the DAO for a model.
   class DaoFactory
   {
       public Dao<TModel> GetDao<TModel>() where TModel : Model
       {
           Dao dao = null;
           if (typeof(TModel) == typeof(Person))
           {
               dao = new PersonDao();
           }
           else if (typeof(TModel) == typeof(Thing))
           {
               dao = new ThingDao();
           }
           return (Dao<TModel>)dao;
       }
   }

   static class Driver
   {
       static void Main()
       {
           DaoFactory factory = new DaoFactory();

           Dao<Person> personDao = factory.GetDao<Person>();
           Console.WriteLine("DAO is " + personDao);
           Person p = personDao.Get();
           Console.WriteLine("Model is " + p);

           Dao<Thing> thingDao = factory.GetDao<Thing>();
           Console.WriteLine("DAO is " + thingDao);
           Thing t = thingDao.Get();
           Console.WriteLine("Model is " + t);

       }

   }
}

Hi David,

That's not contravariance.