Merge pull request #49742 from wwlpublish/72e4a7ae727b8d605084f0ca780abb7d01b91fde2816067e61793aec2b5011df-live

 Modules/M04-get-started-generic-anonymous-types

Author: ttorble

learn-pr/wwl-azure/get-started-generic-anonymous-types/1-introduction.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.introduction
+title: Introduction
+metadata:
+  title: Introduction
+  description: "Introduction to the module."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/1-introduction.md)]

learn-pr/wwl-azure/get-started-generic-anonymous-types/2-examine-generics.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.examine-generics
+title: Examine generics
+metadata:
+  title: Examine generics
+  description: "Learn how generics acts as code templates that allow you to define type-safe data structures without committing to an actual data type."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 6
+content: |
+  [!include[](includes/2-examine-generics.md)]

learn-pr/wwl-azure/get-started-generic-anonymous-types/3-explore-advanced-generics-concepts.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.explore-advanced-generics-concepts
+title: Explore advanced generics concepts
+metadata:
+  title: Explore advanced generics concepts
+  description: "Understand advanced concepts of generics, including covariance, contravariance, and generic constraints, to write more flexible, and reusable code."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 8
+content: |
+  [!include[](includes/3-explore-advanced-generics-concepts.md)]

learn-pr/wwl-azure/get-started-generic-anonymous-types/4-practical-applications-anonymous-types.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.practical-applications-anonymous-types
+title: Practical applications of anonymous types
+metadata:
+  title: Practical applications of anonymous types
+  description: "Learn how to use anonymous types in C# for temporary data structures, LINQ queries, and efficient grouping of related data."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 7
+content: |
+  [!include[](includes/4-practical-applications-anonymous-types.md)]

learn-pr/wwl-azure/get-started-generic-anonymous-types/5-exercise-implement-generic-anonymous-types.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.exercise-implement-generic-anonymous-types
+title: Exercise - Implement generic and anonymous types
+metadata:
+  title: Exercise - Implement generic and anonymous types
+  description: "Practice creating generics, advanced generics, and anonymous types in C# to write flexible, reusable, and efficient code."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 25
+content: |
+  [!include[](includes/5-exercise-implement-generic-anonymous-types.md)]

learn-pr/wwl-azure/get-started-generic-anonymous-types/6-knowledge-check.yml

@@ -0,0 +1,49 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.knowledge-check
+title: Knowledge check
+metadata:
+  title: Knowledge check
+  description: "Check what you've learned in this module."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 3
+content: |
+  [!include[](includes/6-knowledge-check.md)]
+quiz:
+  title: "Check your knowledge"
+  questions:
+  - content: "What is the primary purpose of generics in programming?"
+    choices:
+    - content: "To allow code to handle multiple data types while ensuring type safety."
+      isCorrect: true
+      explanation: "Correct. Generics enables developers to write reusable code that works with different data types, ensuring type safety by catching errors at compile time."
+    - content: "To improve runtime performance by optimizing memory usage."
+      isCorrect: false
+      explanation: "Incorrect. While generics can enhance performance by avoiding unnecessary type conversions, their primary purpose is to ensure type safety and code reusability."
+    - content: "To simplify debugging by automatically generating error messages."
+      isCorrect: false
+      explanation: "Incorrect. Generics doesn't generate error messages for debugging; they ensure type safety during compilation, reducing runtime errors."
+  - content: "Which of the following is an example of a generic class?"
+    choices:
+    - content: "`public class Box<T> { public T Item { get; set; } }`"
+      isCorrect: true
+      explanation: "Correct. This is a generic class where 'T' acts as a placeholder for the type, allowing the class to work with any data type."
+    - content: "`public class Box { public int Item { get; set; } }`"
+      isCorrect: false
+      explanation: "Incorrect. This is a non-generic class because it's explicitly defined to work only with integers."
+    - content: "`public class Box { public void AddItem(string item) { } }`"
+      isCorrect: false
+      explanation: "Incorrect. This is a non-generic class because it's designed to work only with strings, not multiple data types."
+  - content: "Which of the following scenarios is a common use case for anonymous types in C#?"
+    choices:
+    - content: "Projecting selected properties in a Language-Integrated Query (LINQ)."
+      isCorrect: true
+      explanation: "Correct. Anonymous types are commonly used in LINQ queries to project results into objects with only the required properties."
+    - content: "Defining a reusable class for multiple methods."
+      isCorrect: false
+      explanation: "Incorrect. Anonymous types aren't reusable and are intended for temporary use within a single method."
+    - content: "Creating mutable objects for data manipulation."
+      isCorrect: false
+      explanation: "Incorrect. Anonymous types are immutable, meaning their properties are read-only and can't be modified after creation."

learn-pr/wwl-azure/get-started-generic-anonymous-types/7-summary.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.get-started-generic-anonymous-types.summary
+title: Summary
+metadata:
+  title: Summary
+  description: "Summarize the key concepts covered in this module."
+  ms.date: 04/01/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/7-summary.md)]

learn-pr/wwl-azure/get-started-generic-anonymous-types/includes/1-introduction.md

@@ -0,0 +1,17 @@
+Generics, advanced generics, and anonymous types in C# are powerful tools that help developers write flexible, reusable, and efficient code. Using generics enables improved performance while maintaining type safety.
+
+Imagine you're managing a warehouse with various types of boxes. Each box contains different items, such as electronics, clothing, or fragile goods. To ensure everything is organized and handled efficiently, you need a system that can manage these diverse items safely and flexibly. You also want to sort and compare items across different categories without duplicating effort. Additionally, for quick summaries or reports, you need a way to group key details temporarily without creating detailed records for each item. By learning generics, advanced generics, and anonymous types in C#, you can create a system that is adaptable, efficient, and easy to maintain.
+
+## Learning objectives
+
+- Implement generic classes and methods to handle various data types efficiently.
+- Utilize advanced generics features like generic interfaces, covariance, contravariance, and generic math to address complex scenarios.
+- Apply anonymous types to create temporary, lightweight data structures for short-term use.
+- Explore use cases for anonymous types and tuples.
+
+## Prerequisites
+
+- Visual Studio Code installed with the C# Dev Kit.
+- Basic knowledge of the Visual Studio Code IDE.
+- Basic understanding of the C# programming language.
+- Familiar with classes, abstract classes, interfaces and inheritance.

learn-pr/wwl-azure/get-started-generic-anonymous-types/includes/2-examine-generics.md

@@ -0,0 +1,83 @@
+Imagine you have a box that can hold different items, like toys, books, or clothes. Instead of creating separate boxes for each type of item, you can use a single box with a label that specifies what it contains. Similar to how generics work in programming, they allow you to create a single class or method that can handle different types of data.
+
+## Understand generics
+
+Developers are enabled to define classes, methods, and interfaces with placeholders for data types by using generics. This placeholder behavior improves code reusability, ensures type safety by catching errors at compile time, and enhances performance by avoiding unnecessary type conversions.
+
+- **Code reusability**: You can use the same code for different data types.
+
+- **Type safety**: Errors related to incorrect data types are caught during compilation.
+
+- **Performance**: Generics avoids unnecessary type conversions, making your code faster.
+
+> [!NOTE]  
+> Generics provides benefit when working with collections, such as lists or dictionaries, where the type of data stored can vary.
+
+## How generics allow defining classes, methods, and interfaces with placeholders
+
+Generics introduces type parameters, which act as placeholders for data types. For example, instead of creating a class that works only with integers, you can create a generic class that works with any type.
+
+Here’s an example of a generic class:
+
+```csharp
+public class Box<T>
+{
+    public T Item { get; set; }
+
+    public void AddItem(T item)
+    {
+        Item = item;
+    }
+}
+```
+
+In this example:
+
+- `T` is the type parameter.
+
+- You can create instances of `Box<T>` for different types, like `Box<int>` or `Box<string>`.
+
+When you use generics, the compiler replaces the type parameter with the actual type during compilation, ensuring type safety and avoiding runtime errors.
+
+> [!TIP]  
+> Think of `T` as a "placeholder" for the type you want to use. It makes your code flexible and reusable.
+
+## Create generic classes and methods
+
+Generic classes and methods are commonly used with collections, such as `List<T>` and `Dictionary<TKey, TValue>`. These collections provide type-safe ways to store and manipulate data.
+
+Using a generic list example:
+
+```csharp
+List<int> numbers = new List<int>();
+numbers.Add(1);
+numbers.Add(2);
+numbers.Add(3);
+
+foreach (int number in numbers)
+{
+    Console.WriteLine(number);
+}
+```
+
+The generic list code demonstrates how to use a generic `List<int>` to store integers and iterate through them to print each number.
+
+Creating a generic method example:
+
+```csharp
+public T GetFirstItem<T>(List<T> items)
+{
+    return items[0];
+}
+
+List<string> names = new List<string> {"Hannah", "Mario"};
+string firstName = GetFirstItem(names);
+Console.WriteLine(firstName);
+```
+
+This generic method retrieves the first item from a list of any type. For example, it gets the first name from a list of strings.
+
+> [!TIP]  
+> Use generics when you need to write reusable code that works with multiple data types while ensuring type safety.
+
+Generics let you write flexible and reusable code using type parameters like `<T>`. They ensure type safety and simplify working with collections such as `List<T>` and `Dictionary<TKey, TValue>`. By learning generics, you can create adaptable and efficient code while avoiding common mistakes like forgetting to specify a type or using incompatible types.

learn-pr/wwl-azure/get-started-generic-anonymous-types/includes/3-explore-advanced-generics-concepts.md

@@ -0,0 +1,127 @@
+Imagine you have a warehouse with boxes that can hold different types of items. Some items, like fragile goods or oversized packages, need special handling. To manage the special case, you create rules to ensure everything is packed and processed efficiently.
+
+Advanced generics in C# work similarly. Features like generic interfaces, covariance and contravariance, and generic math let you define flexible rules, ensure compatibility, and perform operations across data types, making your code reusable and efficient.
+
+## Purpose and value of advanced generics
+
+Advanced use of generics builds on the foundation of generics by introducing features that handle complex scenarios while maintaining type safety and efficiency.
+
+- **Generic Interfaces**: Define type-safe contracts for implementing classes.
+
+- **Covariance and Contravariance**: Enable flexible type assignments in method signatures and delegates.
+
+- **Generic Math**: Perform mathematical operations generically across numeric types.
+
+> [!TIP]  
+> Use advanced generics to simplify complex scenarios while keeping your code reusable and type-safe.
+
+## Generic interfaces
+
+Generic interfaces are a key feature of advanced generics, allowing you to define type-safe contracts for implementing classes. They're especially useful when you want to enforce consistent behavior across different types while maintaining flexibility.
+
+For example, the `IComparable<T>` interface allows objects to be compared by type:
+
+```csharp
+public class Product : IComparable<Product>
+{
+    public string Name { get; set; }
+    public decimal Price { get; set; }
+
+    public int CompareTo(Product other)
+    {
+        return Price.CompareTo(other.Price);
+    }
+}
+```
+
+In this example:
+
+- The `Product` class implements the `IComparable<Product>` interface.
+- The `CompareTo` method ensures that products can be compared based on their price.
+
+Some commonly used generic interfaces in .NET include:
+
+- **`IEnumerable<T>`**: Represents a collection of objects that can be enumerated.
+
+- **`IComparer<T>`**: Defines a custom comparison for sorting objects.
+
+- **`IEqualityComparer<T>`**: Defines custom equality logic for comparing objects.
+
+Here’s an example of using `IComparer<T>` to sort a list of products:
+
+```csharp
+public class ProductComparer : IComparer<Product>
+{
+    public int Compare(Product x, Product y)
+    {
+        return x.Price.CompareTo(y.Price);
+    }
+}
+
+var products = new List<Product>
+{
+    new Product { Name = "Laptop", Price = 1200 },
+    new Product { Name = "Tablet", Price = 600 }
+};
+
+products.Sort(new ProductComparer());
+```
+
+- The `ProductComparer` class implements `IComparer<Product>` to sort products by price.
+- The `Sort` method uses the comparer to order the products.
+
+> [!TIP]  
+> Use generic interfaces to enforce type-safe behavior across different types while keeping your code flexible and reusable.
+
+By using generic interfaces, you can enforce consistent behavior across different types while keeping your code flexible and reusable.
+
+## Covariance and Contravariance
+
+Covariance and contravariance allow flexibility when working with generic types, especially when assigning one type to another. They help ensure compatibility between related types in certain scenarios.
+
+- **Covariance**: Allows you to assign a more specific type (derived type) to a more general type (base type).  
+  Think of it like storing a collection of apples (`IEnumerable<Apple>`) in a basket that can hold any fruit (`IEnumerable<Fruit>`).
+
+- **Contravariance**: Allows you to assign a more general type (base type) to a more specific type (derived type).  
+  Think of it like using a handler for any fruit (`Action<Fruit>`) to process only apples (`Action<Apple>`).
+
+Covariance allows you to assign a more specific type to a more general type. For example:
+
+```csharp
+IEnumerable<string> strings = new List<string>();
+IEnumerable<object> objects = strings; // Covariance: string is a more specific type than object
+```
+
+Contravariance allows you to assign a more general type to a more specific type. For example:
+
+```csharp
+Action<object> handleObject = obj => Console.WriteLine(obj);
+Action<string> handleString = handleObject; // Contravariance: object is a more general type than string
+```
+
+> [!TIP]  
+> Covariance is useful when reading data, such as, iterating through a collection. Contravariance is useful when writing or processing data, such as passing parameters to a method.
+
+## Generic math and methods
+
+.NET 7 introduces generic math interfaces, enabling mathematical operations across numeric types.
+
+The following example demonstrates a generic addition method:
+
+```csharp
+static T Add<T>(T left, T right) where T : INumber<T>
+{
+    return left + right;
+}
+
+int result = Add(5, 10); // Works with integers
+double resultDouble = Add(5.5, 10.2); // Works with doubles
+```
+
+- Generic math reduces redundant overloads and supports a wide range of numeric types.
+- It simplifies mathematical operations by allowing you to write reusable methods for numeric types.
+
+> [!TIP]  
+> Use generic math to write reusable methods for numeric operations, reducing the need for multiple overloads.
+
+Advanced generics in C# build on the foundation of generics to handle more complex scenarios. Features like generic interfaces, covariance and contravariance, and generic math allow you to write flexible, reusable, and type-safe code. By learning these tools, you can simplify complex logic and create more adaptable applications.