🎯 C# Collections & Lists Project

Lesson Snapshot

Build a video game inventory system that stores, searches, and sorts items like a pro! (Ages 8-18)

Folder & File Map

CSharp-Lesson-Seven/
├── .git/
├── .gitignore
└── collections/
    ├── collections.csproj
    ├── GameItem.cs   ← you will create this in Step 4
    └── Program.cs

How to use the code snippets

Starting at Step 4, this lesson uses two C# files: GameItem.cs holds the class, and Program.cs holds the Main method that uses it. Each step header tells you which file(s) to change — and from Step 5 onward, only Program.cs changes while GameItem.cs stays exactly the same.

When a step says "replace Program.cs with this" (or GameItem.cs), click inside that file, select all (Ctrl+A / Cmd+A), delete it, then paste the new code. Keeping the class in its own file means you will never accidentally end up with two Main methods or leftover starter code mixed in with your class.

How to create a new C# file in Rider 🛠️

You only need to do this once, in Step 4, to make GameItem.cs:

1. In the Solution Explorer on the left, right-click the collections project (the one with the little C# icon, not the outer folder).
2. Choose Add → Class…
3. Type GameItem for the name and press Enter.
4. Rider creates GameItem.cs with an empty class. Select all (Ctrl+A / Cmd+A), delete it, then paste the Step 4 snippet below.

Step-by-Step Build Guide

1. Fork and Clone the Repository ✅

• What to do: Go to https://github.com/PhillyCoderDojo/CSharp-Lesson-Seven → Click "Fork" → Open GitHub Desktop → Clone your fork
• File(s) touched: Creating project folder
• Code snippet: None
• Why it matters: Get your workspace for managing collections
• Git command: git clone https://github.com/YOUR-USERNAME/CSharp-Lesson-Seven.git

2. Open Project in Rider ✅

• What to do: Open Rider → File → Open → Select your cloned folder → Click OK. The project lives in the collections/ subfolder.
• File(s) touched: Loading project
• Code snippet: None
• Why it matters: Ready to master Lists and collections!
• Git command: None

3. Create Your First List 📝

• What to do: Replace Program.cs with the code below. It builds a simple shopping list using List<string> and prints it. (No new files yet — that comes in Step 4.)
• File(s) touched: Program.cs
• Code snippet for Program.cs (full file):

namespace collections;

class Program
{
    static void Main(string[] args)
    {
        List<string> shoppingList = new List<string>();

        shoppingList.Add("Apples");
        shoppingList.Add("Bread");
        shoppingList.Add("Milk");

        Console.WriteLine("Shopping List:");
        foreach (string item in shoppingList)
        {
            Console.WriteLine($"• {item}");
        }

        Console.WriteLine($"Total items: {shoppingList.Count}");
    }
}

• Why it matters: Lists store multiple items that can grow/shrink
• Git command: git add . && git commit -m "Create first List with basic operations"

4. Build a GameItem Class in Its Own File 🎮

• What to do: First, create a brand-new file called GameItem.cs using the "How to create a new C# file in Rider" steps above. Paste the GameItem.cs snippet below into it. Then replace Program.cs with the snippet that creates one GameItem and prints it to confirm everything compiles.
• File(s) touched: GameItem.cs (new), Program.cs
• Code snippet for GameItem.cs (full file):

namespace collections;

class GameItem
{
    public string Name { get; set; }
    public int Value { get; set; }
    public string Type { get; set; }

    public GameItem(string name, int value, string type)
    {
        Name = name;
        Value = value;
        Type = type;
    }

    public override string ToString()
    {
        return $"{Name} ({Type}) - ${Value}";
    }
}

• Code snippet for Program.cs (full file):

namespace collections;

class Program
{
    static void Main(string[] args)
    {
        GameItem sword = new GameItem("Magic Sword", 150, "Weapon");
        Console.WriteLine(sword);
    }
}

• Why it matters: Lists can hold custom objects, not just strings — and one class per file is how real C# projects are organized.
• Git command: git add . && git commit -m "Create GameItem class in its own file"

5. Create Game Inventory with Objects 🎒

• What to do: Replace Program.cs with the version below. Main now creates a List<GameItem> inventory, prints every item, adds a new one, then removes the Health Potion. GameItem.cs does not change in this step.
• File(s) touched: Program.cs
• Code snippet for Program.cs (full file):

namespace collections;

class Program
{
    static void Main(string[] args)
    {
        List<GameItem> inventory = new List<GameItem>
        {
            new GameItem("Magic Sword", 150, "Weapon"),
            new GameItem("Health Potion", 25, "Consumable"),
            new GameItem("Steel Shield", 75, "Armor"),
            new GameItem("Fire Spell", 100, "Magic")
        };

        Console.WriteLine("=== Player Inventory ===");
        foreach (GameItem item in inventory)
        {
            Console.WriteLine(item);
        }

        inventory.Add(new GameItem("Dragon Scale", 200, "Material"));
        Console.WriteLine($"\nFound Dragon Scale! Inventory now has {inventory.Count} items.");

        inventory.RemoveAt(1); // Remove Health Potion
        Console.WriteLine("Used Health Potion!");
    }
}

• Why it matters: Real programs manage collections of objects
• Git command: git add . && git commit -m "Create game inventory with object list"

6. Add Search and Filter with LINQ 🔍

• What to do: Replace Program.cs with the version below. After the inventory is built, Main uses LINQ (Where, OrderByDescending) to find expensive items, list all weapons, and sort by value. GameItem.cs still does not change.
• File(s) touched: Program.cs
• Code snippet for Program.cs (full file):

using System.Linq;

namespace collections;

class Program
{
    static void Main(string[] args)
    {
        List<GameItem> inventory = new List<GameItem>
        {
            new GameItem("Magic Sword", 150, "Weapon"),
            new GameItem("Health Potion", 25, "Consumable"),
            new GameItem("Steel Shield", 75, "Armor"),
            new GameItem("Fire Spell", 100, "Magic")
        };

        Console.WriteLine("=== Player Inventory ===");
        foreach (GameItem item in inventory)
        {
            Console.WriteLine(item);
        }

        inventory.Add(new GameItem("Dragon Scale", 200, "Material"));
        Console.WriteLine($"\nFound Dragon Scale! Inventory now has {inventory.Count} items.");

        inventory.RemoveAt(1); // Remove Health Potion
        Console.WriteLine("Used Health Potion!");

        Console.WriteLine("\n=== Expensive Items (Value > $100) ===");
        var expensiveItems = inventory.Where(item => item.Value > 100);
        foreach (var item in expensiveItems)
        {
            Console.WriteLine(item);
        }

        Console.WriteLine("\n=== All Weapons ===");
        var weapons = inventory.Where(item => item.Type == "Weapon");
        foreach (var weapon in weapons)
        {
            Console.WriteLine(weapon);
        }

        Console.WriteLine("\n=== Items Sorted by Value (High to Low) ===");
        var sortedItems = inventory.OrderByDescending(item => item.Value);
        foreach (var item in sortedItems)
        {
            Console.WriteLine(item);
        }
    }
}

• Why it matters: LINQ makes searching and sorting super easy
• Git command: git add . && git commit -m "Add LINQ search and sorting features"

7. Build Interactive Inventory Manager 🎯

• What to do: Replace Program.cs with the version below. It puts everything together: a while loop with a menu, three helper methods, and LINQ for the searches. GameItem.cs still does not change.
• File(s) touched: Program.cs
• Code snippet for Program.cs (full file):

using System.Linq;

namespace collections;

class Program
{
    static void Main(string[] args)
    {
        List<GameItem> inventory = new List<GameItem>
        {
            new GameItem("Magic Sword", 150, "Weapon"),
            new GameItem("Health Potion", 25, "Consumable"),
            new GameItem("Steel Shield", 75, "Armor"),
            new GameItem("Fire Spell", 100, "Magic"),
            new GameItem("Iron Dagger", 50, "Weapon")
        };

        while (true)
        {
            Console.WriteLine("\n=== Inventory Manager ===");
            Console.WriteLine("1. Show All Items  2. Search by Type  3. Expensive Items  4. Quit");
            Console.Write("Choose option: ");

            string choice = Console.ReadLine();

            if (choice == "1")
            {
                ShowAllItems(inventory);
            }
            else if (choice == "2")
            {
                SearchByType(inventory);
            }
            else if (choice == "3")
            {
                ShowExpensiveItems(inventory);
            }
            else if (choice == "4")
            {
                break;
            }
        }
    }

    static void ShowAllItems(List<GameItem> items)
    {
        Console.WriteLine("\n=== All Items ===");
        foreach (var item in items.OrderBy(i => i.Name))
        {
            Console.WriteLine(item);
        }
        Console.WriteLine($"Total value: ${items.Sum(i => i.Value)}");
    }

    static void SearchByType(List<GameItem> items)
    {
        Console.Write("Enter item type (Weapon/Armor/Magic/Consumable): ");
        string type = Console.ReadLine();

        var filtered = items.Where(i => i.Type.Equals(type, StringComparison.OrdinalIgnoreCase));

        Console.WriteLine($"\n=== {type} Items ===");
        foreach (var item in filtered)
        {
            Console.WriteLine(item);
        }
    }

    static void ShowExpensiveItems(List<GameItem> items)
    {
        var expensive = items.Where(i => i.Value >= 100).OrderByDescending(i => i.Value);

        Console.WriteLine("\n=== Expensive Items ($100+) ===");
        foreach (var item in expensive)
        {
            Console.WriteLine(item);
        }
    }
}

• Why it matters: Combine lists, LINQ, and methods for complete programs
• Git command: git add . && git commit -m "Create interactive inventory manager"

8. Push Your Collection-Powered Code 🚀

• What to do: In GitHub Desktop → Commit changes → Push origin
• File(s) touched: Uploading to GitHub
• Code snippet: None
• Why it matters: Share your powerful collection management system
• Git command: git push origin main

Run & Test ▶️

• Press Ctrl+F5 or click green ▶️ button in Rider
• Expected output after Step 7: a menu loop. Press 1 to list all items alphabetically with the total value, 2 then type a type like Weapon to filter, 3 for items worth $100+, 4 to quit.

Common errors and fixes

• "The name 'GameItem' does not exist in the current context" — Program.cs cannot see your class. Check that GameItem.cs is in the same project folder as Program.cs (you should see it listed in the Solution Explorer under the collections project) and that both files start with namespace collections;.
• "Type 'Program' already defines a member called 'Main'" — You pasted the Program.cs snippet on top of itself instead of replacing the file's contents. Select all (Ctrl+A / Cmd+A) inside Program.cs, delete everything, then paste once. There should be exactly one static void Main(string[] args) in Program.cs and zero in GameItem.cs.
• "The entry point of the program is global code; ignoring 'Main(string[])' entry point" — A stray line of code is sitting outside any class — often a leftover Console.WriteLine("Hello, World!"); from the starter Program.cs. Make sure every line in Program.cs is inside either class Program { ... } or static void Main(string[] args) { ... }.
• "The name 'Where' (or 'OrderBy', 'OrderByDescending', 'Sum') does not exist" — Missing using System.Linq; at the top of Program.cs. Add it as the very first line.
• "GameItem does not contain a constructor that takes 0 arguments" — You wrote new GameItem() instead of new GameItem(name, value, type). The GameItem constructor needs all three values.

Bonus Challenge 🔥

Create a PlayerStats tracker with a List of achievements — and put it in its own new file called PlayerStats.cs (use the same "Add → Class…" trick from Step 4).

Hint (paste into PlayerStats.cs):

namespace collections;

class PlayerStats
{
    public string PlayerName { get; set; }
    public List<string> Achievements { get; set; }
    public Dictionary<string, int> Stats { get; set; }

    public PlayerStats(string name)
    {
        PlayerName = name;
        Achievements = new List<string>();
        Stats = new Dictionary<string, int>
        {
            {"Level", 1},
            {"Experience", 0},
            {"Gold", 100}
        };
    }

    public void AddAchievement(string achievement)
    {
        if (!Achievements.Contains(achievement))
        {
            Achievements.Add(achievement);
            Console.WriteLine($"🏆 Achievement unlocked: {achievement}");
        }
    }
}