Recursive models with ProjectTo

[BlaiseD]

In the sample below the parent entity is being ignored if it already exists in the object graph.

The child entities are still included. PreserveReferences() does not seen to affect the outcome.

The logic seems to depend on this:

tenants[0].Buildings.First().Tenant will return a non-null value if AlreadyExists returns false.

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.17" />
  </ItemGroup>

namespace ConsoleApp2
{
    class Program
    {

        private static IServiceProvider serviceProvider;

        static void Main(string[] args)
        {
            AutoMapper.IConfigurationProvider configurationProvider = new MapperConfiguration(cfg =>
            {
                cfg.AddMaps(typeof(Program).Assembly);
                cfg.AllowNullCollections = true;
            });

            IMapper mapper = new Mapper(configurationProvider);

            serviceProvider = new ServiceCollection()
                .AddDbContext<MyDbContext>
                (
                    options => options.UseSqlServer
                    (
                        @"Server=(localdb)\mssqllocaldb;Database=OpsTenantTest;ConnectRetryCount=0"
                    ),
                    ServiceLifetime.Transient
                ).BuildServiceProvider();

            CreateDataBase();
            SeedDatabase();

            using (MyDbContext context = serviceProvider.GetRequiredService<MyDbContext>())
            {
                List<OpsTenant> tenants = mapper.ProjectTo<OpsTenant>(context.MandatorSet).ToList();
                List<CoreBuilding> buildings = mapper.ProjectTo<CoreBuilding>(context.BuildingSet).ToList();

                if (tenants[0].Buildings.First().Tenant == null)
                {//always null

                }

                if (buildings[0].Tenant.Buildings.FirstOrDefault(b => b.Identity == buildings[0].Identity) != null)
                {//always NOT null

                }
            }
        }

        private static void CreateDataBase()
        {
            using (MyDbContext context = serviceProvider.GetRequiredService<MyDbContext>())
            {
                context.Database.EnsureCreated();
            }
        }

        static void SeedDatabase()
        {
            using (MyDbContext context = serviceProvider.GetRequiredService<MyDbContext>())
            {
                if (context.City.Any())
                    return;

                context.City.Add(new TCity { Name = "London" });
                context.City.Add(new TCity { Name = "Leeds" });
                context.SaveChanges();

                List<TCity> cities = context.City.ToList();
                context.Builder.Add(new TBuilder { Name = "Sam", CityId = cities.First(b => b.Name == "London").Id });
                context.Builder.Add(new TBuilder { Name = "John", CityId = cities.First(b => b.Name == "London").Id });
                context.Builder.Add(new TBuilder { Name = "Mark", CityId = cities.First(b => b.Name == "Leeds").Id });
                context.SaveChanges();

                List<TBuilder> builders = context.Builder.ToList();
                context.MandatorSet.Add(new TMandator
                {
                    Identity = Guid.NewGuid(),
                    Name = "One",
                    CreatedDate = new DateTime(2012, 12, 12),
                    Buildings = new List<TBuilding>
                    {
                        new TBuilding { Identity =  Guid.NewGuid(), LongName = "One L1", BuilderId = builders.First(b => b.Name == "Sam").Id },
                        new TBuilding { Identity =  Guid.NewGuid(), LongName = "One L2", BuilderId = builders.First(b => b.Name == "Sam").Id  }
                    }
                });
                context.MandatorSet.Add(new TMandator
                {
                    Identity = Guid.NewGuid(),
                    Name = "Two",
                    CreatedDate = new DateTime(2012, 12, 12),
                    Buildings = new List<TBuilding>
                    {
                        new TBuilding { Identity =  Guid.NewGuid(), LongName = "Two L1", BuilderId = builders.First(b => b.Name == "John").Id  },
                        new TBuilding { Identity =  Guid.NewGuid(), LongName = "Two L2", BuilderId = builders.First(b => b.Name == "Mark").Id  },
                        new TBuilding { Identity =  Guid.NewGuid(), LongName = "Two L3", BuilderId = builders.First(b => b.Name == "Mark").Id  }
                    }
                });
                context.SaveChanges();
            }
        }
    }

    public class MyDbContext : DbContext
    {
        public MyDbContext(DbContextOptions<MyDbContext> options) : base(options)
        {
            this.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
            this.ChangeTracker.AutoDetectChangesEnabled = false;
        }

        public DbSet<TMandator> MandatorSet { get; set; }

        public DbSet<TBuilding> BuildingSet { get; set; }

        public DbSet<TBuilder> Builder { get; set; }

        public DbSet<TCity> City { get; set; }

    }

    public class CoreBuildingMappings : AutoMapper.Profile
    {
        public CoreBuildingMappings()
        {
            CreateMap<TBuilding, CoreBuilding>()
                .ForMember(d => d.Name, o => o.MapFrom(s => s.LongName))
                .ForMember(d => d.Tenant, o => o.MapFrom(s => s.Mandator))
                ;//.PreserveReferences().MaxDepth(2);

            CreateMap<TBuilder, OpsBuilder>();//.PreserveReferences().MaxDepth(2);
            CreateMap<TCity, OpsCity>();//.PreserveReferences().MaxDepth(2);
        }
    }

    public class OpsTenantMappings : AutoMapper.Profile
    {
        public OpsTenantMappings()
        {
            CreateMap<TMandator, OpsTenant>();//.PreserveReferences().MaxDepth(2);
        }
    }

    [Table("TBuilders")]
    public class TBuilder
    {
        [Column("Id")]
        [Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public Int32 Id { get; set; }

        [Column("Name")]
        public String Name { get; set; }

        [ForeignKey("City")]
        public Int32 CityId { get; set; }

        public TCity City { get; set; }
    }

    [Table("OB_TBuilding")]
    public class TBuilding
    {

        [Column("pkBID")]
        [Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public Int32 Id { get; set; }

        [Column("Identifier")]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public Guid Identity { get; set; }

        [Column("sLongName")]
        public String LongName { get; set; }

        [ForeignKey("Builder")]
        public Int32 BuilderId { get; set; }

        public TBuilder Builder { get; set; }

        public TMandator Mandator { get; set; }

        [ForeignKey("Mandator")]
        [Column("fkMandatorID")]
        public Int32 MandatorId { get; set; }

    }

    [Table("TCities")]
    public class TCity
    {
        [Column("Id")]
        [Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public Int32 Id { get; set; }

        [Column("Name")]
        public String Name { get; set; }
    }

    [Table("G_TMandator")]
    public class TMandator
    {

        [Column("pkMandatorID")]
        [Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public Int32 Id { get; set; }

        [Column("gIdentity")]
        public Guid Identity { get; set; }

        [Column("sName")]
        public String Name { get; set; }

        [Column("CreatedDate")]
        public DateTime CreatedDate { get; set; }

        public virtual ICollection<TBuilding> Buildings { get; set; }

    }

    public class CoreBuilding
    {
        [Key]
        public Guid Identity { get; set; }
        public string Name { get; set; }
        public OpsBuilder Builder { get; set; }
        public OpsTenant Tenant { get; set; }
        public string Parameter { get; set; }
    }

    public class OpsBuilder
    {
        public Int32 Id { get; set; }
        public String Name { get; set; }
        public OpsCity City { get; set; }
        public Int32 Parameter { get; set; }
    }

    public class OpsCity
    {
        public Int32 Id { get; set; }
        public String Name { get; set; }
    }

    public class OpsTenant
    {
        [Key]
        public Guid Identity { get; set; }
        public string Name { get; set; }
        public DateTime CreatedDate { get; set; }
        public ICollection<CoreBuilding> Buildings { get; set; }
    }
}

Thoughts?

[lbargaoanu]

PreserveReferences works with Map. Try setting RecursiveQueriesMaxDepth.

[BlaiseD]

Worked like a charm - thank you.