Move logic from ModelCustomizer to conventions.

src/EFCore.Relational/Infrastructure/RelationalModelCustomizer.cs

@@ -1,26 +1,14 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-using System.Linq;
-using System.Reflection;
 using JetBrains.Annotations;
-using Microsoft.EntityFrameworkCore.Internal;
-using Microsoft.EntityFrameworkCore.Metadata;
-using Microsoft.EntityFrameworkCore.Utilities;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.EntityFrameworkCore.Infrastructure
 {
  /// <summary>
  /// <para>
- /// Builds the model for a given context. This default implementation builds the model by calling
- /// <see cref="DbContext.OnConfiguring(DbContextOptionsBuilder)" /> on the context.
- /// </para>
- /// <para>
- /// Also, entity types found as <see cref="DbSet{TEntity}" /> properties on the context are mapped
- /// to tables named for the DbSet property names, and public static methods on the context marked with
- /// <see cref="DbFunctionAttribute" /> are mapped to database functions.
+ /// Builds the model for a given context.
  /// </para>
  /// <para>
  /// This type is typically used by database providers (and other extensions). It is generally
@@ -42,80 +30,5 @@ public RelationalModelCustomizer([NotNull] ModelCustomizerDependencies dependenc
  : base(dependencies)
  {
  }
-
- /// <summary>
- /// <para>
- /// Performs additional configuration of the model in addition to what is discovered by convention. This implementation
- /// builds the model for a given context by calling <see cref="DbContext.OnConfiguring(DbContextOptionsBuilder)" />
- /// on the context.
- /// </para>
- /// <para>
- /// Also, entity types found as <see cref="DbSet{TEntity}" /> properties on the context are mapped
- /// to tables named for the DbSet property names, and public static methods on the context marked with
- /// <see cref="DbFunctionAttribute" /> are mapped to database functions.
- /// </para>
- /// </summary>
- /// <param name="modelBuilder">
- /// The builder being used to construct the model.
- /// </param>
- /// <param name="context">
- /// The context instance that the model is being created for.
- /// </param>
- public override void Customize(ModelBuilder modelBuilder, DbContext context)
- {
- FindDbFunctions(modelBuilder, context);
-
- base.Customize(modelBuilder, context);
- }
-
- /// <summary>
- /// Adds to the model function mappings found as public static methods on the context marked with
- /// the <see cref="DbFunctionAttribute" />.
- /// </summary>
- /// <param name="modelBuilder"> The <see cref="ModelBuilder" /> being used to build the model. </param>
- /// <param name="context"> The context to find function methods on. </param>
- protected virtual void FindDbFunctions([NotNull] ModelBuilder modelBuilder, [NotNull] DbContext context)
- {
- Check.NotNull(modelBuilder, nameof(modelBuilder));
- Check.NotNull(context, nameof(context));
-
- var contextType = context.GetType();
-
- while (contextType != typeof(DbContext))
- {
- var functions = contextType.GetMethods(
- BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
- | BindingFlags.Static | BindingFlags.DeclaredOnly)
- .Where(mi => mi.GetCustomAttributes(typeof(DbFunctionAttribute)).Any());
-
- foreach (var function in functions)
- {
- modelBuilder.HasDbFunction(function);
- }
-
- contextType = contextType.BaseType;
- }
- }
-
- /// <summary>
- /// Adds the entity types found in <see cref="DbSet{TEntity}" /> properties on the context to the model.
- /// </summary>
- /// <param name="modelBuilder"> The <see cref="ModelBuilder" /> being used to build the model. </param>
- /// <param name="contextType"> The context type to find <see cref="DbSet{TEntity}" /> properties on. </param>
- protected override void FindSets(ModelBuilder modelBuilder, Type contextType)
- {
- base.FindSets(modelBuilder, contextType);
-
- var sets = Dependencies.SetFinder.CreateClrTypeDbSetMapping(contextType);
-
- foreach (var entityType in modelBuilder.Model.GetEntityTypes().Cast<IConventionEntityType>())
- {
- if (entityType.BaseType == null
- && sets.ContainsKey(entityType.ClrType))
- {
- entityType.Builder.ToTable(sets[entityType.ClrType].Name);
- }
- }
- }
  }
 }

src/EFCore.Relational/Metadata/Conventions/Infrastructure/RelationalConventionSetBuilder.cs

@@ -70,13 +70,21 @@ public override ConventionSet CreateConventionSet()
 
  conventionSet.PropertyAddedConventions.Add(relationalColumnAttributeConvention);
 
- var storeGenerationConvention = new StoreGenerationConvention(Dependencies, RelationalDependencies);
+ var tableNameFromDbSetConvention = new TableNameFromDbSetConvention(Dependencies, RelationalDependencies);
  conventionSet.EntityTypeAddedConventions.Add(new RelationalTableAttributeConvention(Dependencies, RelationalDependencies));
- conventionSet.EntityTypeBaseTypeChangedConventions.Add(new TableNameFromDbSetConvention(Dependencies, RelationalDependencies));
+ conventionSet.EntityTypeAddedConventions.Add(tableNameFromDbSetConvention);
+
+ conventionSet.EntityTypeBaseTypeChangedConventions.Add(tableNameFromDbSetConvention);
+
  conventionSet.PropertyFieldChangedConventions.Add(relationalColumnAttributeConvention);
+
+ var storeGenerationConvention = new StoreGenerationConvention(Dependencies, RelationalDependencies);
  conventionSet.PropertyAnnotationChangedConventions.Add(storeGenerationConvention);
  conventionSet.PropertyAnnotationChangedConventions.Add((RelationalValueGenerationConvention)valueGenerationConvention);
 
+ var dbFunctionAttributeConvention = new RelationalDbFunctionAttributeConvention(Dependencies, RelationalDependencies);
+ conventionSet.ModelInitializedConventions.Add(dbFunctionAttributeConvention);
+
  var sharedTableConvention = new SharedTableConvention(Dependencies, RelationalDependencies);
  ConventionSet.AddBefore(
  conventionSet.ModelFinalizedConventions,
@@ -87,7 +95,7 @@ public override ConventionSet CreateConventionSet()
  sharedTableConvention,
  typeof(ValidatingConvention));
 
- conventionSet.ModelAnnotationChangedConventions.Add(new RelationalDbFunctionConvention(Dependencies, RelationalDependencies));
+ conventionSet.ModelAnnotationChangedConventions.Add(dbFunctionAttributeConvention);
 
  return conventionSet;
  }

src/EFCore.Relational/Metadata/Conventions/RelationalDbFunctionConvention.cs → src/EFCore.Relational/Metadata/Conventions/RelationalDbFunctionAttributeConvention.cs

@@ -12,17 +12,17 @@
 namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
 {
  /// <summary>
- /// A convention that configures the name and schema for a <see cref="IDbFunction"/> based on the applied
+ /// A convention that configures model function mappings based on public static methods on the context marked with
  /// <see cref="DbFunctionAttribute"/>.
  /// </summary>
- public class RelationalDbFunctionConvention : IModelAnnotationChangedConvention
+ public class RelationalDbFunctionAttributeConvention : IModelInitializedConvention, IModelAnnotationChangedConvention
  {
  /// <summary>
- /// Creates a new instance of <see cref="RelationalDbFunctionConvention" />.
+ /// Creates a new instance of <see cref="RelationalDbFunctionAttributeConvention" />.
  /// </summary>
  /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
  /// <param name="relationalDependencies"> Parameter object containing relational dependencies for this convention. </param>
- public RelationalDbFunctionConvention(
+ public RelationalDbFunctionAttributeConvention(
  [NotNull] ProviderConventionSetBuilderDependencies dependencies,
  [NotNull] RelationalConventionSetBuilderDependencies relationalDependencies)
  {
@@ -34,6 +34,31 @@ public RelationalDbFunctionConvention(
  /// </summary>
  protected virtual ProviderConventionSetBuilderDependencies Dependencies { get; }
 
+ /// <summary>
+ /// Called after a model is initialized.
+ /// </summary>
+ /// <param name="modelBuilder"> The builder for the model. </param>
+ /// <param name="context"> Additional information associated with convention execution. </param>
+ public virtual void ProcessModelInitialized(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+ {
+ var contextType = Dependencies.ContextType;
+ while (contextType != null
+ && contextType != typeof(DbContext))
+ {
+ var functions = contextType.GetMethods(
+ BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
+ | BindingFlags.Static | BindingFlags.DeclaredOnly)
+ .Where(mi => mi.IsDefined(typeof(DbFunctionAttribute)));
+
+ foreach (var function in functions)
+ {
+ modelBuilder.HasDbFunction(function);
+ }
+
+ contextType = contextType.BaseType;
+ }
+ }
+
  /// <summary>
  /// Called after an annotation is changed on an model.
  /// </summary>

src/EFCore.Relational/Metadata/Conventions/TableNameFromDbSetConvention.cs

@@ -13,7 +13,7 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
  /// <summary>
  /// A convention that configures the table name based on the <see cref="DbSet{TEntity}"/> property name.
  /// </summary>
- public class TableNameFromDbSetConvention : IEntityTypeBaseTypeChangedConvention
+ public class TableNameFromDbSetConvention : IEntityTypeAddedConvention, IEntityTypeBaseTypeChangedConvention
  {
  private readonly IDictionary<Type, DbSetProperty> _sets;
 
@@ -60,11 +60,30 @@ public virtual void ProcessEntityTypeBaseTypeChanged(
  }
  else if (oldBaseType != null
  && newBaseType == null
+ && entityType.ClrType != null
  && _sets.ContainsKey(entityType.ClrType))
  {
  entityTypeBuilder.ToTable(_sets[entityType.ClrType].Name);
  }
  }
  }
+
+ /// <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)
+ {
+ var entityType = entityTypeBuilder.Metadata;
+ if (entityType.BaseType == null
+ && entityType.ClrType != null
+ && _sets.ContainsKey(entityType.ClrType))
+ {
+ entityTypeBuilder.ToTable(_sets[entityType.ClrType].Name);
+ }
+ }
  }
 }

src/EFCore.SqlServer/Metadata/Conventions/SqlServerConventionSetBuilder.cs

@@ -94,7 +94,7 @@ public override ConventionSet CreateConventionSet()
 
  ReplaceConvention(
  conventionSet.ModelAnnotationChangedConventions,
- (RelationalDbFunctionConvention)new SqlServerDbFunctionConvention(Dependencies, RelationalDependencies));
+ (RelationalDbFunctionAttributeConvention)new SqlServerDbFunctionAttributeConvention(Dependencies, RelationalDependencies));
 
  ReplaceConvention(conventionSet.ModelFinalizedConventions, storeGenerationConvention);
 

src/EFCore.SqlServer/Metadata/Conventions/SqlServerDbFunctionConvention.cs → src/EFCore.SqlServer/Metadata/Conventions/SqlServerDbFunctionAttributeConvention.cs

@@ -10,17 +10,17 @@
 namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
 {
  /// <summary>
- /// A convention that configures the name and schema for a <see cref="IDbFunction"/> based on the applied
- /// <see cref="DbFunctionAttribute"/> and the default schema as 'dbo'.
+ /// A convention that configures model function mappings based on public static methods on the context marked with
+ /// <see cref="DbFunctionAttribute"/> and sets the default schema to 'dbo'.
  /// </summary>
- public class SqlServerDbFunctionConvention : RelationalDbFunctionConvention
+ public class SqlServerDbFunctionAttributeConvention : RelationalDbFunctionAttributeConvention
  {
  /// <summary>
- /// Creates a new instance of <see cref="SqlServerDbFunctionConvention" />.
+ /// Creates a new instance of <see cref="SqlServerDbFunctionAttributeConvention" />.
  /// </summary>
  /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
  /// <param name="relationalDependencies"> Parameter object containing relational dependencies for this convention. </param>
- public SqlServerDbFunctionConvention(
+ public SqlServerDbFunctionAttributeConvention(
  [NotNull] ProviderConventionSetBuilderDependencies dependencies,
  [NotNull] RelationalConventionSetBuilderDependencies relationalDependencies)
  : base(dependencies, relationalDependencies)

src/EFCore.SqlServer/Metadata/Conventions/SqlServerIndexConvention.cs

@@ -27,7 +27,7 @@ public class SqlServerIndexConvention :
  private readonly ISqlGenerationHelper _sqlGenerationHelper;
 
  /// <summary>
- /// Creates a new instance of <see cref="SqlServerDbFunctionConvention" />.
+ /// Creates a new instance of <see cref="SqlServerDbFunctionAttributeConvention" />.
  /// </summary>
  /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
  /// <param name="relationalDependencies"> Parameter object containing relational dependencies for this convention. </param>

src/EFCore/Infrastructure/ModelCustomizer.cs

@@ -1,7 +1,6 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Utilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -54,29 +53,7 @@ public ModelCustomizer([NotNull] ModelCustomizerDependencies dependencies)
  /// </param>
  public virtual void Customize(ModelBuilder modelBuilder, DbContext context)
  {
- FindSets(modelBuilder, context.GetType());
-
  context.OnModelCreating(modelBuilder);
  }
-
- /// <summary>
- /// Adds the entity types found in <see cref="DbSet{TEntity}" /> properties on the context to the model.
- /// </summary>
- /// <param name="modelBuilder"> The <see cref="ModelBuilder" /> being used to build the model. </param>
- /// <param name="contextType"> The context type to find <see cref="DbSet{TEntity}" /> properties on. </param>
- protected virtual void FindSets([NotNull] ModelBuilder modelBuilder, [NotNull] Type contextType)
- {
- foreach (var setInfo in Dependencies.SetFinder.FindSets(contextType))
- {
- if (setInfo.IsKeyless)
- {
- modelBuilder.Entity(setInfo.ClrType).HasNoKey();
- }
- else
- {
- modelBuilder.Entity(setInfo.ClrType);
- }
- }
- }
  }
 }

src/EFCore/Metadata/Conventions/DbSetFindingConvention.cs

@@ -0,0 +1,50 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+ /// <summary>
+ /// A convention that adds entity types based on the <see cref="DbSet{TEntity}"/> properties defined on the
+ /// derived <see cref="DbContext"/> class.
+ /// </summary>
+ public class DbSetFindingConvention : IModelInitializedConvention
+ {
+ /// <summary>
+ /// Creates a new instance of <see cref="DbSetFindingConvention" />.
+ /// </summary>
+ /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
+ public DbSetFindingConvention([NotNull] ProviderConventionSetBuilderDependencies dependencies)
+ {
+ Dependencies = dependencies;
+ }
+
+ /// <summary>
+ /// Parameter object containing service dependencies.
+ /// </summary>
+ protected virtual ProviderConventionSetBuilderDependencies Dependencies { get; }
+
+ /// <summary>
+ /// Called after a model is initialized.
+ /// </summary>
+ /// <param name="modelBuilder"> The builder for the model. </param>
+ /// <param name="context"> Additional information associated with convention execution. </param>
+ public virtual void ProcessModelInitialized(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+ {
+ foreach (var setInfo in Dependencies.SetFinder.FindSets(Dependencies.ContextType))
+ {
+ if (setInfo.IsKeyless)
+ {
+ modelBuilder.Entity(setInfo.ClrType, fromDataAnnotation: true).HasNoKey(fromDataAnnotation: true);
+ }
+ else
+ {
+ modelBuilder.Entity(setInfo.ClrType, fromDataAnnotation: true);
+ }
+ }
+ }
+ }
+}

src/EFCore/Metadata/Conventions/Infrastructure/ProviderConventionSetBuilder.cs

@@ -160,6 +160,8 @@ public virtual ConventionSet CreateConventionSet()
  conventionSet.ForeignKeyOwnershipChangedConventions.Add(keyDiscoveryConvention);
  conventionSet.ForeignKeyOwnershipChangedConventions.Add(relationshipDiscoveryConvention);
 
+ conventionSet.ModelInitializedConventions.Add(new DbSetFindingConvention(Dependencies));
+
  conventionSet.ModelFinalizedConventions.Add(new ModelCleanupConvention(Dependencies));
  conventionSet.ModelFinalizedConventions.Add(keyAttributeConvention);
  conventionSet.ModelFinalizedConventions.Add(foreignKeyAttributeConvention);