/// <summary>
/// Called after the base type of an entity type changes.
/// </summary>
/// <param name="entityTypeBuilder">The builder for the entity type.</param>
/// <param name="newBaseType">The new base entity type.</param>
/// <param name="oldBaseType">The old base entity type.</param>
/// <param name="context">Additional information associated with convention execution.</param>
public virtual void ProcessEntityTypeBaseTypeChanged(
IConventionEntityTypeBuilder entityTypeBuilder,
IConventionEntityType?newBaseType,
IConventionEntityType?oldBaseType,
IConventionContext <IConventionEntityType> context)
{
if (oldBaseType != null &&
oldBaseType.IsInModel &&
oldBaseType.BaseType == null &&
!oldBaseType.GetDirectlyDerivedTypes().Any())
{
oldBaseType.Builder.HasNoDiscriminator();
}
var entityType = entityTypeBuilder.Metadata;
var derivedEntityTypes = entityType.GetDerivedTypes().ToList();
IConventionDiscriminatorBuilder?discriminator;
if (newBaseType == null)
{
if (derivedEntityTypes.Count == 0)
{
entityTypeBuilder.HasNoDiscriminator();
return;
}
discriminator = entityTypeBuilder.HasDiscriminator(typeof(string));
}
else
{
if (entityTypeBuilder.HasNoDiscriminator() == null)
{
return;
}
var rootTypeBuilder = entityType.GetRootType().Builder;
discriminator = rootTypeBuilder.HasDiscriminator(typeof(string));
if (newBaseType.BaseType == null)
{
discriminator?.HasValue(newBaseType, newBaseType.ShortName());
}
}
if (discriminator != null)
{
discriminator.HasValue(entityTypeBuilder.Metadata, entityTypeBuilder.Metadata.ShortName());
SetDefaultDiscriminatorValues(derivedEntityTypes, discriminator);
}
}
private void ProcessEntityType(IConventionEntityTypeBuilder entityTypeBuilder)
{
var entityType = entityTypeBuilder.Metadata;
if (entityType.BaseType != null)
{
return;
}
if (!entityType.IsDocumentRoot())
{
entityTypeBuilder.HasNoDiscriminator();
}
else
{
entityTypeBuilder.HasDiscriminator(typeof(string))
?.HasValue(entityType, entityType.ShortName());
}
}
