/// <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 override void ProcessEntityTypeBaseTypeChanged(
IConventionEntityTypeBuilder entityTypeBuilder,
IConventionEntityType newBaseType,
IConventionEntityType oldBaseType,
IConventionContext <IConventionEntityType> context)
{
if (entityTypeBuilder.Metadata.BaseType != newBaseType)
{
return;
}
IConventionDiscriminatorBuilder discriminator;
var entityType = entityTypeBuilder.Metadata;
if (newBaseType == null)
{
discriminator = entityTypeBuilder.HasDiscriminator(typeof(string));
}
else
{
discriminator = newBaseType.Builder?.HasDiscriminator(typeof(string));
if (newBaseType.BaseType == null)
{
discriminator?.HasValue(newBaseType, newBaseType.ShortName());
}
}
if (discriminator != null)
{
discriminator.HasValue(entityTypeBuilder.Metadata, entityTypeBuilder.Metadata.ShortName());
SetDefaultDiscriminatorValues(entityType.GetDerivedTypes(), discriminator);
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public override bool Apply(InternalEntityTypeBuilder entityTypeBuilder, EntityType oldBaseType)
{
IConventionEntityTypeBuilder conventionEntityTypeBuilder = entityTypeBuilder;
IConventionDiscriminatorBuilder discriminator;
var entityType = entityTypeBuilder.Metadata;
if (entityType.BaseType == null)
{
discriminator = conventionEntityTypeBuilder.HasDiscriminator(typeof(string));
}
else
{
discriminator = ((IConventionEntityTypeBuilder)entityType.BaseType.Builder)?.HasDiscriminator(typeof(string));
if (entityType.BaseType.BaseType == null)
{
discriminator?.HasValue(entityType.BaseType, entityType.BaseType.ShortName());
}
}
if (discriminator != null)
{
discriminator.HasValue(entityTypeBuilder.Metadata, entityTypeBuilder.Metadata.ShortName());
SetDefaultDiscriminatorValues(entityType.GetDerivedTypes(), discriminator);
}
return(true);
}
/// <summary>
/// Called after an entity type is added to the model.
/// </summary>
/// <param name="entityTypeBuilder"> The builder for the entity type. </param>
/// <param name="context"> Additional information associated with convention execution. </param>
public void ProcessEntityTypeAdded(
IConventionEntityTypeBuilder entityTypeBuilder,
IConventionContext <IConventionEntityTypeBuilder> context)
{
var entityType = entityTypeBuilder.Metadata;
if (entityTypeBuilder.Metadata.BaseType == null &&
!entityTypeBuilder.Metadata.GetDerivedTypes().Any())
{
entityTypeBuilder.HasDiscriminator(typeof(string))
.HasValue(entityType, entityType.ShortName());
}
}
/// <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);
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual bool Apply(InternalEntityTypeBuilder entityTypeBuilder, EntityType oldBaseType)
{
if (oldBaseType != null &&
oldBaseType.BaseType == null &&
oldBaseType.GetDirectlyDerivedTypes().Count == 0)
{
((IConventionEntityTypeBuilder)oldBaseType.Builder)?.HasNoDeclaredDiscriminator();
}
IConventionEntityTypeBuilder conventionEntityTypeBuilder = entityTypeBuilder;
var entityType = entityTypeBuilder.Metadata;
var derivedEntityTypes = entityType.GetDerivedTypes().ToList();
IConventionDiscriminatorBuilder discriminator;
if (entityType.BaseType == null)
{
if (derivedEntityTypes.Count == 0)
{
conventionEntityTypeBuilder.HasNoDeclaredDiscriminator();
return(true);
}
discriminator = conventionEntityTypeBuilder.HasDiscriminator(typeof(string));
}
else
{
if (conventionEntityTypeBuilder.HasNoDeclaredDiscriminator() == null)
{
return(true);
}
IConventionEntityTypeBuilder rootTypeBuilder = entityType.RootType().Builder;
discriminator = rootTypeBuilder?.HasDiscriminator(typeof(string));
if (entityType.BaseType.BaseType == null)
{
discriminator?.HasValue(entityType.BaseType, entityType.BaseType.ShortName());
}
}
if (discriminator != null)
{
discriminator.HasValue(entityTypeBuilder.Metadata, entityTypeBuilder.Metadata.ShortName());
SetDefaultDiscriminatorValues(derivedEntityTypes, discriminator);
}
return(true);
}
/// <summary>
/// Called after an entity type is added to the model.
/// </summary>
/// <param name="entityTypeBuilder"> The builder for the entity type. </param>
/// <param name="context"> Additional information associated with convention execution. </param>
public virtual void ProcessEntityTypeAdded(
IConventionEntityTypeBuilder entityTypeBuilder,
IConventionContext <IConventionEntityTypeBuilder> context)
{
Check.NotNull(entityTypeBuilder, nameof(entityTypeBuilder));
Check.NotNull(context, nameof(context));
var entityType = entityTypeBuilder.Metadata;
if (entityType.BaseType == null &&
entityType.IsDocumentRoot())
{
entityTypeBuilder.HasDiscriminator(typeof(string))
?.HasValue(entityType, entityType.ShortName());
}
}
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());
}
}
