Add support for CSharpHelper for List literals

src/EFCore.Design/Design/Internal/CSharpHelper.cs

@@ -737,6 +737,79 @@ public virtual string Literal(object?[,] values)
  return builder.ToString();
  }
 
+ /// <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 Literal<T>(List<T> values, bool vertical = false)
+ => List(typeof(T), values, vertical);
+
+ private string List(Type type, IEnumerable values, bool vertical = false)
+ {
+ var builder = new IndentedStringBuilder();
+
+ builder.Append("new List<")
+ .Append(Reference(type))
+ .Append(">");
+
+ var first = true;
+ foreach (var value in values)
+ {
+ if (first)
+ {
+ builder.Append(" {");
+ if (vertical)
+ {
+ builder.AppendLine();
+ builder.IncrementIndent();
+ }
+ else
+ {
+ builder.Append(" ");
+ }
+ first = false;
+ }
+ else
+ {
+ builder.Append(",");
+
+ if (vertical)
+ {
+ builder.AppendLine();
+ }
+ else
+ {
+ builder.Append(" ");
+ }
+ }
+
+ builder.Append(UnknownLiteral(value));
+ }
+
+ if (first)
+ {
+ builder.Append("()");
+ }
+ else
+ {
+ if (vertical)
+ {
+ builder.AppendLine();
+ builder.DecrementIndent();
+ }
+ else
+ {
+ builder.Append(" ");
+ }
+
+ builder.Append("}");
+ }
+
+ return builder.ToString();
+ }
+
  /// <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
@@ -844,6 +917,11 @@ public virtual string UnknownLiteral(object? value)
  return Array(literalType.GetElementType()!, array);
  }
 
+ if (value is IList list && value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition() == typeof(List<>))
+ {
+ return List(value.GetType().GetGenericArguments()[0], list);
+ }
+
  var mapping = _typeMappingSource.FindMapping(literalType);
  if (mapping != null)
  {

test/EFCore.Design.Tests/Design/Internal/CSharpHelperTest.cs

@@ -121,6 +121,30 @@ public void Literal_works_when_many_ByteArray()
  new byte[] { 1, 2 },
  "new byte[] { 1, 2 }");
 
+ [ConditionalFact]
+ public void Literal_works_when_empty_list()
+ => Literal_works(
+ new List<string>(),
+ @"new List<string>()");
+
+ [ConditionalFact]
+ public void Literal_works_when_list_with_single_element()
+ => Literal_works(
+ new List<string> { "one" },
+ @"new List<string> { ""one"" }");
+
+ [ConditionalFact]
+ public void Literal_works_when_list_of_mixed_objects()
+ => Literal_works(
+ new List<object> { 1, "two" },
+ @"new List<object> { 1, ""two"" }");
+
+ [ConditionalFact]
+ public void Literal_works_when_list_with_ctor_arguments()
+ => Literal_works(
+ new List<string>(new [] { "one" }) { "two", "three" },
+ @"new List<string> { ""one"", ""two"", ""three"" }");
+
  [ConditionalFact]
  public void Literal_works_when_multiline_string()
  => Literal_works(