pull base content,head:MicrosoftDocs:main,into:wwlpublishsync

Author: wwlpublish

learn-pr/wwl-azure/implement-collection-types/1-introduction.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.introduction
+title: Introduction
+metadata:
+  title: Introduction
+  description: "Introduction to the module."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 2
+content: |
+  [!include[](includes/1-introduction.md)]

learn-pr/wwl-azure/implement-collection-types/2-importance-collections.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.importance-collections
+title: Importance of collections
+metadata:
+  title: Importance of collections
+  description: "Learn about the significance of collections in C# for managing groups of objects efficiently."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 5
+content: |
+  [!include[](includes/2-importance-collections.md)]

learn-pr/wwl-azure/implement-collection-types/3-implement-ordered-collections-typed-list.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.implement-ordered-collections-typed-list
+title: Implement ordered collections with List<T>
+metadata:
+  title: Implement ordered collections with List<T>
+  description: "Learn how to use List for managing ordered collections, including adding, removing, and iterating through items."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 6
+content: |
+  [!include[](includes/3-implement-ordered-collections-typed-list.md)]

learn-pr/wwl-azure/implement-collection-types/4-ensure-uniqueness-typed-hashset.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.ensure-uniqueness-typed-hashset
+title: Ensuring uniqueness with HashSet<T>
+metadata:
+  title: Ensuring uniqueness with HashSet<T>
+  description: "Explore how to use HashSet to manage unique collections and prevent duplicate elements."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 6
+content: |
+  [!include[](includes/4-ensure-uniqueness-typed-hashset.md)]

learn-pr/wwl-azure/implement-collection-types/5-organize-data-key-value-pairs-use-typed-dictionary.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.organize-data-key-value-pairs-use-typed-dictionary
+title: Organize data with Dictionary<TKey, TValue>
+metadata:
+  title: Organize data with Dictionary<TKey, TValue>
+  description: "Learn how to use Dictionary for storing and retrieving data using key-value pairs efficiently."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 8
+content: |
+  [!include[](includes/5-organize-data-key-value-pairs-use-typed-dictionary.md)]

learn-pr/wwl-azure/implement-collection-types/6-exercise-implement-collection-types.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.exercise-implement-collection-types
+title: Exercise - Implement collection types
+metadata:
+  title: Exercise - Implement collection types
+  description: "Practice implementing and using collection types like List, Dictionary, and HashSet in a banking application scenario."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 30
+content: |
+  [!include[](includes/6-exercise-implement-collection-types.md)]

learn-pr/wwl-azure/implement-collection-types/7-knowledge-check.yml

@@ -0,0 +1,51 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.knowledge-check
+title: Knowledge check
+metadata:
+  title: Knowledge check
+  description: "Check what you've learned in this module."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 3
+content: |
+  [!include[](includes/7-knowledge-check.md)]
+quiz:
+  title: "Check your knowledge"
+  questions:
+  - content: "What is the primary characteristic of a `HashSet<T>` in C#?"
+    choices:
+    - content: "It allows duplicate elements."
+      isCorrect: false
+      explanation: "Incorrect. `HashSet<T>` doesn't allow duplicate elements, making it ideal for scenarios requiring uniqueness."
+    - content: "It stores elements as key/value pairs."
+      isCorrect: false
+      explanation: "Incorrect. Storing elements as key/value pairs is a characteristic of `Dictionary<TKey, TValue>`, not `HashSet<T>`."
+    - content: "It ensures uniqueness of elements."
+      isCorrect: true
+      explanation: "Correct. `HashSet<T>` is designed to ensure that all elements are unique, which is its primary characteristic."
+  - content: "A banking application needs to store customer IDs with their associated account details for quick retrieval. Which collection should be used?"
+    choices:
+    - content: "`List<Account>`"
+      isCorrect: false
+      explanation: "Incorrect. `List<Account>` is suitable for ordered records but doesn't provide quick look-up by customer ID."
+    - content: "`Dictionary<int, Account>`"
+      isCorrect: true
+      explanation: "Correct. `Dictionary<int, Account>` is ideal for associating customer IDs with account details, enabling efficient look-up by key."
+    - content: "`HashSet<Account>`"
+      isCorrect: false
+      explanation: "Incorrect. `HashSet<Account>` ensures uniqueness but doesn't support key-based look-up, which is required in this scenario."
+  - content: "Which of these collections in C# supports dynamic resizing and access to elements by index?"
+    choices:
+    - content: "`List<T>`"
+      isCorrect: true
+      explanation: "Correct. `List<T>` supports dynamic resizing and allows access to elements by their index, making it versatile for various scenarios."
+    - content: "`Dictionary<TKey, TValue>`"
+      isCorrect: false
+      explanation: "Incorrect. `Dictionary<TKey, TValue>` stores elements as key/value pairs and doesn't provide index-based access."
+    - content: "`HashSet<T>`"
+      isCorrect: false
+      explanation: "Incorrect. `HashSet<T>` is designed for set operations and doesn't support index-based access or dynamic resizing."

learn-pr/wwl-azure/implement-collection-types/8-summary.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.implement-collection-types.summary
+title: Summary
+metadata:
+  title: Summary
+  description: "Summarize the key concepts covered in this module."
+  ms.date: 03/28/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+  ms.custom:
+  - N/A
+durationInMinutes: 2
+content: |
+  [!include[](includes/8-summary.md)]

learn-pr/wwl-azure/implement-collection-types/includes/1-introduction.md

@@ -0,0 +1,17 @@
+C# collections are powerful tools for managing groups of objects dynamically, ensuring type safety and efficient data manipulation for various applications.
+
+Imagine you're working in the banking industry, tasked with developing a system that manages customer accounts and transactions. You need a way to store customer IDs linked to their account details, ensure no duplicate transaction records, and maintain an ordered list of recent activities. Without the right tools, this task could become cumbersome and error-prone. C# collections like `List<T>`, `HashSet<T>`, and `Dictionary<TKey, TValue>` offer solutions tailored to these challenges. For instance, you can use `Dictionary<TKey, TValue>` to map customer IDs to account details for quick lookups, `HashSet<T>` to ensure transaction uniqueness, and `List<T>` to maintain an ordered sequence of activities. These collections streamline data management, making your application robust and efficient.
+
+## Learning objectives
+
+- Apply C# Collections for Efficient Data Management
+- Manage ordered collections using `List<T>` in C#
+- Manage unique collections with `HashSet<T>`
+- Using `Dictionary<TKey, TValue>` for efficient key-value pair management in C#
+
+## 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/implement-collection-types/includes/2-importance-collections.md

@@ -0,0 +1,37 @@
+In C#, collections are essential for managing groups of objects efficiently. They provide a flexible way to store, retrieve, and manipulate data, which is crucial for developers working on various applications, including applications in the banking sector.
+
+## Importance of collections in managing groups of objects
+
+Collections in C# allow developers to handle similar data more efficiently by storing and manipulating it as a group. This capability is vital for applications that require dynamic data handling, such as adding or removing elements. Collections can be classified based on how they access elements, their performance profiles, and their ability to grow or shrink dynamically. For instance, some collections access elements by index, like `List<T>`, while others use keys, like `Dictionary<TKey, TValue>`.
+
+- Collections are strongly typed, meaning they store elements of a specific type (`T`), ensuring type safety and reducing runtime errors.
+- Collections provide methods for adding, removing, or finding items.
+- They support enumeration, allowing iteration over elements using loops.
+- Collections can be copied to arrays, providing flexibility in data manipulation.
+
+> [!NOTE]
+> For examples, you might need to add using directives for the `System.Collections.Generic` and `System.Linq` namespaces.
+
+## Describe List&#60;T&#62;, HashSet&#60;T&#62;, and Dictionary&#60;TKey, TValue&#62;
+
+### **List&#60;T&#62;**
+
+`List<T>` is an indexable collection that allows access to elements by their position. It supports dynamic resizing, making it suitable for scenarios where the number of elements can change.
+
+### **HashSet&#60;T&#62;**
+
+`HashSet<T>` is a collection designed for high-performance set operations. It doesn't allow duplicate elements and is ideal for scenarios where uniqueness is required.
+
+### **Dictionary&#60;TKey, TValue&#62;**
+
+`Dictionary<TKey, TValue>` stores elements as key/value pairs, enabling quick look-up by key. It's useful when you need to associate values with unique keys, such as mapping customer IDs to account details in a banking application.
+
+## Prepare for application of collections in banking scenarios
+
+In banking applications, collections play a crucial role in managing data efficiently. For example, a `Dictionary<int, Account>` can map customer IDs to their respective account details, allowing quick retrieval and updates. Similarly, a `List<Transaction>` can store a sequence of transactions, supporting operations like sorting and filtering using LINQ (Language Integrated Query).
+
+- Use `Dictionary<TKey, TValue>` for quick look-up of customer data.
+- Employ `List<T>` for ordered transaction records.
+- Utilize `HashSet<T>` to ensure unique entries, such as customer IDs.
+
+With collections, developers can build robust and efficient banking applications that handle data dynamically and securely.