**Course Title:** Mastering C#: From Fundamentals to Advanced Programming **Section Title:** Working with Collections and LINQ **Topic:** Introduction to collections (List, Dictionary, Queue, Stack) ### Introduction In this topic, we will explore the world of collections in C#. Collections are data structures that allow you to store and manage multiple items of the same data type. They are essential in programming, as they provide a way to group and manipulate data efficiently. We will cover four fundamental collection types: List, Dictionary, Queue, and Stack. ### Lists A List in C# is a dynamic collection of objects that can grow or shrink as items are added or removed. It is similar to an array, but it has more features and flexibility. #### Key Features of Lists * Dynamic size: Lists can grow or shrink as needed. * Zero-based indexing: List elements are accessed by their index, starting from 0. * Type-safe: Lists can store a specific data type or a reference type. * Supports many operations: Lists have a wide range of methods for adding, removing, searching, and modifying elements. #### Creating and Using a List Here's an example of creating and using a List: ```csharp using System; using System.Collections.Generic; class Program { static void Main() { // Create a list of integers List<int> numbers = new List<int>(); // Add elements to the list numbers.Add(1); numbers.Add(2); numbers.Add(3); numbers.Add(4); numbers.Add(5); // Access and print elements Console.WriteLine("Numbers:"); for (int i = 0; i < numbers.Count; i++) { Console.WriteLine(numbers[i]); } // Remove an element numbers.Remove(3); // Print the list after removing an element Console.WriteLine("\nNumbers after removing 3:"); for (int i = 0; i < numbers.Count; i++) { Console.WriteLine(numbers[i]); } } } ``` ### Dictionaries A Dictionary in C# is a collection of key-value pairs. It is similar to a map in other languages. Dictionaries are useful for storing and retrieving data by their keys. #### Key Features of Dictionaries * Key-value pairs: Dictionaries store data as key-value pairs. * Unique keys: Dictionary keys must be unique. * Fast lookup: Dictionaries provide fast lookup by key. * Type-safe: Dictionaries can store specific data types or reference types. #### Creating and Using a Dictionary Here's an example of creating and using a Dictionary: ```csharp using System; using System.Collections.Generic; class Program { static void Main() { // Create a dictionary of names and ages Dictionary<string, int> people = new Dictionary<string, int>(); // Add entries to the dictionary people.Add("John", 25); people.Add("Alice", 30); people.Add("Bob", 35); // Access and print values by key Console.WriteLine("Names and ages:"); Console.WriteLine(people["John"]); Console.WriteLine(people["Alice"]); Console.WriteLine(people["Bob"]); // Update an entry people["Bob"] = 36; // Print the updated entry Console.WriteLine("\nBob's updated age:"); Console.WriteLine(people["Bob"]); // Remove an entry people.Remove("Alice"); // Print the remaining entries Console.WriteLine("\nRemaining people:"); foreach (KeyValuePair<string, int> person in people) { Console.WriteLine($"Name: {person.Key}, Age: {person.Value}"); } } } ``` ### Queues A Queue in C# is a First-In-First-Out (FIFO) collection of objects. It follows the principle that the first item added will be the first one removed. #### Key Features of Queues * FIFO: Queues follow the First-In-First-Out principle. * Type-safe: Queues can store specific data types or reference types. #### Creating and Using a Queue Here's an example of creating and using a Queue: ```csharp using System; using System.Collections.Generic; class Program { static void Main() { // Create a queue of integers Queue<int> numbers = new Queue<int>(); // Enqueue elements numbers.Enqueue(1); numbers.Enqueue(2); numbers.Enqueue(3); numbers.Enqueue(4); numbers.Enqueue(5); // Dequeue and print elements Console.WriteLine("Numbers:"); while (numbers.Count > 0) { Console.WriteLine(numbers.Dequeue()); } } } ``` ### Stacks A Stack in C# is a Last-In-First-Out (LIFO) collection of objects. It follows the principle that the last item added will be the first one removed. #### Key Features of Stacks * LIFO: Stacks follow the Last-In-First-Out principle. * Type-safe: Stacks can store specific data types or reference types. #### Creating and Using a Stack Here's an example of creating and using a Stack: ```csharp using System; using System.Collections.Generic; class Program { static void Main() { // Create a stack of integers Stack<int> numbers = new Stack<int>(); // Push elements onto the stack numbers.Push(1); numbers.Push(2); numbers.Push(3); numbers.Push(4); numbers.Push(5); // Pop and print elements Console.WriteLine("Numbers:"); while (numbers.Count > 0) { Console.WriteLine(numbers.Pop()); } } } ``` ### Conclusion In this topic, we covered the basics of collections in C#, including Lists, Dictionaries, Queues, and Stacks. These data structures are essential in programming, as they provide efficient ways to store and manipulate data. ### Key Takeaways * Lists are dynamic collections of objects that can grow or shrink as needed. * Dictionaries are collections of key-value pairs, with unique keys and fast lookup capabilities. * Queues follow the First-In-First-Out principle, with type-safe storage. * Stacks follow the Last-In-First-Out principle, with type-safe storage. ### Practice and Review Now that you have learned the basics of collections in C#, it's time to practice and review. Try creating your own collections, adding and removing elements, and accessing their contents. This will help you solidify your understanding of these essential data structures. Before we move on to the next topic, 'Using LINQ (Language Integrated Query) to query collections,' take a moment to review and practice what you have learned so far. If you have any questions or need further clarification, feel free to ask in the comments section below. Additional resources: * [MSDN: List\<T> Class](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1) * [MSDN: Dictionary\<TKey,TValue> Class](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2) * [MSDN: Queue\<T> Class](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.queue-1) * [MSDN: Stack\<T> Class](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.stack-1)