Arrays and Collections

// ===== DECLARING ARRAYS =====

// Method 1: Create with size (all elements are default values)
int[] numbers = new int[5];  // 5 slots: [0, 0, 0, 0, 0]

// Method 2: Create and initialize with values
string[] names = { "Alice", "Bob", "Charlie" };  // Size is 3

// Method 3: Create with size and assign values
int[] scores = new int[3] { 95, 88, 76 };

// ===== ACCESSING ARRAY ELEMENTS =====
string[] fruits = { "Apple", "Banana", "Orange" };

string first = fruits[0];  // "Apple" (first element - index 0)
string second = fruits[1]; // "Banana" (second element - index 1)
string last = fruits[2];   // "Orange" (third element - index 2)

// Change a value
fruits[1] = "Grape";  // Now: ["Apple", "Grape", "Orange"]

// ===== ARRAY PROPERTIES =====
int length = fruits.Length;  // Gets the number of elements (3)

// ===== LOOPING THROUGH AN ARRAY =====
// Using for loop (with index)
for (int i = 0; i < fruits.Length; i++)
{
    Console.WriteLine($"Index {i}: {fruits[i]}");
}

// Using foreach (cleaner, no index)
foreach (string fruit in fruits)
{
    Console.WriteLine($"Fruit: {fruit}");
}

// ===== MULTIDIMENSIONAL ARRAYS =====
// 2D array (like a grid or table)
int[,] grid = new int[2, 3];  // 2 rows, 3 columns
grid[0, 0] = 1;
grid[0, 1] = 2;
grid[0, 2] = 3;
grid[1, 0] = 4;
grid[1, 1] = 5;
grid[1, 2] = 6;
// grid = [[1,2,3], [4,5,6]]

// Initialize 2D array with values
int[,] grid2 = { { 1, 2 }, { 3, 4 } };

// ===== CREATING A LIST =====
using System.Collections.Generic;  // Required for List

// Empty list (most common)
List<string> names = new List<string>();

// With initial items
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

// Using var (shortcut)
var students = new List<Student>();  // List of Student objects

// ===== ADDING ITEMS =====
names.Add("Alice");     // Adds at the end
names.Add("Bob");
names.Add("Charlie");

// Add multiple items at once
var moreNames = new List<string> { "Dave", "Eve" };
names.AddRange(moreNames);  // Adds all items from another list

// ===== INSERTING ITEMS (IN THE MIDDLE) =====
names.Insert(1, "Zara");  // Inserts "Zara" at index 1
// Before: ["Alice", "Bob", "Charlie"]
// After:  ["Alice", "Zara", "Bob", "Charlie"]

// ===== ACCESSING ITEMS =====
string first = names[0];  // "Alice"
string last = names[names.Count - 1];  // "Charlie"

// ===== REMOVING ITEMS =====
names.Remove("Bob");       // Removes "Bob" by value
names.RemoveAt(0);      // Removes the first item (index 0)
names.RemoveAll(n => n.StartsWith("A"));  // Removes all items starting with "A"
names.Clear();           // Removes ALL items

// ===== LIST PROPERTIES =====
int count = names.Count;   // Number of items
bool isEmpty = names.Count == 0;
int capacity = names.Capacity;  // Internal size (usually bigger than Count)
// ===== CHECKING IF AN ITEM EXISTS =====
bool hasAlice = names.Contains("Alice");  // true or false

// ===== FINDING ITEMS =====
int index = names.IndexOf("Alice");  // Returns index or -1 if not found
string found = names.Find(n => n.StartsWith("A"));  // Returns first match
List<string> allFound = names.FindAll(n => n.Length > 3);

// ===== SORTING =====
names.Sort();  // Sorts alphabetically (A to Z)
names.Reverse();  // Reverses the order

// ===== LOOPING THROUGH A LIST =====
// Using foreach (cleanest - most common)
foreach (string name in names)
{
    Console.WriteLine($"Hello, {name}");
}

// Using for loop (when you need the index)
for (int i = 0; i < names.Count; i++)
{
    Console.WriteLine($"Index {i}: {names[i]}");
}

// ===== CONVERTING =====
string[] nameArray = names.ToArray();  // Convert to array
List<string> newList = nameArray.ToList();  // Convert array to list

// ===== CREATING A DICTIONARY =====
using System.Collections.Generic;  // Required

// Empty dictionary
Dictionary<string, int> ages = new Dictionary<string, int>();

// With initial values
Dictionary<string, string> countries = new Dictionary<string, string>
{
    { "USA", "Washington D.C." },
    { "Canada", "Ottawa" },
    { "UK", "London" }
};

// Using var
var productPrices = new Dictionary<int, decimal>();

// ===== ADDING ITEMS =====
// Method 1: Using indexer (adds or updates)
ages["Alice"] = 25;
ages["Bob"] = 30;

// Method 2: Using Add() (throws error if key exists)
ages.Add("Charlie", 35);

// Method 3: TryAdd (safe - returns true/false)
if (ages.TryAdd("Dave", 28))
{
    Console.WriteLine("Dave added successfully");
}
else
{
    Console.WriteLine("Dave already exists");
}

// ===== ACCESSING VALUES =====
int aliceAge = ages["Alice"];  // 25 (throws error if key doesn't exist)

// ===== SAFE ACCESS (Best Practices) =====

// Method 1: Check if key exists first
if (ages.ContainsKey("Bob"))
{
    Console.WriteLine($"Bob is {ages["Bob"]} years old");
}

// Method 2: TryGetValue (BEST - one lookup, no error)
if (ages.TryGetValue("Unknown", out int age))
{
    Console.WriteLine($"Age: {age}");
}
else
{
    Console.WriteLine("Key not found");
}

// Method 3: GetValueOrDefault (C# 8+)
int unknownAge = ages.GetValueOrDefault("Unknown", 0);  // Returns 0 if not found

// ===== UPDATING VALUES =====
ages["Alice"] = 26;  // Updates Alice's age to 26

// ===== REMOVING ITEMS =====
bool removed = ages.Remove("Bob");  // Removes Bob, returns true if found
ages.Clear();  // Removes ALL items

// ===== DICTIONARY PROPERTIES =====
int count = ages.Count;  // Number of key-value pairs
List<string> allKeys = new List<string>(ages.Keys);  // Get all keys
List<int> allValues = new List<int>(ages.Values);  // Get all values
bool hasKeys = ages.Keys.Any();  // Check if there are any keys

// ===== LOOPING THROUGH A DICTIONARY =====
// Using foreach with KeyValuePair
foreach (KeyValuePair<string, int> item in ages)
{
    Console.WriteLine($"{item.Key} is {item.Value} years old");
}

// Loop through keys only
foreach (string key in ages.Keys)
{
    Console.WriteLine($"Key: {key}");
}

// Loop through values only
foreach (int value in ages.Values)
{
    Console.WriteLine($"Value: {value}");
}

// ===== CREATING A HASHSET =====
HashSet<string> uniqueNames = new HashSet<string>();

// With initial items (duplicates automatically removed)
var tags = new HashSet<string> { "C#", "Java", "Python", "C#" };
// tags = ["C#", "Java", "Python"]  (C# only appears once)

// ===== ADDING ITEMS =====
uniqueNames.Add("Alice");  // true (added)
uniqueNames.Add("Bob");    // true (added)
uniqueNames.Add("Alice");  // false (ignored - already exists)

// ===== CHECKING IF AN ITEM EXISTS =====
bool hasAlice = uniqueNames.Contains("Alice");  // true
bool hasDave = uniqueNames.Contains("Dave");    // false

// ===== REMOVING ITEMS =====
bool removed = uniqueNames.Remove("Bob");  // true
uniqueNames.Clear();  // Removes all items

// ===== HASHSET PROPERTIES =====
int count = uniqueNames.Count;  // Number of unique items

// ===== SET OPERATIONS =====
var setA = new HashSet<int> { 1, 2, 3, 4 };
var setB = new HashSet<int> { 3, 4, 5, 6 };

// Union - combines both sets (no duplicates)
var union = new HashSet<int>(setA);
union.UnionWith(setB);  // {1,2,3,4,5,6}

// Intersection - items in both sets
var intersection = new HashSet<int>(setA);
intersection.IntersectWith(setB);  // {3,4}

// Difference - items in setA but not in setB
var difference = new HashSet<int>(setA);
difference.ExceptWith(setB);  // {1,2}

// ===== LOOPING THROUGH A HASHSET =====
foreach (string name in uniqueNames)
{
    Console.WriteLine(name);
}

// ===== REMOVING DUPLICATES FROM A LIST =====
var listWithDuplicates = new List<int> { 1, 2, 2, 3, 3, 4 };
var uniqueNumbers = new HashSet<int>(listWithDuplicates);
// uniqueNumbers = {1,2,3,4}

// ===== CREATING A QUEUE =====
Queue<string> queue = new Queue<string>();

// With initial items
var tasks = new Queue<string>(new string[] { "Task 1", "Task 2", "Task 3" });

// ===== ADDING ITEMS (Enqueue) =====
queue.Enqueue("First");   // Adds to the back
queue.Enqueue("Second");  // Adds to the back
queue.Enqueue("Third");   // Adds to the back
// queue = ["First", "Second", "Third"]

// ===== REMOVING ITEMS (Dequeue) =====
string firstItem = queue.Dequeue();  // "First" (removes from front)
string nextItem = queue.Dequeue();   // "Second"
// queue now has: ["Third"]

// ===== LOOKING AT ITEMS WITHOUT REMOVING =====
string front = queue.Peek();  // "Third" (doesn't remove)

// ===== QUEUE PROPERTIES =====
int count = queue.Count;  // Number of items
bool isEmpty = queue.Count == 0;

// ===== CHECKING IF AN ITEM EXISTS =====
bool hasFirst = queue.Contains("First");  // true or false

// ===== CLEARING =====
queue.Clear();  // Removes all items

// ===== LOOPING THROUGH A QUEUE =====
// Using foreach (doesn't remove items)
foreach (string item in queue)
{
    Console.WriteLine($"Processing: {item}");
}

// Process all items (removes them)
while (queue.Count > 0)
{
    string item = queue.Dequeue();
    Console.WriteLine($"Processing and removing: {item}");
}

// ===== CREATING A STACK =====
Stack<string> stack = new Stack<string>();

// With initial items
var history = new Stack<string>(new string[] { "Page 1", "Page 2" });

// ===== ADDING ITEMS (Push) =====
stack.Push("First");   // Adds to the top
stack.Push("Second");  // Adds to the top
stack.Push("Third");   // Adds to the top
// stack = ["First", "Second", "Third"] (Third is on top)

// ===== REMOVING ITEMS (Pop) =====
string lastItem = stack.Pop();  // "Third" (removes from top)
string previous = stack.Pop();  // "Second"
// stack now has: ["First"]

// ===== LOOKING AT ITEMS WITHOUT REMOVING =====
string top = stack.Peek();  // "First" (doesn't remove)

// ===== STACK PROPERTIES =====
int count = stack.Count;  // Number of items
bool isEmpty = stack.Count == 0;

// ===== CHECKING IF AN ITEM EXISTS =====
bool hasFirst = stack.Contains("First");  // true or false

// ===== CLEARING =====
stack.Clear();  // Removes all items

// ===== LOOPING THROUGH A STACK =====
// Using foreach (doesn't remove items)
foreach (string item in stack)
{
    Console.WriteLine($"Item: {item}");
}

// Process all items (removes them)
while (stack.Count > 0)
{
    string item = stack.Pop();
    Console.WriteLine($"Processing and removing: {item}");
}

// ===== REAL-WORLD EXAMPLE: Undo System =====
var undoStack = new Stack<string>();

// User performs actions
undoStack.Push("Typed 'Hello'");
undoStack.Push("Typed ' World'");
undoStack.Push("Added emoji");

// User presses Undo (Ctrl+Z)
string lastAction = undoStack.Pop();  // "Added emoji"
Console.WriteLine($"Undo: {lastAction}");

// Undo again
lastAction = undoStack.Pop();  // "Typed ' World'"
Console.WriteLine($"Undo: {lastAction}");