Change default embedded discriminator property from "Discriminator" to "$type"

src/EFCore.Cosmos/Metadata/Conventions/CosmosDiscriminatorConvention.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.EntityFrameworkCore.Cosmos.Metadata.Internal;
-using Microsoft.EntityFrameworkCore.Metadata.Internal;
 
 // ReSharper disable once CheckNamespace
 namespace Microsoft.EntityFrameworkCore.Metadata.Conventions;
@@ -19,7 +18,8 @@ public class CosmosDiscriminatorConvention :
     IForeignKeyOwnershipChangedConvention,
     IForeignKeyRemovedConvention,
     IEntityTypeAddedConvention,
-    IEntityTypeAnnotationChangedConvention
+    IEntityTypeAnnotationChangedConvention,
+    IModelEmbeddedDiscriminatorNameConvention
 {
     /// <summary>
     ///     Creates a new instance of <see cref="CosmosDiscriminatorConvention" />.
@@ -86,7 +86,7 @@ private static void ProcessEntityType(IConventionEntityTypeBuilder entityTypeBui
 
         if (entityType.IsDocumentRoot())
         {
-            entityTypeBuilder.HasDiscriminator(typeof(string))
+            entityTypeBuilder.HasDiscriminator(entityType.Model.GetEmbeddedDiscriminatorName(), typeof(string))
                 ?.HasValue(entityType, entityType.ShortName());
         }
         else
@@ -125,7 +125,7 @@ public override void ProcessEntityTypeBaseTypeChanged(
         {
             if (entityType.IsDocumentRoot())
             {
-                entityTypeBuilder.HasDiscriminator(typeof(string));
+                entityTypeBuilder.HasDiscriminator(entityType.Model.GetEmbeddedDiscriminatorName(), typeof(string));
             }
         }
         else
@@ -137,7 +137,7 @@ public override void ProcessEntityTypeBaseTypeChanged(
                 return;
             }
 
-            var discriminator = rootType.Builder.HasDiscriminator(typeof(string));
+            var discriminator = rootType.Builder.HasDiscriminator(entityType.Model.GetEmbeddedDiscriminatorName(), typeof(string));
             if (discriminator != null)
             {
                 SetDefaultDiscriminatorValues(entityTypeBuilder.Metadata.GetDerivedTypesInclusive(), discriminator);
@@ -163,4 +163,22 @@ public override void ProcessEntityTypeRemoved(
         IConventionContext<IConventionEntityType> context)
     {
     }
+
+    /// <inheritdoc/>
+    public virtual void ProcessEmbeddedDiscriminatorName(
+        IConventionModelBuilder modelBuilder,
+        string? newName,
+        string? oldName,
+        IConventionContext<string> context)
+    {
+        if (oldName == newName)
+        {
+            return;
+        }
+
+        foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
+        {
+            ProcessEntityType(entityType.Builder);
+        }
+    }
 }

src/EFCore/Metadata/Builders/IConventionModelBuilder.cs

@@ -341,4 +341,20 @@ bool CanHaveSharedTypeEntity(
     /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
     /// <returns><see langword="true" /> if the given property access mode can be set.</returns>
     bool CanSetPropertyAccessMode(PropertyAccessMode? propertyAccessMode, bool fromDataAnnotation = false);
+
+    /// <summary>
+    ///     Sets the name to use for discriminator properties embedded in JSON documents. The default is "$type".
+    /// </summary>
+    /// <param name="name">The property name, or <see langword="null" /> to clear the name set.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>The same builder instance if the configuration was successful, <see langword="null" /> otherwise.</returns>
+    IConventionModelBuilder? HasEmbeddedDiscriminatorName(string? name, bool fromDataAnnotation = false);
+
+    /// <summary>
+    ///     Returns a value indicating whether the given name can be set from the current configuration source
+    /// </summary>
+    /// <param name="name">The property name, or <see langword="null" /> to clear the name set.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns><see langword="true" /> if the given property access mode can be set.</returns>
+    bool CanSetEmbeddedDiscriminatorName(string? name, bool fromDataAnnotation = false);
 }

src/EFCore/Metadata/Conventions/ConventionSet.cs

@@ -31,6 +31,11 @@ public class ConventionSet
     /// </summary>
     public virtual List<IModelAnnotationChangedConvention> ModelAnnotationChangedConventions { get; } = [];
 
+    /// <summary>
+    ///     Conventions to run when an annotation is set or removed on an entity type.
+    /// </summary>
+    public virtual List<IModelEmbeddedDiscriminatorNameConvention> ModelEmbeddedDiscriminatorNameConventions { get; } = [];
+
     /// <summary>
     ///     Conventions to run when a type is ignored.
     /// </summary>
@@ -321,6 +326,12 @@ public virtual void Replace<TImplementation>(TImplementation newConvention)
             ModelAnnotationChangedConventions.Add(modelAnnotationChangedConvention);
         }
 
+        if (newConvention is IModelEmbeddedDiscriminatorNameConvention modelEmbeddedDiscriminatorNameConvention
+            && !Replace(ModelEmbeddedDiscriminatorNameConventions, modelEmbeddedDiscriminatorNameConvention, oldConventionType))
+        {
+            ModelEmbeddedDiscriminatorNameConventions.Add(modelEmbeddedDiscriminatorNameConvention);
+        }
+
         if (newConvention is ITypeIgnoredConvention typeIgnoredConvention
             && !Replace(TypeIgnoredConventions, typeIgnoredConvention, oldConventionType))
         {
@@ -696,6 +707,11 @@ public virtual void Add(IConvention convention)
             ModelAnnotationChangedConventions.Add(modelAnnotationChangedConvention);
         }
 
+        if (convention is IModelEmbeddedDiscriminatorNameConvention modelEmbeddedDiscriminatorNameConvention)
+        {
+            ModelEmbeddedDiscriminatorNameConventions.Add(modelEmbeddedDiscriminatorNameConvention);
+        }
+
         if (convention is ITypeIgnoredConvention typeIgnoredConvention)
         {
             TypeIgnoredConventions.Add(typeIgnoredConvention);
@@ -1034,6 +1050,11 @@ public virtual void Remove(Type conventionType)
             Remove(ModelAnnotationChangedConventions, conventionType);
         }
 
+        if (typeof(IModelEmbeddedDiscriminatorNameConvention).IsAssignableFrom(conventionType))
+        {
+            Remove(ModelEmbeddedDiscriminatorNameConventions, conventionType);
+        }
+
         if (typeof(ITypeIgnoredConvention).IsAssignableFrom(conventionType))
         {
             Remove(TypeIgnoredConventions, conventionType);

src/EFCore/Metadata/Conventions/DiscriminatorConvention.cs

@@ -86,7 +86,7 @@ public virtual void ProcessDiscriminatorPropertySet(
             return;
         }
 
-        var discriminator = entityTypeBuilder.HasDiscriminator(typeof(string));
+        var discriminator = entityTypeBuilder.HasDiscriminator(name, typeof(string));
         if (discriminator != null)
         {
             SetDefaultDiscriminatorValues(entityTypeBuilder.Metadata.GetDerivedTypesInclusive(), discriminator);

src/EFCore/Metadata/Conventions/IModelEmbeddedDiscriminatorNameConvention.cs

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions;
+
+/// <summary>
+///     Represents an operation that should be performed when the embedded discriminator name for the model changes.
+/// </summary>
+/// <remarks>
+///     See <see href="https://aka.ms/efcore-docs-conventions">Model building conventions</see> for more information and examples.
+/// </remarks>
+public interface IModelEmbeddedDiscriminatorNameConvention : IConvention
+{
+    /// <summary>
+    ///     Called after <see cref="ModelBuilder.HasEmbeddedDiscriminatorName"/> has been called.
+    /// </summary>
+    /// <param name="modelBuilder">The builder for the model.</param>
+    /// <param name="newName">The new discriminator name.</param>
+    /// <param name="oldName">The current discriminator name.</param>
+    /// <param name="context">Additional information associated with convention execution.</param>
+    void ProcessEmbeddedDiscriminatorName(
+        IConventionModelBuilder modelBuilder,
+        string? newName,
+        string? oldName,
+        IConventionContext<string> context);
+}

src/EFCore/Metadata/Conventions/Internal/ConventionDispatcher.ConventionScope.cs

@@ -182,6 +182,11 @@ public int GetLeafCount()
             IConventionAnnotation? annotation,
             IConventionAnnotation? oldAnnotation);
 
+        public abstract string? OnModelEmbeddedDiscriminatorNameChanged(
+            IConventionModelBuilder modelBuilder,
+            string? oldName,
+            string? newName);
+
         public abstract IConventionNavigationBuilder? OnNavigationAdded(IConventionNavigationBuilder navigationBuilder);
 
         public abstract string? OnNavigationRemoved(