コード例 #1
0
 private void SetDefaultDiscriminatorValues(IReadOnlyList<EntityType> entityTypes, DiscriminatorBuilder discriminator)
 {
     foreach (var entityType in entityTypes)
     {
         discriminator.HasValue(entityType.Name, entityType.DisplayName());
     }
 }
コード例 #2
0
 private static void SetDefaultDiscriminatorValues(IReadOnlyList <EntityType> entityTypes, DiscriminatorBuilder discriminator)
 {
     foreach (var entityType in entityTypes)
     {
         discriminator.HasValue(entityType.Name, entityType.ShortName());
     }
 }
        public void Can_access_discriminator_value_generic()
        {
            var typeBuilder = CreateBuilder().Entity(typeof(Splot), ConfigurationSource.Convention);

            var discriminatorBuilder = new DiscriminatorBuilder <int?>(
                typeBuilder.Relational(ConfigurationSource.Convention).HasDiscriminator(Splot.SplowedProperty));

            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splot), 1));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splow), 2));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splod), 3));
            Assert.Equal(1, typeBuilder.Metadata.Relational().DiscriminatorValue);
            Assert.Equal(
                2, typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
            Assert.Equal(
                3, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);

            discriminatorBuilder = new DiscriminatorBuilder <int?>(
                typeBuilder.Relational(ConfigurationSource.DataAnnotation).HasDiscriminator());
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splot), 4));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splow), 5));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splod), 6));
            Assert.Equal(4, typeBuilder.Metadata.Relational().DiscriminatorValue);
            Assert.Equal(
                5, typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
            Assert.Equal(
                6, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);

            discriminatorBuilder = new DiscriminatorBuilder <int?>(
                typeBuilder.Relational(ConfigurationSource.Convention).HasDiscriminator());
            Assert.Null(discriminatorBuilder.HasValue(typeof(Splot), 1));
            Assert.Null(discriminatorBuilder.HasValue(typeof(Splow), 2));
            Assert.Null(discriminatorBuilder.HasValue(typeof(Splod), 3));
            Assert.Equal(4, typeBuilder.Metadata.Relational().DiscriminatorValue);
            Assert.Equal(
                5, typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
            Assert.Equal(
                6, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
        }
コード例 #4
0
        public void Can_access_discriminator_value_generic()
        {
            var typeBuilder = CreateBuilder().Entity(typeof(Splot), ConfigurationSource.Convention);

            var discriminatorBuilder = new DiscriminatorBuilder <int?>(
                (DiscriminatorBuilder)typeBuilder.HasDiscriminator(Splot.SplowedProperty));

            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splot), 1));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splow), 2));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splod), 3));

            var splow = typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention).Metadata;
            var splod = typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention).Metadata;

            Assert.Equal(1, typeBuilder.Metadata.GetDiscriminatorValue());
            Assert.Equal(2, splow.GetDiscriminatorValue());
            Assert.Equal(
                3, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.GetDiscriminatorValue());

            discriminatorBuilder = new DiscriminatorBuilder <int?>(
                (DiscriminatorBuilder)typeBuilder.HasDiscriminator(fromDataAnnotation: true));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splot), 4));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splow), 5));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splod), 6));
            Assert.Equal(4, typeBuilder.Metadata.GetDiscriminatorValue());
            Assert.Equal(5, splow.GetDiscriminatorValue());
            Assert.Equal(6, splod.GetDiscriminatorValue());

            var conventionDiscriminatorBuilder = typeBuilder.HasDiscriminator();

            Assert.Null(conventionDiscriminatorBuilder.HasValue(typeBuilder.Metadata, 1));
            Assert.Null(conventionDiscriminatorBuilder.HasValue(splow, 2));
            Assert.Null(conventionDiscriminatorBuilder.HasValue(splod, 3));
            Assert.Equal(4, typeBuilder.Metadata.GetDiscriminatorValue());
            Assert.Equal(5, splow.GetDiscriminatorValue());
            Assert.Equal(6, splod.GetDiscriminatorValue());
        }
        public void Can_access_discriminator_value_generic()
        {
            var typeBuilder = CreateBuilder().Entity(typeof(Splot), ConfigurationSource.Convention);

            var discriminatorBuilder = new DiscriminatorBuilder<int?>(
                typeBuilder.Relational(ConfigurationSource.Convention).Discriminator(Splot.SplowedProperty));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splot), 1));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splow), 2));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splod), 3));
            Assert.Equal(1, typeBuilder.Metadata.Relational().DiscriminatorValue);
            Assert.Equal(2, typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
            Assert.Equal(3, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);

            discriminatorBuilder = new DiscriminatorBuilder<int?>(
                typeBuilder.Relational(ConfigurationSource.DataAnnotation).Discriminator());
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splot), 4));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splow), 5));
            Assert.NotNull(discriminatorBuilder.HasValue(typeof(Splod), 6));
            Assert.Equal(4, typeBuilder.Metadata.Relational().DiscriminatorValue);
            Assert.Equal(5, typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
            Assert.Equal(6, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);

            discriminatorBuilder = new DiscriminatorBuilder<int?>(
                typeBuilder.Relational(ConfigurationSource.Convention).Discriminator());
            Assert.Null(discriminatorBuilder.HasValue(typeof(Splot), 1));
            Assert.Null(discriminatorBuilder.HasValue(typeof(Splow), 2));
            Assert.Null(discriminatorBuilder.HasValue(typeof(Splod), 3));
            Assert.Equal(4, typeBuilder.Metadata.Relational().DiscriminatorValue);
            Assert.Equal(5, typeBuilder.ModelBuilder.Entity(typeof(Splow), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
            Assert.Equal(6, typeBuilder.ModelBuilder.Entity(typeof(Splod), ConfigurationSource.Convention)
                .Metadata.Relational().DiscriminatorValue);
        }