Cualquier tipo de ayuda es bienvenida. Incluso si puede decir (según su experiencia) que usar un ORM para una jerarquía tan enorme es una locura :).

Backgroud Mi capa de modelo tiene una jerarquía de clases bastante grande, es decir, hay alrededor de 200 clases. Lo bueno / malo de la jerarquía es que todos ellos tienen la misma clase base. La distancia máxima entre las clases base y hoja es 7 y las clases de número máximo en cualquier nivel en la jerarquía es 80. Estoy usando nHibernar para guardar / cargar datos desde el almacenamiento persistente.

Problema Las consultas generadas por nHibernate son bastante eficientes. por ejemplo, si quiero seleccionar las identificaciones de los objetos en función de algún filtro en una propiedad de la clase base, NHibernate intentará unir todas las tablas en jerarquía / unirlas según la estrategia de mapeo que elija, es decir, tabla por subclase o tabla por clase jerarquía.

Entiendo que nHibernate no determina qué tipo de objeto hasta que pueda escanear todas las tablas relevantes. Pero qué pasa si solo estoy interesado en los datos de clase base en este momento. Cómo forzar a nHibernar a cargar solo los objetos de la clase base.

Para ilustrar mi problema, aquí hay una versión simplificada.

public class Vehicle
{
    public virtual Guid Identifier { get; set; }
    public virtual int WheelsCount { get; set; }
    public virtual Make Make { get; set; }
    public virtual Model Model { get; set; }
}

public class Bike : Vehicle
{
    public Bike()
    {
        WheelsCount = 2;
    }

    public virtual bool IsDirtBike { get; set; }
}

public class Car : Vehicle
{
    public Car()
    {
        WheelsCount = 4;
    }

    public virtual bool IsFourWheelDrive { get; set; }

    public virtual string Title { get; set; }
    public virtual string Description { get; set; }
}

public class Make
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual IList<Model> Models { get; set; }
}

public class Model
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual Make Make { get; set; }
}

Y las asignaciones son las siguientes

public class VehicleMap : ClassMap<Vehicle>
{
    public VehicleMap()
    {
        Id(x => x.Identifier).GeneratedBy.Guid();
        Map(x => x.WheelsCount);

        References(x => x.Make).Column("MakeId");
        References(x => x.Model).Column("ModelId");

        Table("Vehicle");
        Polymorphism.Explicit();
        UseUnionSubclassForInheritanceMapping();
    }
}

public class BikeMap : SubclassMap<Bike>
{
    public BikeMap()
    {
        Map(x => x.IsDirtBike);
        Table("Bike");
        // Abstract();
    }
}

public class CarMap : SubclassMap<Car>
{
    public CarMap()
    {
        Map(x => x.Title);
        Map(x => x.Description);
        Map(x => x.IsFourWheelDrive);
        Table("Car");
       // Abstract();
    }
}

public class MakeMap : ClassMap<Make>
{
    public MakeMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        HasMany(x => x.Models)
            .KeyColumn("MakeId");
        Table("Make");
    }
}

public class ModelMap : ClassMap<Model>
{
   public ModelMap()
   {
       Id(x => x.Id);
       Map(x => x.Name);
       References(x => x.Make)
           .Column("MakeId");
       Table("Model");
   }
}

Ahora, si ejecuta la siguiente consulta para cargar vehículos de cuatro ruedas, NHibernate se unirá a los vehículos, el automóvil y la mesa de bicicletas. Mientras que todo lo que necesito ahora es solo los datos almacenados en la tabla de Vehículos

List<Vehicle> vehicles = session.Query < Vehicle > ().Where(v => v.WheelsCount > 2).ToList();

¿Alguien sabe cómo puedo forzar nHibernar simplemente cargar los datos que se necesitan actualmente, es decir, si solo puede devolver objetos del vehículo en lugar de Coche / Bicicleta? Con solo un par de tablas en su esquema, puede pasar por alto estas consultas con nHibernate, pero realmente duele cuando tiene 200 tablas :(.

PD En caso de que haya un fallo en el modelo, ignórelo. Este no es el modelo real. El modelo real como se dijo anteriormente es mucho más grande. Este modelo está ahí para ilustrar el problema.