[preview 5] Add public conventions interfaces for metadata builders

EFCore.sln.DotSettings

@@ -190,5 +190,6 @@ Licensed under the Apache License, Version 2.0. See License.txt in the project r
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=keyless/@EntryIndexedValue">True</s:Boolean>
 
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=navigations/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=requiredness/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=sqlite/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=unignore/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

src/EFCore.Cosmos/Metadata/Internal/CosmosAnnotationsBuilder.cs

@@ -22,7 +22,7 @@ public class CosmosAnnotationsBuilder : CosmosAnnotations
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public CosmosAnnotationsBuilder(
-            [NotNull] InternalMetadataBuilder internalBuilder,
+            [NotNull] InternalAnnotatableBuilder internalBuilder,
             ConfigurationSource configurationSource)
             : base(internalBuilder.Metadata)
         {
@@ -44,7 +44,7 @@ public CosmosAnnotationsBuilder(
         ///     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 InternalMetadataBuilder MetadataBuilder { get; }
+        public virtual InternalAnnotatableBuilder MetadataBuilder { get; }
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -55,7 +55,7 @@ public CosmosAnnotationsBuilder(
         public override bool SetAnnotation(
             string relationalAnnotationName,
             object value)
-            => MetadataBuilder.HasAnnotation(relationalAnnotationName, value, ConfigurationSource);
+            => MetadataBuilder.HasAnnotation(relationalAnnotationName, value, ConfigurationSource) != null;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -75,6 +75,6 @@ public override bool CanSetAnnotation(
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public override bool RemoveAnnotation(string annotationName)
-            => MetadataBuilder.RemoveAnnotation(annotationName, ConfigurationSource);
+            => MetadataBuilder.RemoveAnnotation(annotationName, ConfigurationSource) != null;
     }
 }

src/EFCore.Relational/Metadata/Builders/DiscriminatorBuilder.cs

@@ -48,7 +48,7 @@ public DiscriminatorBuilder(
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         [EntityFrameworkInternal]
-        protected virtual InternalEntityTypeBuilder EntityTypeBuilder => (InternalEntityTypeBuilder)AnnotationsBuilder.MetadataBuilder;
+        protected virtual InternalEntityTypeBuilder EntityTypeBuilder => (InternalEntityTypeBuilder)AnnotationsBuilder.GetInfrastructure();
 
         /// <summary>
         ///     Configures the default discriminator value to use.
@@ -76,7 +76,7 @@ public virtual DiscriminatorBuilder HasValue<TEntity>([CanBeNull] object value)
         public virtual DiscriminatorBuilder HasValue([NotNull] Type entityType, [CanBeNull] object value)
         {
             var entityTypeBuilder = EntityTypeBuilder.ModelBuilder.Entity(
-                        entityType, AnnotationsBuilder.ConfigurationSource, owned: null);
+                        entityType, AnnotationsBuilder.ConfigurationSource, shouldBeOwned: null);
 
             return HasValue(entityTypeBuilder, value);
         }
@@ -90,7 +90,7 @@ public virtual DiscriminatorBuilder HasValue([NotNull] Type entityType, [CanBeNu
         public virtual DiscriminatorBuilder HasValue([NotNull] string entityTypeName, [CanBeNull] object value)
         {
             var entityTypeBuilder = EntityTypeBuilder.ModelBuilder.Entity(
-                        entityTypeName, AnnotationsBuilder.ConfigurationSource, owned: null);
+                        entityTypeName, AnnotationsBuilder.ConfigurationSource, shouldBeOwned: null);
 
             return HasValue(entityTypeBuilder, value);
         }

src/EFCore.Relational/Metadata/RelationalAnnotationsBuilder.cs → src/EFCore.Relational/Metadata/Internal/RelationalAnnotationsBuilder.cs

@@ -2,10 +2,10 @@
 // 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.Internal;
+using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Utilities;
 
-namespace Microsoft.EntityFrameworkCore.Metadata
+namespace Microsoft.EntityFrameworkCore.Metadata.Internal
 {
     /// <summary>
     ///     <para>
@@ -17,7 +17,7 @@ namespace Microsoft.EntityFrameworkCore.Metadata
     ///         not used in application code.
     ///     </para>
     /// </summary>
-    public class RelationalAnnotationsBuilder : RelationalAnnotations
+    public class RelationalAnnotationsBuilder : RelationalAnnotations, IInfrastructure<InternalAnnotatableBuilder>
     {
         /// <summary>
         ///     <para>
@@ -31,12 +31,12 @@ public class RelationalAnnotationsBuilder : RelationalAnnotations
         /// <param name="internalBuilder"> The internal builder to use. </param>
         /// <param name="configurationSource"> The configuration source. </param>
         public RelationalAnnotationsBuilder(
-            [NotNull] InternalMetadataBuilder internalBuilder,
+            [NotNull] InternalAnnotatableBuilder internalBuilder,
             ConfigurationSource configurationSource)
             : base(Check.NotNull(internalBuilder, nameof(internalBuilder)).Metadata)
 
         {
-            MetadataBuilder = internalBuilder;
+            AnnotatableBuilder = internalBuilder;
             ConfigurationSource = configurationSource;
         }
 
@@ -53,45 +53,48 @@ public RelationalAnnotationsBuilder(
 
         /// <summary>
         ///     <para>
-        ///         Returns the <see cref="InternalMetadataBuilder"/> being used.
+        ///         Returns the <see cref="InternalAnnotatableBuilder"/> being used.
         ///     </para>
         ///     <para>
         ///         This property is typically used by database providers (and other extensions). It is generally
         ///         not used in application code.
         ///     </para>
         /// </summary>
-        public virtual InternalMetadataBuilder MetadataBuilder { get; }
+        [EntityFrameworkInternal]
+        protected virtual InternalAnnotatableBuilder AnnotatableBuilder { get; }
 
         /// <summary>
         ///     Attempts to set an annotation with the given name to the given value and
         ///     returns whether or not this was successful.
         /// </summary>
         /// <param name="annotationName"> The name of the annotation to set. </param>
         /// <param name="value"> The value to set. </param>
-        /// <returns><c>True</c> if the annotation was set; <c>false</c> otherwise. </returns>
+        /// <returns><c>true</c> if the annotation was set; <c>false</c> otherwise. </returns>
         public override bool SetAnnotation(
             string annotationName,
             object value)
-            => MetadataBuilder.HasAnnotation(annotationName, value, ConfigurationSource);
+            => AnnotatableBuilder.HasAnnotation(annotationName, value, ConfigurationSource) != null;
 
         /// <summary>
         ///     Checks whether or not the annotation with the given name can be set to the given value.
         /// </summary>
         /// <param name="annotationName"> The name of the annotation to set. </param>
         /// <param name="value"> The value to set. </param>
-        /// <returns><c>True</c> if the annotation can be set; <c>false</c> otherwise. </returns>
+        /// <returns><c>true</c> if the annotation can be set; <c>false</c> otherwise. </returns>
         public override bool CanSetAnnotation(
             string annotationName,
             object value)
-            => MetadataBuilder.CanSetAnnotation(annotationName, value, ConfigurationSource);
+            => AnnotatableBuilder.CanSetAnnotation(annotationName, value, ConfigurationSource);
 
         /// <summary>
         ///     Attempts to remove an annotation with the given name and
         ///     returns whether or not this was successful.
         /// </summary>
         /// <param name="annotationName"> The name of the annotation to remove. </param>
-        /// <returns><c>True</c> if the annotation was removed; <c>false</c> otherwise. </returns>
+        /// <returns><c>true</c> if the annotation was removed; <c>false</c> otherwise. </returns>
         public override bool RemoveAnnotation(string annotationName)
-            => MetadataBuilder.RemoveAnnotation(annotationName, ConfigurationSource);
+            => AnnotatableBuilder.RemoveAnnotation(annotationName, ConfigurationSource) != null;
+
+        InternalAnnotatableBuilder IInfrastructure<InternalAnnotatableBuilder>.Instance => AnnotatableBuilder;
     }
 }

src/EFCore.Relational/Metadata/Internal/RelationalEntityTypeBuilderAnnotations.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Reflection;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore.Utilities;
 using Microsoft.EntityFrameworkCore.ValueGeneration.Internal;
@@ -55,7 +56,7 @@ public RelationalEntityTypeBuilderAnnotations(
         ///     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>
-        protected virtual InternalEntityTypeBuilder EntityTypeBuilder => (InternalEntityTypeBuilder)Annotations.MetadataBuilder;
+        protected virtual InternalEntityTypeBuilder EntityTypeBuilder => (InternalEntityTypeBuilder)Annotations.GetInfrastructure();
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Extensions/ConventionEntityTypeExtensions.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 System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -349,6 +348,37 @@ public static IConventionIndex AddIndex(
             return entityType.AddIndex(new[] { property }, fromDataAnnotation);
         }
 
+        /// <summary>
+        ///     <para>
+        ///         Sets the <see cref="PropertyAccessMode" /> to use for properties of all entity types
+        ///         in this model.
+        ///     </para>
+        ///     <para>
+        ///         Note that individual entity types can override this access mode, and individual properties of
+        ///         entity types can override the access mode set on the entity type. The value set here will
+        ///         be used for any property for which no override has been specified.
+        ///     </para>
+        /// </summary>
+        /// <param name="entityType"> The entity type to set the access mode for. </param>
+        /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" />, or <c>null</c> to clear the mode set.</param>
+        /// <param name="fromDataAnnotation"> Indicates whether the configuration was specified using a data annotation. </param>
+        public static void SetPropertyAccessMode(
+            [NotNull] this IConventionEntityType entityType,
+            PropertyAccessMode? propertyAccessMode,
+            bool fromDataAnnotation = false)
+            => Check.NotNull(entityType, nameof(entityType)).AsEntityType()
+                .SetPropertyAccessMode(
+                    propertyAccessMode,
+                    fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
+
+        /// <summary>
+        ///     Returns the configuration source for <see cref="ModelExtensions.GetPropertyAccessMode" />.
+        /// </summary>
+        /// <param name="entityType"> The entity type to set the access mode for. </param>
+        /// <returns> The configuration source for <see cref="ModelExtensions.GetPropertyAccessMode" />. </returns>
+        public static ConfigurationSource? GetPropertyAccessModeConfigurationSource([NotNull] this IConventionEntityType entityType)
+            => entityType.FindAnnotation(CoreAnnotationNames.PropertyAccessMode)?.GetConfigurationSource();
+
         /// <summary>
         ///     Sets the change tracking strategy to use for this entity type. This strategy indicates how the
         ///     context detects changes to properties for an instance of the entity type.
@@ -358,19 +388,12 @@ public static IConventionIndex AddIndex(
         /// <param name="fromDataAnnotation"> Indicates whether the configuration was specified using a data annotation. </param>
         public static void SetChangeTrackingStrategy(
             [NotNull] this IConventionEntityType entityType,
-            ChangeTrackingStrategy changeTrackingStrategy,
+            ChangeTrackingStrategy? changeTrackingStrategy,
             bool fromDataAnnotation = false)
-        {
-            Check.NotNull(entityType, nameof(entityType));
-
-            var errorMessage = entityType.CheckChangeTrackingStrategy(changeTrackingStrategy);
-            if (errorMessage != null)
-            {
-                throw new InvalidOperationException(errorMessage);
-            }
-
-            entityType.SetOrRemoveAnnotation(CoreAnnotationNames.ChangeTrackingStrategy, changeTrackingStrategy, fromDataAnnotation);
-        }
+            => Check.NotNull(entityType, nameof(entityType)).AsEntityType()
+                .SetChangeTrackingStrategy(
+                    changeTrackingStrategy,
+                    fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
 
         /// <summary>
         ///     Returns the configuration source for <see cref="EntityTypeExtensions.GetChangeTrackingStrategy" />.
@@ -381,7 +404,7 @@ public static void SetChangeTrackingStrategy(
             => entityType.FindAnnotation(CoreAnnotationNames.ChangeTrackingStrategy)?.GetConfigurationSource();
 
         /// <summary>
-        ///    Sets the LINQ expression filter automatically applied to queries for this entity type.
+        ///     Sets the LINQ expression filter automatically applied to queries for this entity type.
         /// </summary>
         /// <param name="entityType"> The entity type to set the query filter for. </param>
         /// <param name="queryFilter"> The LINQ expression filter. </param>
@@ -390,17 +413,10 @@ public static void SetQueryFilter(
             [NotNull] this IConventionEntityType entityType,
             [CanBeNull] LambdaExpression queryFilter,
             bool fromDataAnnotation = false)
-        {
-            Check.NotNull(entityType, nameof(entityType));
-
-            var errorMessage = entityType.CheckQueryFilter(queryFilter);
-            if (errorMessage != null)
-            {
-                throw new InvalidOperationException(errorMessage);
-            }
-
-            entityType.SetOrRemoveAnnotation(CoreAnnotationNames.QueryFilter, queryFilter, fromDataAnnotation);
-        }
+            => Check.NotNull(entityType, nameof(entityType)).AsEntityType()
+                .SetQueryFilter(
+                    queryFilter,
+                    fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
 
         /// <summary>
         ///     Returns the configuration source for <see cref="EntityTypeExtensions.GetQueryFilter" />.
@@ -420,11 +436,10 @@ public static void SetDefiningQuery(
             [NotNull] this IConventionEntityType entityType,
             [CanBeNull] LambdaExpression definingQuery,
             bool fromDataAnnotation = false)
-        {
-            Check.NotNull(entityType, nameof(entityType));
-
-            entityType.SetOrRemoveAnnotation(CoreAnnotationNames.DefiningQuery, definingQuery, fromDataAnnotation);
-        }
+            => Check.NotNull(entityType, nameof(entityType)).AsEntityType()
+                .SetDefiningQuery(
+                    definingQuery,
+                    fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
 
         /// <summary>
         ///     Returns the configuration source for <see cref="EntityTypeExtensions.GetDefiningQuery" />.