Improved exception messages

Fixes #19383
Fixes #17123

> No suitable constructor was found for entity type 'BlogNone'. The following constructors had parameters that could not be bound to properties of the entity type: cannot bind 'did' in 'BlogNone(string title, int did)'; cannot bind 'notTitle' in 'BlogNone(string notTitle, Guid? shadow, int id)'; cannot bind 'dummy' in 'BlogNone(string title, Guid? shadow, bool dummy, int id)'; cannot bind 'dummy', 'description' in 'BlogNone(string title, Guid? shadow, bool dummy, int id, string description)'. Note that only mapped properties can be bound to constructor parameters. Navigations to related entities, including references to owned types, cannot be bound.

Fixes #26341

> The 'DateOnly' property 'Blog.PostedOn' could not be mapped because the database provider does not support this type. Consider converting the property value to a type supported by the database using a value converter. See https://aka.ms/efcore-docs-value-converters for more information. Alternately, exclude the property from the model using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.

Or if the store type is specified:

> The 'DateOnly' property 'Blog.PostedOn' could not be mapped to the database type 'datetime2' because the database provider does not support mapping 'DateOnly' properties to 'datetime2' columns. Consider mapping to a different database type or converting the property value to a type supported by the database using a value converter. See https://aka.ms/efcore-docs-value-converters for more information. Alternately, exclude the property from the model using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.

Fixes #21954

> Cannot save instance of 'Skinner' because it is an owned entity without any reference to its owner. Owned entities can only be saved as part of an aggregate also including the owner entity.

src/EFCore.Relational/Infrastructure/RelationalModelValidator.cs

@@ -1525,5 +1525,31 @@ protected virtual void ValidateIndexProperties(
                 }
             }
         }
+
+        /// <summary>
+        ///     Throws an <see cref="InvalidOperationException"/> with a message containing provider-specific information, when
+        ///     available, indicating possible reasons why the property cannot be mapped.
+        /// </summary>
+        /// <param name="propertyType">The property CLR type.</param>
+        /// <param name="entityType">The entity type.</param>
+        /// <param name="unmappedProperty">The property.</param>
+        protected override void ThrowPropertyNotMappedException(
+            string propertyType,
+            IConventionEntityType entityType, 
+            IConventionProperty unmappedProperty)
+        {
+            var storeType = unmappedProperty.GetColumnType();
+            if (storeType != null)
+            {
+                throw new InvalidOperationException(
+                    RelationalStrings.PropertyNotMapped(
+                        propertyType,
+                        entityType.DisplayName(),
+                        unmappedProperty.Name,
+                        storeType));
+            }
+
+            base.ThrowPropertyNotMappedException(propertyType, entityType, unmappedProperty);
+        }
     }
 }

src/EFCore.Relational/Properties/RelationalStrings.resx

@@ -728,6 +728,9 @@
   <data name="ProjectionMappingCountMismatch" xml:space="preserve">
     <value>Unable to translate set operations when both sides don't assign values to the same properties in the nominal type. Please make sure that the same properties are included on both sides, and consider assigning default values if a property doesn't require a specific value.</value>
   </data>
+  <data name="PropertyNotMapped" xml:space="preserve">
+    <value>The '{propertyType}' property '{entityType}.{property}' could not be mapped to the database type '{storeType}' because the database provider does not support mapping '{propertyType}' properties to '{storeType}' columns. Consider mapping to a different database type or converting the property value to a type supported by the database using a value converter. See https://aka.ms/efcore-docs-value-converters for more information. Alternately, exclude the property from the model using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.</value>
+  </data>
   <data name="PropertyNotMappedToTable" xml:space="preserve">
     <value>The property '{property}' on entity type '{entityType}' is not mapped to '{table}'.</value>
   </data>

src/EFCore/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -1487,6 +1487,10 @@ public InternalEntityEntry PrepareToSave()
                         && property.IsForeignKey()
                         && _stateData.IsPropertyFlagged(property.GetIndex(), PropertyFlag.Unknown))
                     {
+                        if (property.GetContainingForeignKeys().Any(fk => fk.IsOwnership))
+                        {
+                            throw new InvalidOperationException(CoreStrings.SaveOwnedWithoutOwner(entityType.DisplayName()));    
+                        }
                         throw new InvalidOperationException(CoreStrings.UnknownKeyValue(entityType.DisplayName(), property.Name));
                     }
                 }

src/EFCore/Infrastructure/ModelValidator.cs

@@ -170,10 +170,10 @@ protected virtual void ValidatePropertyMapping(
 
                 if (unmappedProperty != null)
                 {
-                    throw new InvalidOperationException(
-                        CoreStrings.PropertyNotMapped(
-                            entityType.DisplayName(), unmappedProperty.Name,
-                            (unmappedProperty.GetValueConverter()?.ProviderClrType ?? unmappedProperty.ClrType).ShortDisplayName()));
+                    ThrowPropertyNotMappedException(
+                        (unmappedProperty.GetValueConverter()?.ProviderClrType ?? unmappedProperty.ClrType).ShortDisplayName(),
+                        entityType,
+                        unmappedProperty);
                 }
 
                 if (entityType.ClrType == Model.DefaultPropertyBagType)
@@ -287,6 +287,23 @@ protected virtual void ValidatePropertyMapping(
             }
         }
 
+        /// <summary>
+        ///     Throws an <see cref="InvalidOperationException"/> with a message containing provider-specific information, when
+        ///     available, indicating possible reasons why the property cannot be mapped.
+        /// </summary>
+        /// <param name="propertyType">The property CLR type.</param>
+        /// <param name="entityType">The entity type.</param>
+        /// <param name="unmappedProperty">The property.</param>
+        protected virtual void ThrowPropertyNotMappedException(
+            string propertyType,
+            IConventionEntityType entityType, 
+            IConventionProperty unmappedProperty)
+            => throw new InvalidOperationException(
+                CoreStrings.PropertyNotMapped(
+                    propertyType,
+                    entityType.DisplayName(), 
+                    unmappedProperty.Name));
+
         /// <summary>
         ///     Returns a value indicating whether that target CLR type would correspond to an owned entity type.
         /// </summary>

src/EFCore/Properties/CoreStrings.resx

@@ -311,7 +311,7 @@
     <value>The constructors '{firstConstructor}' and '{secondConstructor}' have the same number of parameters, and can both be used by Entity Framework. The constructor to be used must be configured in 'OnModelCreating'.</value>
   </data>
   <data name="ConstructorNotFound" xml:space="preserve">
-    <value>No suitable constructor was found for entity type '{entityType}'. The following constructors had parameters that could not be bound to properties of the entity type: {constructors}.</value>
+    <value>No suitable constructor was found for entity type '{entityType}'. The following constructors had parameters that could not be bound to properties of the entity type: {constructors}. Note that only mapped properties can be bound to constructor parameters. Navigations to related entities, including references to owned types, cannot be bound.</value>
   </data>
   <data name="ContextDisposed" xml:space="preserve">
     <value>Cannot access a disposed context instance. A common cause of this error is disposing a context instance that was resolved from dependency injection and then later trying to use the same context instance elsewhere in your application. This may occur if you are calling 'Dispose' on the context instance, or wrapping it in a using statement. If you are using dependency injection, you should let the dependency injection container take care of disposing context instances.</value>
@@ -1290,7 +1290,7 @@
     <value>The property '{1_entityType}.{0_property}' could not be found. Ensure that the property exists and has been included in the model.</value>
   </data>
   <data name="PropertyNotMapped" xml:space="preserve">
-    <value>The property '{entityType}.{property}' is of type '{propertyType}' which is not supported by the current database provider. Either change the property CLR type, or ignore the property using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.</value>
+    <value>The '{propertyType}' property '{entityType}.{property}' could not be mapped because the database provider does not support this type. Consider converting the property value to a type supported by the database using a value converter. See https://aka.ms/efcore-docs-value-converters for more information. Alternately, exclude the property from the model using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.</value>
   </data>
   <data name="PropertyReadOnlyAfterSave" xml:space="preserve">
     <value>The property '{1_entityType}.{0_property}' is defined as read-only after it has been saved, but its value has been modified or marked as modified.</value>
@@ -1373,6 +1373,9 @@
   <data name="RuntimeParameterMissingParameter" xml:space="preserve">
     <value>While registering a runtime parameter, the lambda expression must have only one parameter which must be same as 'QueryCompilationContext.QueryContextParameter' expression.</value>
   </data>
+  <data name="SaveOwnedWithoutOwner" xml:space="preserve">
+    <value>Cannot save instance of '{entityType}' because it is an owned entity without any reference to its owner. Owned entities can only be saved as part of an aggregate also including the owner entity.</value>
+  </data>
   <data name="SavepointsNotSupported" xml:space="preserve">
     <value>Savepoints are not supported by the database provider in use.</value>
   </data>

test/EFCore.Relational.Tests/Infrastructure/RelationalModelValidatorTest.PropertyMapping.cs

@@ -20,7 +20,9 @@ public void Throws_when_added_property_is_not_mapped_to_store()
 
             Assert.Equal(
                 CoreStrings.PropertyNotMapped(
-                    typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(), "LongProperty", typeof(Tuple<long>).ShortDisplayName()),
+                    typeof(Tuple<long>).ShortDisplayName(),
+                    typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(),
+                    "LongProperty"),
                 Assert.Throws<InvalidOperationException>(() => Validate(modelBuilder)).Message);
         }
 
@@ -33,9 +35,11 @@ public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured
                 .HasColumnType("some_int_mapping");
 
             Assert.Equal(
-                CoreStrings.PropertyNotMapped(
-                    typeof(NonPrimitiveNonNavigationAsPropertyEntity).ShortDisplayName(), "LongProperty",
-                    typeof(Tuple<long>).ShortDisplayName()),
+                RelationalStrings.PropertyNotMapped(
+                    typeof(Tuple<long>).ShortDisplayName(),
+                    typeof(NonPrimitiveNonNavigationAsPropertyEntity).ShortDisplayName(),
+                    "LongProperty",
+                    "some_int_mapping"),
                 Assert.Throws<InvalidOperationException>(() => Validate(modelBuilder)).Message);
         }
     }

test/EFCore.Relational.Tests/Infrastructure/RelationalModelValidatorTest.cs

@@ -32,7 +32,7 @@ public override void Detects_key_property_which_cannot_be_compared()
             });
 
             VerifyError(
-                CoreStrings.PropertyNotMapped(nameof(WithNonComparableKey), nameof(WithNonComparableKey.Id), nameof(NotComparable)),
+                CoreStrings.PropertyNotMapped(nameof(NotComparable), nameof(WithNonComparableKey), nameof(WithNonComparableKey.Id)),
                 modelBuilder);
         }
 
@@ -47,7 +47,7 @@ public override void Detects_unique_index_property_which_cannot_be_compared()
 
             VerifyError(
                 CoreStrings.PropertyNotMapped(
-                    nameof(WithNonComparableUniqueIndex), nameof(WithNonComparableUniqueIndex.Index), nameof(NotComparable)),
+                    nameof(NotComparable), nameof(WithNonComparableUniqueIndex), nameof(WithNonComparableUniqueIndex.Index)),
                 modelBuilder);
         }
 
@@ -64,7 +64,7 @@ public override void Ignores_normal_property_which_cannot_be_compared()
 
             VerifyError(
                 CoreStrings.PropertyNotMapped(
-                    nameof(WithNonComparableNormalProperty), nameof(WithNonComparableNormalProperty.Foo), nameof(NotComparable)),
+                    nameof(NotComparable), nameof(WithNonComparableNormalProperty), nameof(WithNonComparableNormalProperty.Foo)),
                 modelBuilder);
         }
 

test/EFCore.Tests/ChangeTracking/ChangeTrackerTest.cs

@@ -326,7 +326,59 @@ public async Task Keys_generated_on_behalf_of_a_principal_are_not_saved(bool asy
 
             Assert.Equal(
                 CoreStrings.UnknownKeyValue(nameof(Weak), nameof(Weak.HeroId)),
-                Assert.Throws<InvalidOperationException>(() => context.SaveChanges()).Message);
+                (await Assert.ThrowsAsync<InvalidOperationException>(
+                    async () => _ = async ? await context.SaveChangesAsync() : context.SaveChanges()))
+                .Message);
+        }
+
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public async Task Attached_owned_entity_without_owner_not_saved(bool async)
+        {
+            using var context = new WeakHerosContext();
+
+            if (async)
+            {
+                await context.AddAsync(new Skinner());
+            }
+            else
+            {
+                context.Add(new Skinner());
+            }
+
+            Assert.True(context.ChangeTracker.HasChanges());
+
+            Assert.Equal(
+                CoreStrings.SaveOwnedWithoutOwner(nameof(Skinner)),
+                (await Assert.ThrowsAsync<InvalidOperationException>(
+                    async () => _ = async ? await context.SaveChangesAsync() : context.SaveChanges()))
+                .Message);
+        }
+
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public async Task Attached_owned_collection_entity_without_owner_not_saved(bool async)
+        {
+            using var context = new WeakHerosContext();
+
+            if (async)
+            {
+                await context.AddAsync(new TheStreets());
+            }
+            else
+            {
+                context.Add(new TheStreets());
+            }
+
+            Assert.True(context.ChangeTracker.HasChanges());
+
+            Assert.Equal(
+                CoreStrings.SaveOwnedWithoutOwner(nameof(TheStreets)),
+                (await Assert.ThrowsAsync<InvalidOperationException>(
+                    async () => _ = async ? await context.SaveChangesAsync() : context.SaveChanges()))
+                .Message);
         }
 
         public class Hero
@@ -343,16 +395,40 @@ public class Weak
             public Hero Hero { get; set; }
         }
 
+        public class Mike
+        {
+            public Guid Id { get; set; }
+            public ICollection<TheStreets> TheStreets { get; set; }
+            public Skinner TheHero { get; set; }
+        }
+
+        public class Skinner
+        {
+        }
+
+        public class TheStreets
+        {
+        }
+
         public class WeakHerosContext : DbContext
         {
             protected internal override void OnModelCreating(ModelBuilder modelBuilder)
-                => modelBuilder.Entity<Weak>(
+            {
+                modelBuilder.Entity<Weak>(
                     b =>
                     {
                         b.HasKey(e => new { e.Id, e.HeroId });
                         b.HasOne(e => e.Hero).WithMany(e => e.Weaks).HasForeignKey(e => e.HeroId);
                     });
 
+                modelBuilder.Entity<Mike>(
+                    b =>
+                    {
+                        b.OwnsOne(e => e.TheHero);
+                        b.OwnsMany(e => e.TheStreets);
+                    });
+            }
+
             protected internal override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
                 => optionsBuilder.UseInMemoryDatabase(nameof(WeakHerosContext));
         }

test/EFCore.Tests/Infrastructure/ModelValidatorTest.PropertyMapping.cs

@@ -27,9 +27,9 @@ public virtual void Throws_when_added_property_is_not_of_primitive_type()
 
             Assert.Equal(
                 CoreStrings.PropertyNotMapped(
+                    typeof(NavigationAsProperty).ShortDisplayName(),
                     typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(),
-                    nameof(NonPrimitiveAsPropertyEntity.Property),
-                    typeof(NavigationAsProperty).ShortDisplayName()),
+                    nameof(NonPrimitiveAsPropertyEntity.Property)),
                 Assert.Throws<InvalidOperationException>(() => Validate(modelBuilder)).Message);
         }