Expose an annotation-free DebugView of the model

This is mostly for me when debugging issues, since I frequently manually remove annotations to make the model easier to read.

src/EFCore/Metadata/Internal/DebugView.cs

@@ -19,21 +19,25 @@ public class DebugView<TMetadata>
         private readonly TMetadata _metadata;
 
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private readonly Func<TMetadata, string> _toDebugString;
+        private readonly Func<TMetadata, string> _toShortDebugString;
 
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private string _view;
+        private readonly Func<TMetadata, string> _toLongDebugString;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
         ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
         ///     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 DebugView([NotNull] TMetadata metadata, [NotNull] Func<TMetadata, string> toDebugString)
+        public DebugView(
+            [NotNull] TMetadata metadata,
+            [NotNull] Func<TMetadata, string> toShortDebugString,
+            [NotNull] Func<TMetadata, string> toLongDebugString)
         {
             _metadata = metadata;
-            _toDebugString = toDebugString;
+            _toShortDebugString = toShortDebugString;
+            _toLongDebugString = toLongDebugString;
         }
 
         /// <summary>
@@ -42,6 +46,14 @@ public DebugView([NotNull] TMetadata metadata, [NotNull] Func<TMetadata, string>
         ///     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 string View => _view ?? (_view = _toDebugString(_metadata));
+        public virtual string LongView => _toLongDebugString(_metadata);
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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 string ShortView => _toShortDebugString(_metadata);
     }
 }

src/EFCore/Metadata/Internal/DebugViewOptions.cs

@@ -0,0 +1,65 @@
+// 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;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+{
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     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>
+    [Flags]
+    public enum DebugViewOptions
+    {
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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>
+        IncludeAnnotations = 1,
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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>
+        IncludePropertyIndexes = 2,
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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>
+        SingleLine = 4,
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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>
+        ShortDefault = 0,
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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>
+        LongDefault = IncludeAnnotations,
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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>
+        SingleLineDefault = SingleLine
+    }
+}

src/EFCore/Metadata/Internal/EntityType.cs

@@ -463,7 +463,7 @@ private bool InheritsFrom(EntityType entityType)
         ///     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 override string ToString() => this.ToDebugString();
+        public override string ToString() => this.ToDebugString(DebugViewOptions.SingleLineDefault);
 
         /// <summary>
         ///     Runs the conventions when an annotation was set or removed.
@@ -3306,6 +3306,9 @@ public virtual void Attach([NotNull] InternalEntityTypeBuilder entityTypeBuilder
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public virtual DebugView<EntityType> DebugView
-            => new DebugView<EntityType>(this, m => m.ToDebugString(false));
+            => new DebugView<EntityType>(
+                this,
+                m => m.ToDebugString(DebugViewOptions.ShortDefault),
+                m => m.ToDebugString(DebugViewOptions.LongDefault));
     }
 }

src/EFCore/Metadata/Internal/EntityTypeExtensions.cs

@@ -481,7 +481,10 @@ public static IEnumerable<IPropertyBase> GetNotificationProperties(
         ///     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 static string ToDebugString([NotNull] this IEntityType entityType, bool singleLine = true, [NotNull] string indent = "")
+        public static string ToDebugString(
+            [NotNull] this IEntityType entityType,
+            DebugViewOptions options,
+            [NotNull] string indent = "")
         {
             var builder = new StringBuilder();
 
@@ -510,15 +513,15 @@ public static string ToDebugString([NotNull] this IEntityType entityType, bool s
                 builder.Append(" ChangeTrackingStrategy.").Append(entityType.GetChangeTrackingStrategy());
             }
 
-            if (!singleLine)
+            if ((options & DebugViewOptions.SingleLine) == 0)
             {
                 var properties = entityType.GetDeclaredProperties().ToList();
                 if (properties.Count != 0)
                 {
                     builder.AppendLine().Append(indent).Append("  Properties: ");
                     foreach (var property in properties)
                     {
-                        builder.AppendLine().Append(property.ToDebugString(singleLine: false, indent: indent + "    "));
+                        builder.AppendLine().Append(property.ToDebugString(options, indent + "    "));
                     }
                 }
 
@@ -528,7 +531,7 @@ public static string ToDebugString([NotNull] this IEntityType entityType, bool s
                     builder.AppendLine().Append(indent).Append("  Navigations: ");
                     foreach (var navigation in navigations)
                     {
-                        builder.AppendLine().Append(navigation.ToDebugString(singleLine: false, indent: indent + "    "));
+                        builder.AppendLine().Append(navigation.ToDebugString(options, indent + "    "));
                     }
                 }
 
@@ -538,7 +541,7 @@ public static string ToDebugString([NotNull] this IEntityType entityType, bool s
                     builder.AppendLine().Append(indent).Append("  Service properties: ");
                     foreach (var serviceProperty in serviceProperties)
                     {
-                        builder.AppendLine().Append(serviceProperty.ToDebugString(singleLine: false, indent: indent + "    "));
+                        builder.AppendLine().Append(serviceProperty.ToDebugString(options, indent + "    "));
                     }
                 }
 
@@ -548,7 +551,7 @@ public static string ToDebugString([NotNull] this IEntityType entityType, bool s
                     builder.AppendLine().Append(indent).Append("  Keys: ");
                     foreach (var key in keys)
                     {
-                        builder.AppendLine().Append(key.ToDebugString(singleLine: false, indent: indent + "    "));
+                        builder.AppendLine().Append(key.ToDebugString(options, indent + "    "));
                     }
                 }
 
@@ -558,11 +561,24 @@ public static string ToDebugString([NotNull] this IEntityType entityType, bool s
                     builder.AppendLine().Append(indent).Append("  Foreign keys: ");
                     foreach (var fk in fks)
                     {
-                        builder.AppendLine().Append(fk.ToDebugString(singleLine: false, indent: indent + "    "));
+                        builder.AppendLine().Append(fk.ToDebugString(options, indent + "    "));
+                    }
+                }
+
+                var indexes = entityType.GetDeclaredIndexes().ToList();
+                if (indexes.Count != 0)
+                {
+                    builder.AppendLine().Append(indent).Append("  Indexes: ");
+                    foreach (var index in indexes)
+                    {
+                        builder.AppendLine().Append(index.ToDebugString(options, indent + "    "));
                     }
                 }
 
-                builder.Append(entityType.AnnotationsToDebugString(indent: indent + "  "));
+                if ((options & DebugViewOptions.IncludeAnnotations) != 0)
+                {
+                    builder.Append(entityType.AnnotationsToDebugString(indent: indent + "  "));
+                }
             }
 
             return builder.ToString();

src/EFCore/Metadata/Internal/ForeignKey.cs

@@ -1068,7 +1068,7 @@ void IConventionForeignKey.SetDeleteBehavior(DeleteBehavior? deleteBehavior, boo
         ///     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 override string ToString() => this.ToDebugString();
+        public override string ToString() => this.ToDebugString(DebugViewOptions.SingleLineDefault);
 
         private void Validate(
             IReadOnlyList<Property> properties,
@@ -1258,7 +1258,10 @@ private static bool ArePropertyTypesCompatible(
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public virtual DebugView<ForeignKey> DebugView
-            => new DebugView<ForeignKey>(this, m => m.ToDebugString(false));
+            => new DebugView<ForeignKey>(
+                this,
+                m => m.ToDebugString(DebugViewOptions.ShortDefault),
+                m => m.ToDebugString(DebugViewOptions.LongDefault));
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Metadata/Internal/ForeignKeyExtensions.cs

@@ -270,12 +270,16 @@ public static IDependentsMap CreateDependentsMapFactory([NotNull] this IForeignK
         ///     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 static string ToDebugString([NotNull] this IForeignKey foreignKey, bool singleLine = true, [NotNull] string indent = "")
+        public static string ToDebugString(
+            [NotNull] this IForeignKey foreignKey,
+            DebugViewOptions options,
+            [NotNull] string indent = "")
         {
             var builder = new StringBuilder();
 
             builder.Append(indent);
 
+            var singleLine = (options & DebugViewOptions.SingleLine) != 0;
             if (singleLine)
             {
                 builder.Append("ForeignKey: ");
@@ -310,7 +314,8 @@ public static string ToDebugString([NotNull] this IForeignKey foreignKey, bool s
                 builder.Append(" ToPrincipal: ").Append(foreignKey.DependentToPrincipal.Name);
             }
 
-            if (!singleLine)
+            if (!singleLine &&
+                (options & DebugViewOptions.IncludeAnnotations) != 0)
             {
                 builder.Append(foreignKey.AnnotationsToDebugString(indent + "  "));
             }

src/EFCore/Metadata/Internal/Index.cs

@@ -173,7 +173,7 @@ public virtual INullableValueFactory<TKey> GetNullableValueFactory<TKey>()
         ///     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 override string ToString() => this.ToDebugString();
+        public override string ToString() => this.ToDebugString(DebugViewOptions.SingleLineDefault);
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -182,7 +182,10 @@ public virtual INullableValueFactory<TKey> GetNullableValueFactory<TKey>()
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public virtual DebugView<Index> DebugView
-            => new DebugView<Index>(this, m => m.ToDebugString(false));
+            => new DebugView<Index>(
+                this,
+                m => m.ToDebugString(DebugViewOptions.ShortDefault),
+                m => m.ToDebugString(DebugViewOptions.LongDefault));
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Metadata/Internal/IndexExtensions.cs

@@ -42,12 +42,16 @@ public static Index AsIndex([NotNull] this IIndex index, [NotNull] [CallerMember
         ///     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 static string ToDebugString([NotNull] this IIndex index, bool singleLine = true, [NotNull] string indent = "")
+        public static string ToDebugString(
+            [NotNull] this IIndex index,
+            DebugViewOptions options,
+            [NotNull] string indent = "")
         {
             var builder = new StringBuilder();
 
             builder.Append(indent);
 
+            var singleLine = (options & DebugViewOptions.SingleLine) != 0;
             if (singleLine)
             {
                 builder.Append("Index: ");
@@ -66,7 +70,8 @@ public static string ToDebugString([NotNull] this IIndex index, bool singleLine
                 builder.Append(" Unique");
             }
 
-            if (!singleLine)
+            if (!singleLine &&
+                (options & DebugViewOptions.IncludeAnnotations) != 0)
             {
                 builder.Append(index.AnnotationsToDebugString(indent + "  "));
             }

src/EFCore/Metadata/Internal/Key.cs

@@ -157,7 +157,7 @@ public virtual IPrincipalKeyValueFactory<TKey> GetPrincipalKeyValueFactory<TKey>
         ///     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 override string ToString() => this.ToDebugString();
+        public override string ToString() => this.ToDebugString(DebugViewOptions.SingleLineDefault);
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -166,7 +166,10 @@ public virtual IPrincipalKeyValueFactory<TKey> GetPrincipalKeyValueFactory<TKey>
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public virtual DebugView<Key> DebugView
-            => new DebugView<Key>(this, m => m.ToDebugString(false));
+            => new DebugView<Key>(
+                this,
+                m => m.ToDebugString(DebugViewOptions.ShortDefault),
+                m => m.ToDebugString(DebugViewOptions.LongDefault));
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Metadata/Internal/KeyExtensions.cs

@@ -59,12 +59,16 @@ public static int IndexOf([NotNull] this IKey key, [NotNull] IProperty property)
         ///     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 static string ToDebugString([NotNull] this IKey key, bool singleLine = true, [NotNull] string indent = "")
+        public static string ToDebugString(
+            [NotNull] this IKey key,
+            DebugViewOptions options,
+            [NotNull] string indent = "")
         {
             var builder = new StringBuilder();
 
             builder.Append(indent);
 
+            var singleLine = (options & DebugViewOptions.SingleLine) != 0;
             if (singleLine)
             {
                 builder.Append("Key: ");
@@ -81,7 +85,8 @@ public static string ToDebugString([NotNull] this IKey key, bool singleLine = tr
                 builder.Append(" PK");
             }
 
-            if (!singleLine)
+            if (!singleLine &&
+                (options & DebugViewOptions.IncludeAnnotations) != 0)
             {
                 builder.Append(key.AnnotationsToDebugString(indent + "  "));
             }