Student Management Console App

Build a console app to add, update, search, and delete student records using classes and collections.

ClassesObjectsCollections

Overview

A student management system is the classic first project for seeing why C# bundles data and behavior together in a class instead of scattering related values across separate arrays or variables. A Student is not just an id, a name, a course, and a GPA sitting next to each other in memory — it is one coherent object that should be created, read, and changed as a single unit. That is exactly what a C# class gives you, and C# adds a language feature Java does not have built in: properties. Instead of writing a getName() method and a setName() method by hand, a C# property like public string Name { get; set; } gives you the same controlled access with far less boilerplate.

By the end of this tutorial you will have a console application built around two classes: Student, which models one record using auto-implemented properties, and StudentManager, which owns a List<Student> and provides add, search, update, and delete operations over it. You will also see modern C#'s top-level statements in action — Program.cs does not need an explicit class Program { static void Main(string[] args) { ... } } wrapper the way older C# and Java both require; the compiler generates that entry point for you behind the scenes, so the file can start directly with executable code.

What You'll Build

A Student class with an auto-implemented Id property (settable only from inside the class) plus Name, Course, and Gpa properties.
A StudentManager class that owns a List<Student> and assigns unique ids automatically.
A linear FindById() search reused by the update and delete operations.
An UpdateStudent() method that safely edits an existing record found by id.
A DeleteStudent() method built on List<T>.RemoveAll().
A Console.ReadLine()-based menu loop tying every operation together into one running program.

Prerequisites

Classes and objects — defining a class with properties, a constructor, and methods.
C# properties — the { get; set; } syntax, and how { get; private set; } restricts who can assign a value.
Collections basics — System.Collections.Generic.List<T> and the foreach loop.
Console I/O — reading input with Console.ReadLine() and parsing it with int.Parse()/double.Parse().
Method basics — parameters, return types, and calling one method from another.

Project Structure

The whole program lives in a single file, Program.cs, created with dotnet new console. Unlike Java, C# does not require one public class per file, or that a file's name match any class inside it — so Student, StudentManager, and the top-level statements that drive the menu can all live together in Program.cs with no naming constraints at all. Student is a pure data-and-behavior class — it never touches the console or the collection it lives in. StudentManager is the layer above it: it owns the List<Student>, hands out ids, and exposes one method per menu action (AddStudent, FindById, UpdateStudent, DeleteStudent, GetAll). The top-level statements at the bottom never manipulate the list directly; they only ever call methods on a single shared StudentManager instance, which keeps every rule about how students are created or removed enforced in exactly one place.

In a C# file that uses top-level statements, the executable statements must come first and any class/record type declarations must come after them — that is why the complete program in this tutorial places the menu loop logic at the top of Program.cs and the Student/StudentManager class definitions below it, the reverse order of how the steps below introduce them.

Step 1: Define the Student Class

Every property here is deliberately shaped around what should and should not be changeable from outside the class. Id uses { get; private set; } — readable by anyone, but assignable only from code inside Student itself, which is what stops a caller from ever reassigning a student's id after it is created. Name, Course, and Gpa use the full { get; set; }, since those are exactly the fields StudentManager's update operation is allowed to change later.

// Represents one student record. Auto-implemented properties give each field a
// compiler-generated backing variable — "private set" on Id means code outside
// this class can read Id but can never assign it a new value directly.
class Student
{
    public int Id { get; private set; }        // Assigned once by StudentManager; never chosen or changed by the caller
    public string Name { get; set; }              // Full get/set: this is exactly what StudentManager is allowed to edit
    public string Course { get; set; }
    public double Gpa { get; set; }               // double so partial grades like 8.75 are representable

    public Student(int id, string name, string course, double gpa)
    {
        Id = id;              // A constructor can assign a private-set property from inside its own class
        Name = name;
        Course = course;
        Gpa = gpa;
    }

    public override string ToString()   // "override" is a keyword here, not an annotation like Java's @Override
    {
        // $"..." is string interpolation; "{Name,-20}" left-aligns Name in a 20-character field, similar to
        // C's/Java's printf-style "%-20s" but built directly into the language's string syntax.
        return $"ID: {Id,-4} | Name: {Name,-20} | Course: {Course,-15} | GPA: {Gpa:F2}";
    }
}

Step 2: Build the StudentManager and Add Students

StudentManager is where the collection actually lives. List<T> is .NET's growable array type — the direct equivalent of Java's ArrayList<T> — and it is common in C# to declare a field as List<Student> directly rather than through a separate interface type, since List<T> already implements IList<T>, ICollection<T>, and IEnumerable<T>. _nextId is a simple auto-incrementing counter (the leading underscore is a common C# naming convention for private fields), so StudentManager, not the caller, decides every student's id, guaranteeing no two records can ever collide.

using System.Collections.Generic;   // List<T> — shown explicitly here even though modern project templates often bring it in via global usings

// Owns every Student record in memory and is the only class allowed to
// create, search, update, or remove them — the menu loop never touches the
// List<Student> directly, it only ever calls methods on a StudentManager.
class StudentManager
{
    private List<Student> _students = new List<Student>();   // Grows automatically as students are added; no manual resizing
    private int _nextId = 1;                                    // Next id to hand out; incremented after every successful add

    public Student AddStudent(string name, string course, double gpa)
    {
        var student = new Student(_nextId, name, course, gpa);   // The manager assigns the id, not the caller
        _students.Add(student);                                    // List<T>.Add() appends in amortized O(1) time
        _nextId++;                                                  // Guarantees every future student gets a fresh id
        return student;                                             // Handy for immediately printing "Added: ..."
    }
}

Step 3: List and Search Students

GetAll() exposes the collection for listing, returned as IReadOnlyList<Student> rather than List<Student> — a small but meaningful signal to callers that they may read this collection but should not add to or remove from it directly. FindById() is a plain linear scan using a foreach loop — with a class list realistically holding dozens to a few hundred students, a linear search is more than fast enough. The return type Student? uses C#'s nullable reference type annotation to make it explicit in the method signature itself that "no match found" is a real, expected outcome the caller must handle.

public IReadOnlyList<Student> GetAll()
{
    return _students;   // Safe to expose here since StudentManager is the only class that ever mutates the list
}

public Student? FindById(int id)   // The ? marks this as possibly returning null — every caller must check for that
{
    foreach (var s in _students)     // foreach walks every student in insertion order, same idea as Java's enhanced for
    {
        if (s.Id == id)
        {
            return s;                 // Found a match: return the actual object, not a defensive copy
        }
    }
    return null;                      // No match; every caller below must check for null before using the result
}

Example Usage

Click Run to see what this code prints.

Step 4: Update a Student Record

UpdateStudent() reuses FindById() from Step 3 rather than scanning the list a second time. If no student with that id exists, it returns false immediately and never touches any property — callers use that return value to decide whether to print "updated" or "not found," so StudentManager never needs to print anything itself.

public bool UpdateStudent(int id, string newName, string newCourse, double newGpa)
{
    var student = FindById(id);   // Reuse the lookup already written in Step 3 instead of duplicating it
    if (student is null)
    {
        return false;               // Nothing to update; let the caller report "student not found"
    }
    student.Name = newName;          // Only StudentManager and code holding a direct Student reference can reach these
    student.Course = newCourse;      // properties, which is exactly the encapsulation boundary set up in Step 1
    student.Gpa = newGpa;
    return true;
}

Step 5: Delete a Student

DeleteStudent() uses List<T>.RemoveAll(), which takes a predicate delegate and removes every element that matches it, returning an int count of how many elements were actually removed — unlike Java's ArrayList.removeIf(), which returns a bool. Comparing that count against 0 gives the same true/false signal Java's version returns directly. Since ids are unique, at most one student is ever removed here, but RemoveAll() is still the cleanest way to express "delete the student whose id equals this one" without manually managing a loop index while removing from the list being iterated.

public bool DeleteStudent(int id)
{
    return _students.RemoveAll(s => s.Id == id) > 0;   // Lambda predicate; RemoveAll returns a count, so compare against 0
}

Step 6: Build the Menu Loop

The top-level statements below create one StudentManager shared by every menu action and loop on a numbered menu until the user chooses to exit. Notice there is no equivalent of Java's scanner.nextLine() cleanup call here: Console.ReadLine() always reads and consumes one full line of input, including its trailing newline, so there is no leftover character sitting in a buffer waiting to be accidentally read by the next call — an entire category of bug Java's Scanner requires you to defend against by hand.

var manager = new StudentManager();   // One manager instance shared by every menu action below
int choice;

do
{
    Console.WriteLine("\n===== STUDENT MANAGEMENT SYSTEM =====");
    Console.WriteLine("1. Add Student");
    Console.WriteLine("2. List All Students");
    Console.WriteLine("3. Search Student by ID");
    Console.WriteLine("4. Update Student");
    Console.WriteLine("5. Delete Student");
    Console.WriteLine("6. Exit");
    Console.Write("Enter your choice: ");
    choice = int.Parse(Console.ReadLine()!);   // ! tells the compiler "trust me, this won't be null" for a console read

    if (choice == 1)
    {
        Console.Write("Enter name: ");
        string name = Console.ReadLine()!;
        Console.Write("Enter course: ");
        string course = Console.ReadLine()!;
        Console.Write("Enter GPA: ");
        double gpa = double.Parse(Console.ReadLine()!);
        var added = manager.AddStudent(name, course, gpa);
        Console.WriteLine($"Added! Assigned ID: {added.Id}");
    }
    else if (choice == 2)
    {
        Console.WriteLine("\n--- All Students ---");
        foreach (var s in manager.GetAll())   // Reuses Student's ToString() from Step 1 for each line
        {
            Console.WriteLine(s);
        }
    }
    else if (choice == 3)
    {
        Console.Write("Enter ID to search: ");
        int id = int.Parse(Console.ReadLine()!);
        var found = manager.FindById(id);
        Console.WriteLine(found is null ? "No student with that ID." : found.ToString());
    }
    else if (choice == 4)
    {
        Console.Write("Enter ID to update: ");
        int id = int.Parse(Console.ReadLine()!);
        if (manager.FindById(id) is null)
        {
            Console.WriteLine("No student with that ID.");
        }
        else
        {
            Console.Write("Enter new name: ");
            string newName = Console.ReadLine()!;
            Console.Write("Enter new course: ");
            string newCourse = Console.ReadLine()!;
            Console.Write("Enter new GPA: ");
            double newGpa = double.Parse(Console.ReadLine()!);
            manager.UpdateStudent(id, newName, newCourse, newGpa);
            Console.WriteLine("Student updated.");
        }
    }
    else if (choice == 5)
    {
        Console.Write("Enter ID to delete: ");
        int id = int.Parse(Console.ReadLine()!);
        bool removed = manager.DeleteStudent(id);
        Console.WriteLine(removed ? "Student deleted." : "No student with that ID.");
    }
    else if (choice == 6)
    {
        Console.WriteLine("Goodbye!");
    }
    else
    {
        Console.WriteLine("Invalid choice, try again.");   // Catches anything outside 1-6
    }
} while (choice != 6);   // Keep looping until the user explicitly picks Exit

// --- Type declarations below the top-level statements above ---

class Student
{
    public int Id { get; private set; }
    public string Name { get; set; }
    public string Course { get; set; }
    public double Gpa { get; set; }

    public Student(int id, string name, string course, double gpa)
    {
        Id = id;
        Name = name;
        Course = course;
        Gpa = gpa;
    }

    public override string ToString()
    {
        return $"ID: {Id,-4} | Name: {Name,-20} | Course: {Course,-15} | GPA: {Gpa:F2}";
    }
}

Complete Code

Here is the full program with the menu logic and both classes assembled in the correct order — top-level statements first, then type declarations — ready to save as Program.cs inside a project created with dotnet new console and run with dotnet run.

Program.cs

using System.Collections.Generic;

var manager = new StudentManager();
int choice;

do
{
    Console.WriteLine("\n===== STUDENT MANAGEMENT SYSTEM =====");
    Console.WriteLine("1. Add Student");
    Console.WriteLine("2. List All Students");
    Console.WriteLine("3. Search Student by ID");
    Console.WriteLine("4. Update Student");
    Console.WriteLine("5. Delete Student");
    Console.WriteLine("6. Exit");
    Console.Write("Enter your choice: ");
    choice = int.Parse(Console.ReadLine()!);

    if (choice == 1)
    {
        Console.Write("Enter name: ");
        string name = Console.ReadLine()!;
        Console.Write("Enter course: ");
        string course = Console.ReadLine()!;
        Console.Write("Enter GPA: ");
        double gpa = double.Parse(Console.ReadLine()!);
        var added = manager.AddStudent(name, course, gpa);
        Console.WriteLine($"Added! Assigned ID: {added.Id}");
    }
    else if (choice == 2)
    {
        Console.WriteLine("\n--- All Students ---");
        foreach (var s in manager.GetAll())
        {
            Console.WriteLine(s);
        }
    }
    else if (choice == 3)
    {
        Console.Write("Enter ID to search: ");
        int id = int.Parse(Console.ReadLine()!);
        var found = manager.FindById(id);
        Console.WriteLine(found is null ? "No student with that ID." : found.ToString());
    }
    else if (choice == 4)
    {
        Console.Write("Enter ID to update: ");
        int id = int.Parse(Console.ReadLine()!);
        if (manager.FindById(id) is null)
        {
            Console.WriteLine("No student with that ID.");
        }
        else
        {
            Console.Write("Enter new name: ");
            string newName = Console.ReadLine()!;
            Console.Write("Enter new course: ");
            string newCourse = Console.ReadLine()!;
            Console.Write("Enter new GPA: ");
            double newGpa = double.Parse(Console.ReadLine()!);
            manager.UpdateStudent(id, newName, newCourse, newGpa);
            Console.WriteLine("Student updated.");
        }
    }
    else if (choice == 5)
    {
        Console.Write("Enter ID to delete: ");
        int id = int.Parse(Console.ReadLine()!);
        bool removed = manager.DeleteStudent(id);
        Console.WriteLine(removed ? "Student deleted." : "No student with that ID.");
    }
    else if (choice == 6)
    {
        Console.WriteLine("Goodbye!");
    }
    else
    {
        Console.WriteLine("Invalid choice, try again.");
    }
} while (choice != 6);

class Student
{
    public int Id { get; private set; }
    public string Name { get; set; }
    public string Course { get; set; }
    public double Gpa { get; set; }

    public Student(int id, string name, string course, double gpa)
    {
        Id = id;
        Name = name;
        Course = course;
        Gpa = gpa;
    }

    public override string ToString()
    {
        return $"ID: {Id,-4} | Name: {Name,-20} | Course: {Course,-15} | GPA: {Gpa:F2}";
    }
}

class StudentManager
{
    private List<Student> _students = new List<Student>();
    private int _nextId = 1;

    public Student AddStudent(string name, string course, double gpa)
    {
        var student = new Student(_nextId, name, course, gpa);
        _students.Add(student);
        _nextId++;
        return student;
    }

    public IReadOnlyList<Student> GetAll()
    {
        return _students;
    }

    public Student? FindById(int id)
    {
        foreach (var s in _students)
        {
            if (s.Id == id)
            {
                return s;
            }
        }
        return null;
    }

    public bool UpdateStudent(int id, string newName, string newCourse, double newGpa)
    {
        var student = FindById(id);
        if (student is null)
        {
            return false;
        }
        student.Name = newName;
        student.Course = newCourse;
        student.Gpa = newGpa;
        return true;
    }

    public bool DeleteStudent(int id)
    {
        return _students.RemoveAll(s => s.Id == id) > 0;
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a FindByName(string query) method using LINQ's _students.Where(s => s.Name.Contains(query, StringComparison.OrdinalIgnoreCase)).
Switch StudentManager's backing collection from List<Student> to Dictionary<int, Student> keyed by id, turning FindById() from an O(n) scan into an O(1) lookup.
Persist students to a JSON file with System.Text.Json.JsonSerializer so records survive between program runs.
Replace int.Parse/double.Parse in the menu loop with int.TryParse/double.TryParse so bad input shows a friendly message instead of crashing the program.
Add a SortByGpa() method using _students.Sort((a, b) => b.Gpa.CompareTo(a.Gpa)) to list top performers first.

Summary

You built a working student management system where Student exposes its data through properties instead of Java-style getter/setter methods, and StudentManager composes many students into one manageable, searchable collection backed by List<T>. The add/find/update/delete shape you wrote here — one class owning a collection and exposing a small, well-named method per operation — is the same shape you will reuse in almost every data-driven C# console application from here on.