Add tuples comparison and guidance to anonymous types article

Co-authored-by: meaghanlewis <[email protected]>

Author: Copilot

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

@@ -12,6 +12,9 @@ helpviewer_keywords:
 
 Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without having to explicitly define a type first. The type name is generated by the compiler and isn't available at the source code level. The type of each property is inferred by the compiler.
 
+> [!TIP]
+> In most scenarios, [tuples](../../language-reference/builtin-types/value-tuples.md) are the preferred choice over anonymous types. Tuples provide better performance, support deconstruction, and offer more flexible syntax. Use anonymous types primarily when you need expression tree support or when working with code that requires reference types.
+
 You create anonymous types by using the [`new`](../../language-reference/operators/new-operator.md) operator together with an object initializer. For more information about object initializers, see [Object and Collection Initializers](../../programming-guide/classes-and-structs/object-and-collection-initializers.md).
 
 The following example shows an anonymous type that is initialized with two properties named `Amount` and `Message`.
@@ -28,6 +31,43 @@ Anonymous types are typically used in the [`select`](../../language-reference/ke
 
 Anonymous types contain one or more public read-only properties. No other kinds of class members, such as methods or events, are valid. The expression that is used to initialize a property can't be `null`, an anonymous function, or a pointer type.
 
+## Anonymous types vs tuples
+
+Both anonymous types and tuples let you group multiple values without defining a named type. However, tuples are the preferred choice in most scenarios because they provide better performance and more flexibility. The following table summarizes the key differences:
+
+| Feature | Anonymous types | Tuples |
+|---------|----------------|--------|
+| Type | Reference type (`class`) | Value type (`struct`) |
+| Performance | Heap allocation | Stack allocation (better performance) |
+| Mutability | Read-only properties | Mutable fields |
+| Deconstruction | Not supported | Supported |
+| Expression trees | Supported | Not supported |
+| Access modifier | `internal` | `public` |
+| Member names | Required or inferred | Optional (with default names like `Item1`, `Item2`) |
+
+### When to use tuples
+
+Use tuples when:
+
+- You need better performance through stack allocation.
+- You want to deconstruct values into separate variables.
+- You're returning multiple values from a method.
+- You don't need expression tree support.
+
+The following example shows how tuples provide similar functionality to anonymous types with cleaner syntax:
+
+:::code language="csharp" source="snippets/anonymous-types/Program.cs" ID="TupleExample":::
+
+### When to use anonymous types
+
+Use anonymous types when:
+
+- You're working with expression trees (for example, in some LINQ providers).
+- You need the object to be a reference type.
+- You're projecting query results in LINQ and want named properties without defining a class.
+
+For more information about choosing between anonymous types and tuples, see [Choosing between anonymous and tuple types](../../../standard/base-types/choosing-between-anonymous-and-tuple.md).
+
 The most common scenario is to initialize an anonymous type with properties from another type. In the following example, assume that a class exists that is named `Product`. Class `Product` includes `Color` and `Price` properties, together with other properties that you aren't interested in:
 
 :::code language="csharp" source="snippets/anonymous-types/Program.cs" ID="ProductDefinition":::
@@ -93,3 +133,10 @@ var v = new { Title = "Hello", Age = 24 };
 
 Console.WriteLine(v.ToString()); // "{ Title = Hello, Age = 24 }"
 ```
+
+## See also
+
+- [Tuple types](../../language-reference/builtin-types/value-tuples.md)
+- [Choosing between anonymous and tuple types](../../../standard/base-types/choosing-between-anonymous-and-tuple.md)
+- [Object and Collection Initializers](../../programming-guide/classes-and-structs/object-and-collection-initializers.md)
+- [LINQ in C#](../../linq/index.md)

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

@@ -78,6 +78,20 @@ from prod in products
 
             Console.WriteLine($"Title: {employee.title}, Department: {employee.department}, Salary: {employee.salary}");
             // </ProjectionExample>
+
+            // <TupleExample>
+            // Anonymous type example.
+            var anonymousProduct = new { Name = "Widget", Price = 19.99M };
+            Console.WriteLine($"Anonymous: {anonymousProduct.Name} costs ${anonymousProduct.Price}");
+
+            // Equivalent using a tuple with named elements.
+            var tupleProduct = (Name: "Widget", Price: 19.99M);
+            Console.WriteLine($"Tuple: {tupleProduct.Name} costs ${tupleProduct.Price}");
+
+            // Tuples support deconstruction.
+            var (productName, productPrice) = tupleProduct;
+            Console.WriteLine($"Deconstructed: {productName} costs ${productPrice}");
+            // </TupleExample>
         }
     }
 }