Make ToDebugString methods public and DebugViews easily obtainable (#…

…20681)

Part of #20409

src/EFCore.Relational/Extensions/RelationalModelExtensions.cs

@@ -4,8 +4,10 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Text;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
@@ -14,10 +16,51 @@
 namespace Microsoft.EntityFrameworkCore
 {
     /// <summary>
-    ///     Extension methods for <see cref="IModel" /> for relational database metadata.
+    ///     Relational-specific extension methods for <see cref="IModel" /> and extension methods for <see cref="IRelationalModel"/>.
     /// </summary>
     public static class RelationalModelExtensions
     {
+        /// <summary>
+        ///     <para>
+        ///         Creates a human-readable representation of the given metadata.
+        ///     </para>
+        ///     <para>
+        ///         Warning: Do not rely on the format of the returned string.
+        ///         It is designed for debugging only and may change arbitrarily between releases.
+        ///     </para>
+        /// </summary>
+        /// <param name="model"> The metadata item. </param>
+        /// <param name="options"> Options for generating the string. </param>
+        /// <param name="indent"> The number of indent spaces to use before each new line. </param>
+        /// <returns> A human-readable representation. </returns>
+        public static string ToDebugString(
+            [NotNull] this IRelationalModel model,
+            MetadataDebugStringOptions options,
+            int indent = 0)
+        {
+            var builder = new StringBuilder();
+            var indentString = new string(' ', indent);
+
+            builder.Append(indentString).Append("DatabaseModel: ");
+
+            foreach (var table in model.Tables)
+            {
+                builder.AppendLine().Append(table.ToDebugString(options, indent + 2));
+            }
+
+            foreach (var view in model.Views)
+            {
+                builder.AppendLine().Append(view.ToDebugString(options, indent + 2));
+            }
+
+            if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
+            {
+                builder.Append(model.AnnotationsToDebugString(indent));
+            }
+
+            return builder.ToString();
+        }
+
         /// <summary>
         ///     Returns the default schema to use for the model, or <c>null</c> if none has been set.
         /// </summary>

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

@@ -5,31 +5,36 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
-namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+namespace Microsoft.EntityFrameworkCore.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.
+    ///     Extension methods for <see cref="ICheckConstraint" />.
     /// </summary>
     public static class CheckConstraintExtensions
     {
         /// <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.
+        ///     <para>
+        ///         Creates a human-readable representation of the given metadata.
+        ///     </para>
+        ///     <para>
+        ///         Warning: Do not rely on the format of the returned string.
+        ///         It is designed for debugging only and may change arbitrarily between releases.
+        ///     </para>
         /// </summary>
+        /// <param name="constraint"> The metadata item. </param>
+        /// <param name="options"> Options for generating the string. </param>
+        /// <param name="indent"> The number of indent spaces to use before each new line. </param>
+        /// <returns> A human-readable representation. </returns>
         public static string ToDebugString(
             [NotNull] this ICheckConstraint constraint,
             MetadataDebugStringOptions options,
-            [NotNull] string indent = "")
+            int indent = 0)
         {
             var builder = new StringBuilder();
+            var indentString = new string(' ', indent);
 
             builder
-                .Append(indent)
+                .Append(indentString)
                 .Append("Check: ");
 
             builder.Append(constraint.Name)
@@ -41,7 +46,7 @@ public static string ToDebugString(
             {
                 if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
                 {
-                    builder.Append(constraint.AnnotationsToDebugString(indent: indent + "  "));
+                    builder.Append(constraint.AnnotationsToDebugString(indent: indent + 2));
                 }
             }
 

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

@@ -5,30 +5,35 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
-namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+namespace Microsoft.EntityFrameworkCore.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.
+    ///     Extension methods for <see cref="IColumn" />.
     /// </summary>
     public static class ColumnExtensions
     {
         /// <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.
+        ///     <para>
+        ///         Creates a human-readable representation of the given metadata.
+        ///     </para>
+        ///     <para>
+        ///         Warning: Do not rely on the format of the returned string.
+        ///         It is designed for debugging only and may change arbitrarily between releases.
+        ///     </para>
         /// </summary>
+        /// <param name="column"> The metadata item. </param>
+        /// <param name="options"> Options for generating the string. </param>
+        /// <param name="indent"> The number of indent spaces to use before each new line. </param>
+        /// <returns> A human-readable representation. </returns>
         public static string ToDebugString(
             [NotNull] this IColumn column,
             MetadataDebugStringOptions options,
-            [NotNull] string indent = "")
+            int indent = 0)
         {
             var builder = new StringBuilder();
+            var indentString = new string(' ', indent);
 
-            builder.Append(indent);
+            builder.Append(indentString);
 
             var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0;
             if (singleLine)
@@ -54,7 +59,7 @@ public static string ToDebugString(
             if (!singleLine &&
                 (options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
             {
-                builder.Append(column.AnnotationsToDebugString(indent + "  "));
+                builder.Append(column.AnnotationsToDebugString(indent + 2));
             }
 
             return builder.ToString();

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

@@ -5,30 +5,35 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
-namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+namespace Microsoft.EntityFrameworkCore.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.
+    ///     Extension methods for <see cref="IColumnMapping" />.
     /// </summary>
     public static class ColumnMappingExtensions
     {
         /// <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.
+        ///     <para>
+        ///         Creates a human-readable representation of the given metadata.
+        ///     </para>
+        ///     <para>
+        ///         Warning: Do not rely on the format of the returned string.
+        ///         It is designed for debugging only and may change arbitrarily between releases.
+        ///     </para>
         /// </summary>
+        /// <param name="columnMapping"> The metadata item. </param>
+        /// <param name="options"> Options for generating the string. </param>
+        /// <param name="indent"> The number of indent spaces to use before each new line. </param>
+        /// <returns> A human-readable representation. </returns>
         public static string ToDebugString(
             [NotNull] this IColumnMapping columnMapping,
             MetadataDebugStringOptions options,
-            [NotNull] string indent = "")
+            int indent = 0)
         {
             var builder = new StringBuilder();
+            var indentString = new string(' ', indent);
 
-            builder.Append(indent);
+            builder.Append(indentString);
 
             var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0;
             if (singleLine)
@@ -50,7 +55,7 @@ public static string ToDebugString(
             if (!singleLine &&
                 (options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
             {
-                builder.Append(columnMapping.AnnotationsToDebugString(indent + "  "));
+                builder.Append(columnMapping.AnnotationsToDebugString(indent + 2));
             }
 
             return builder.ToString();

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

@@ -6,31 +6,36 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
-namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+namespace Microsoft.EntityFrameworkCore.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.
+    ///     Extension methods for <see cref="IDbFunction" />.
     /// </summary>
     public static class DbFunctionExtensions
     {
         /// <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.
+        ///     <para>
+        ///         Creates a human-readable representation of the given metadata.
+        ///     </para>
+        ///     <para>
+        ///         Warning: Do not rely on the format of the returned string.
+        ///         It is designed for debugging only and may change arbitrarily between releases.
+        ///     </para>
         /// </summary>
+        /// <param name="function"> The metadata item. </param>
+        /// <param name="options"> Options for generating the string. </param>
+        /// <param name="indent"> The number of indent spaces to use before each new line. </param>
+        /// <returns> A human-readable representation. </returns>
         public static string ToDebugString(
             [NotNull] this IDbFunction function,
             MetadataDebugStringOptions options,
-            [NotNull] string indent = "")
+            int indent = 0)
         {
             var builder = new StringBuilder();
+            var indentString = new string(' ', indent);
 
             builder
-                .Append(indent)
+                .Append(indentString)
                 .Append("DbFunction: ");
 
             builder.Append(function.ReturnType.ShortDisplayName())
@@ -50,16 +55,16 @@ public static string ToDebugString(
                 var parameters = function.Parameters.ToList();
                 if (parameters.Count != 0)
                 {
-                    builder.AppendLine().Append(indent).Append("  Parameters: ");
+                    builder.AppendLine().Append(indentString).Append("  Parameters: ");
                     foreach (var parameter in parameters)
                     {
-                        builder.AppendLine().Append(parameter.ToDebugString(options, indent + "    "));
+                        builder.AppendLine().Append(parameter.ToDebugString(options, indent + 4));
                     }
                 }
 
                 if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
                 {
-                    builder.Append(function.AnnotationsToDebugString(indent: indent + "  "));
+                    builder.Append(function.AnnotationsToDebugString(indent: indent + 2));
                 }
             }
 

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

@@ -5,31 +5,36 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
-namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+namespace Microsoft.EntityFrameworkCore.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.
+    ///     Extension methods for <see cref="IDbFunctionParameter" />.
     /// </summary>
     public static class DbFunctionParameterExtensions
     {
         /// <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.
+        ///     <para>
+        ///         Creates a human-readable representation of the given metadata.
+        ///     </para>
+        ///     <para>
+        ///         Warning: Do not rely on the format of the returned string.
+        ///         It is designed for debugging only and may change arbitrarily between releases.
+        ///     </para>
         /// </summary>
+        /// <param name="parameter"> The metadata item. </param>
+        /// <param name="options"> Options for generating the string. </param>
+        /// <param name="indent"> The number of indent spaces to use before each new line. </param>
+        /// <returns> A human-readable representation. </returns>
         public static string ToDebugString(
             [NotNull] this IDbFunctionParameter parameter,
             MetadataDebugStringOptions options,
-            [NotNull] string indent = "")
+            int indent = 0)
         {
             var builder = new StringBuilder();
+            var indentString = new string(' ', indent);
 
             builder
-                .Append(indent)
+                .Append(indentString)
                 .Append("DbFunctionParameter: ");
 
             builder.Append(parameter.Name)
@@ -40,7 +45,7 @@ public static string ToDebugString(
             {
                 if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
                 {
-                    builder.Append(parameter.AnnotationsToDebugString(indent: indent + "  "));
+                    builder.Append(parameter.AnnotationsToDebugString(indent + 2));
                 }
             }