Add with-expressions to anonymous types (#27111)

* Add with-expressions to anonymous types

Fixes #26770

With-expressions can be used with anonymous types.

* code review

Author: BillWagner

docs/csharp/fundamentals/types/anonymous-types.md

@@ -44,6 +44,10 @@ Anonymous types are [`class`](../../language-reference/keywords/class.md) types
 
 If two or more anonymous object initializers in an assembly specify a sequence of properties that are in the same order and that have the same names and types, the compiler treats the objects as instances of the same type. They share the same compiler-generated type information.
 
+Anonymous types support non-destructive mutation in the form of [with expressions](../../language-reference/operators/with-expression.md). This enables you to create a new instance of an anonymous type where one or more properties have new values:
+
+:::code language="csharp" source="snippets/anonymous-types/Program.cs" ID="snippet02":::
+
 You cannot declare a field, a property, an event, or the return type of a method as having an anonymous type. Similarly, you cannot declare a formal parameter of a method, property, constructor, or indexer as having an anonymous type. To pass an anonymous type, or a collection that contains anonymous types, as an argument to a method, you can declare the parameter as type `object`. However, using `object` for anonymous types defeats the purpose of strong typing. If you must store query results or pass them outside the method boundary, consider using an ordinary named struct or class instead of an anonymous type.
 
 Because the <xref:System.Object.Equals%2A> and <xref:System.Object.GetHashCode%2A> methods on anonymous types are defined in terms of the `Equals` and `GetHashCode` methods of the properties, two instances of the same anonymous type are equal only if all their properties are equal.

docs/csharp/fundamentals/types/snippets/anonymous-types/Program.cs

@@ -6,7 +6,7 @@ namespace anonymous_types
 {
     class Product
     {
-        public string Color {get;set;}
+        public string? Color {get;set;}
         public  decimal Price {get;set;}
     }
     class Anonymous
@@ -16,7 +16,7 @@ static void Main()
             // don't show this unless you add a bunch more
             // properties to the type. otherwise it obviates the
             // need for the anonymous type
-            List<Product> products = new List<Product>()
+            List<Product> products = new ()
             {
                 new Product() { Color="Orange", Price=2.00M},
             };
@@ -31,6 +31,13 @@ from prod in products
                 Console.WriteLine("Color={0}, Price={1}", v.Color, v.Price);
             }
             //</snippet81>
+
+            // <Snippet02>
+            var apple = new { Item = "apples", Price = 1.35 };
+            var onSale = apple with { Price = 0.79 };
+            Console.WriteLine(apple);
+            Console.WriteLine(onSale);
+            // </Snippet02>
         }
     }
 }

docs/csharp/fundamentals/types/snippets/anonymous-types/anonymous-types.csproj

@@ -2,8 +2,10 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <RootNamespace>anonymous_types</RootNamespace>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
 </Project>

docs/csharp/language-reference/operators/snippets/with-expression/BasicExample.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 public class WithExpressionBasicExample
 {
@@ -20,5 +20,11 @@ public static void Main()
         Console.WriteLine($"{nameof(p3)}: {p3}");  // output: p3: NamedPoint { Name = C, X = 0, Y = 4 }
 
         Console.WriteLine($"{nameof(p1)}: {p1}");  // output: p1: NamedPoint { Name = A, X = 0, Y = 0 }
+
+        var apples = new { Item = "Apples", Price = "1.19" };
+        Console.WriteLine($"original apples: {apples}");
+        var saleApples = apples with { Price = "0.79" };
+        Console.WriteLine($"sale apples: {saleApples}");
+
     }
-}
+}

docs/csharp/language-reference/operators/snippets/with-expression/ExampleWithReferenceType.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 public class ExampleWithReferenceType
@@ -19,5 +19,6 @@ public static void Main()
         original.Tags.Add("C");
         Console.WriteLine($"Tags of {nameof(copy)}: {copy.PrintTags()}");
         // output: Tags of copy: A, B, C
+
     }
-}
+}

docs/csharp/language-reference/operators/snippets/with-expression/with-expression.csproj

@@ -2,10 +2,11 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
-    <LangVersion>9.0</LangVersion>
+    <TargetFramework>net6.0</TargetFramework>
     <RootNamespace>with_expression</RootNamespace>
     <StartupObject>with_expression.Program</StartupObject>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
 </Project>

docs/csharp/language-reference/operators/with-expression.md

@@ -16,7 +16,7 @@ Available in C# 9.0 and later, a `with` expression produces a copy of its operan
 
 As the preceding example shows, you use [object initializer](../../programming-guide/classes-and-structs/object-and-collection-initializers.md) syntax to specify what members to modify and their new values.
 
-In C# 9.0, a left-hand operand of a `with` expression must be of a [record type](../builtin-types/record.md). Beginning with C# 10, a left-hand operand of a `with` expression can also be of a [structure type](../builtin-types/struct.md).
+In C# 9.0, a left-hand operand of a `with` expression must be of a [record type](../builtin-types/record.md). Beginning with C# 10, a left-hand operand of a `with` expression can also be of a [structure type](../builtin-types/struct.md) or an [anonymous type](../../fundamentals/types/anonymous-types.md).
 
 The result of a `with` expression has the same run-time type as the expression's operand, as the following example shows:
 

docs/csharp/whats-new/csharp-10.md

@@ -37,7 +37,7 @@ You can declare value type records using the [`record struct` or `readonly recor
 C# 10 introduces the following improvements related to structure types:
 
 - You can declare an instance parameterless constructor in a structure type and initialize an instance field or property at its declaration. For more information, see the [Parameterless constructors and field initializers](../language-reference/builtin-types/struct.md#parameterless-constructors-and-field-initializers) section of the [Structure types](../language-reference/builtin-types/struct.md) article.
-- A left-hand operand of the [`with` expression](../language-reference/operators/with-expression.md) can be of any structure type.
+- A left-hand operand of the [`with` expression](../language-reference/operators/with-expression.md) can be of any structure type or an anonymous (reference) type.
 
 ## Interpolated string handler