Error when working with derived classes about detached-mapper HOT 12 CLOSED

modelBuilder.Entity<RollenBase>()
                .HasDiscriminator(r => r.RollenTyp)
                .HasValue<KontaktRolle>(1)
                .HasValue<BauvorhabenKontaktRolle>(2)
                .HasValue<PersonalRolle>(3);

modelBuilder.Entity<RollenBase>()
                .HasDiscriminator(r => r.RollenTyp)
                .HasValue<KontaktRolle>(nameof(KontaktRolle))
                .HasValue<BauvorhabenKontaktRolle>(nameof(BauvorhabenKontaktRolle))
                .HasValue<PersonalRolle>(nameof(PersonalRolle));

public abstract class RollenBase
   {
       [Key]
       public int Id { get; set; }
       public string RollenTyp { get; set; }
       public string Name { get; set; }
   }

public class BauvorhabenKontaktRolle : RollenBase
    {
        public int RollenId { get; set; }

        //some props
    }

 public class BauvorhabenKontaktRolleDTO
    {
        public int Id { get; set; } 

        public string Name { get; set; }

        public string RollenTyp  {get; set;}
    }

using System.ComponentModel.DataAnnotations;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using Detached.Mappers.EntityFramework;
using System.Diagnostics;

namespace Test
{

    public class Program
    {
        public static async Task Main(string[] args)
        {
            TestDbContext context = await TestDbContext.CreateAsync("inheritance_test");

            var r1 = context.Map<RollenBase>(new BauvorhabenKontaktRolleDTO
            {
                Id = 1,
                Name = "kontakt",
                RollenTyp = nameof(KontaktRolle)
            });

            var r2 = context.Map<RollenBase>(new BauvorhabenKontaktRolleDTO
            {
                Id = 2,
                Name = "bauvorhabenKontakt",
                RollenTyp = nameof(BauvorhabenKontaktRolle)
            });

            var r3 = context.Map<RollenBase>(new BauvorhabenKontaktRolleDTO
            {
                Id = 3,
                Name = "personalRolle",
                RollenTyp = nameof(PersonalRolle)
            });

            Debug.Assert(r1.GetType() == typeof(KontaktRolle));
            Debug.Assert(r2.GetType() == typeof(BauvorhabenKontaktRolle));
            Debug.Assert(r3.GetType() == typeof(PersonalRolle));

            Console.WriteLine("it works!");
        }
    }

    public abstract class RollenBase
    {
        [Key]
        public int Id { get; set; }

        public string RollenTyp { get; set; }

        public string Name { get; set; }
    }

    public class BauvorhabenKontaktRolle : RollenBase
    {
        public int RollenId { get; set; }

        //some props
    }

    public class KontaktRolle : RollenBase
    {
        public int RollenId { get; set; }

        //some props
    }
    public class PersonalRolle : RollenBase
    {
        public int RollenId { get; set; }

        //some props
    }

    public class BauvorhabenKontaktRolleDTO
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public string RollenTyp { get; set; }
    }

    public class TestDbContext : DbContext
    {
        public TestDbContext(DbContextOptions<TestDbContext> options)
            : base(options)
        {
        }

        public DbSet<RollenBase> RollenBases { get; set; }

        protected override void OnModelCreating(ModelBuilder mb)
        {
            mb.Entity<RollenBase>()
                .HasDiscriminator(r => r.RollenTyp)
                .HasValue<KontaktRolle>(nameof(KontaktRolle))
                .HasValue<BauvorhabenKontaktRolle>(nameof(BauvorhabenKontaktRolle))
                .HasValue<PersonalRolle>(nameof(PersonalRolle));
        }

        public static async Task<DbContextOptions<TestDbContext>> CreateOptionsAsync([CallerMemberName] string dbName = null)
        {
            var connection = new SqliteConnection($"DataSource=file:{dbName}?mode=memory&cache=shared");

            await connection.OpenAsync();

            return new DbContextOptionsBuilder<TestDbContext>()
                    .UseSqlite(connection)
                    .UseDetached(cfg =>
                    {

                    })
                    .Options;
        }

        public static async Task<TestDbContext> CreateAsync([CallerMemberName] string dbName = null)
        {
            var context = new TestDbContext(await CreateOptionsAsync(dbName));
            await context.Database.EnsureCreatedAsync();
            return context;
        }
    }
}