BackingFieldAttribute also works for Navigations.

src/EFCore.Abstractions/BackingFieldAttribute.cs

@@ -8,7 +8,7 @@
 namespace Microsoft.EntityFrameworkCore
 {
     /// <summary>
-    ///     Names the backing field associated with this property.
+    ///     Names the backing field associated with this property or navigation property.
     /// </summary>
     [AttributeUsage(AttributeTargets.Property)]
     public sealed class BackingFieldAttribute : Attribute

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

@@ -185,6 +185,7 @@ public virtual ConventionSet CreateConventionSet()
             conventionSet.ModelFinalizedConventions.Add(new ValidatingConvention(Dependencies));
 
             conventionSet.NavigationAddedConventions.Add(backingFieldConvention);
+            conventionSet.NavigationAddedConventions.Add(new NavigationBackingFieldAttributeConvention(Dependencies));
             conventionSet.NavigationAddedConventions.Add(new RequiredNavigationAttributeConvention(Dependencies));
             conventionSet.NavigationAddedConventions.Add(nonNullableNavigationConvention);
             conventionSet.NavigationAddedConventions.Add(inversePropertyAttributeConvention);

src/EFCore/Metadata/Conventions/NavigationBackingFieldAttributeConvention.cs

@@ -0,0 +1,40 @@
+// 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.Reflection;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     A convention that configures a navigation property as having a backing field
+    ///     based on the <see cref="BackingFieldAttribute"/> attribute.
+    /// </summary>
+    public class NavigationBackingFieldAttributeConvention : NavigationAttributeConventionBase<BackingFieldAttribute>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="NavigationBackingFieldAttributeConvention" />.
+        /// </summary>
+        /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
+        public NavigationBackingFieldAttributeConvention([NotNull] ProviderConventionSetBuilderDependencies dependencies)
+            : base(dependencies)
+        {
+        }
+
+        /// <summary>
+        ///     Called after a navigation property that has an attribute is added to an entity type.
+        /// </summary>
+        /// <param name="navigationBuilder"> The builder for the navigation. </param>
+        /// <param name="attribute"> The attribute. </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        public override void ProcessNavigationAdded(
+            IConventionNavigationBuilder navigationBuilder,
+            BackingFieldAttribute attribute,
+            IConventionContext<IConventionNavigationBuilder> context)
+        {
+            navigationBuilder.HasField(attribute.Name, fromDataAnnotation: true);
+        }
+    }
+}

test/EFCore.Tests/Metadata/Conventions/NavigationAttributeConventionTest.cs

@@ -962,6 +962,16 @@ private void RunRequiredNavigationAttributeConvention(InternalForeignKeyBuilder
                 .ProcessNavigationAdded(navigation.Builder, context);
         }
 
+        private void RunNavigationBackingFieldAttributeConvention(InternalForeignKeyBuilder relationshipBuilder, InternalNavigationBuilder navigationBuilder)
+        {
+            var dependencies = CreateDependencies(CreateLogger());
+            var context = new ConventionContext<IConventionNavigationBuilder>(
+                relationshipBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
+
+            new NavigationBackingFieldAttributeConvention(dependencies)
+                .ProcessNavigationAdded(navigationBuilder, context);
+        }
+
         private void Validate(InternalEntityTypeBuilder entityTypeBuilder)
         {
             var dependencies = CreateDependencies(CreateLogger());
@@ -980,6 +990,52 @@ private void Validate(InternalEntityTypeBuilder entityTypeBuilder)
 
         #endregion
 
+        #region BackingFieldAttribute
+
+        [ConditionalFact]
+        public void BackingFieldAttribute_overrides_configuration_from_convention_source()
+        {
+            var dependentEntityTypeBuilder = CreateInternalEntityTypeBuilder<DependentForNavWithBackingField>();
+            var principalEntityTypeBuilder =
+                dependentEntityTypeBuilder.ModelBuilder.Entity(
+                    typeof(PrincipalForNavWithBackingField), ConfigurationSource.Convention);
+
+            var relationshipBuilder = dependentEntityTypeBuilder.HasRelationship(
+                    principalEntityTypeBuilder.Metadata,
+                    "PrincipalForNavWithBackingField",
+                    "DependentForNavWithBackingField",
+                    ConfigurationSource.Convention);
+
+            var navigationBuilder = relationshipBuilder.Metadata.DependentToPrincipal.Builder;
+            RunNavigationBackingFieldAttributeConvention(relationshipBuilder, navigationBuilder);
+
+            Assert.Equal("_backingFieldFromAttribute", navigationBuilder.Metadata.GetFieldName());
+        }
+
+        [ConditionalFact]
+        public void BackingFieldAttribute_does_not_override_configuration_from_explicit_source()
+        {
+            var dependentEntityTypeBuilder = CreateInternalEntityTypeBuilder<DependentForNavWithBackingField>();
+            var principalEntityTypeBuilder =
+                dependentEntityTypeBuilder.ModelBuilder.Entity(
+                    typeof(PrincipalForNavWithBackingField), ConfigurationSource.Convention);
+
+            var relationshipBuilder = dependentEntityTypeBuilder.HasRelationship(
+                    principalEntityTypeBuilder.Metadata,
+                    "PrincipalForNavWithBackingField",
+                    "DependentForNavWithBackingField",
+                    ConfigurationSource.Convention);
+
+            var navigationBuilder = relationshipBuilder.Metadata.DependentToPrincipal.Builder;
+            navigationBuilder.HasField("_backingFieldFromFluentApi", ConfigurationSource.Explicit);
+
+            RunNavigationBackingFieldAttributeConvention(relationshipBuilder, navigationBuilder);
+
+            Assert.Equal("_backingFieldFromFluentApi", navigationBuilder.Metadata.GetFieldName());
+        }
+
+        #endregion
+
         [ConditionalFact]
         public void Navigation_attribute_convention_runs_for_private_property()
         {
@@ -1245,5 +1301,27 @@ private class InvertedPrincipal
 
             public ICollection<Dependent> Dependents { get; set; }
         }
+
+        private class PrincipalForNavWithBackingField
+        {
+            public int Id { get; set; }
+
+            public DependentForNavWithBackingField DependentForNavWithBackingField { get; set; }
+        }
+
+        private class DependentForNavWithBackingField
+        {
+            public int Id { get; set; }
+
+#pragma warning disable IDE0044 // Add readonly modifier
+#pragma warning disable CS0169 // Field never used
+            private PrincipalForNavWithBackingField _backingFieldFromAttribute;
+            private PrincipalForNavWithBackingField _backingFieldFromFluentApi;
+#pragma warning restore CS0169 // Field never used
+#pragma warning restore IDE0044 // Add readonly modifier
+
+            [BackingField(nameof(_backingFieldFromAttribute))]
+            public PrincipalForNavWithBackingField PrincipalForNavWithBackingField { get; set; }
+        }
     }
 }