Studio Shodwe

STUDENT MANAGEMENT SYSTEM

NAME: ROCH AHRON M. BALBERONA

BSCPE 2 - H3

INSTRUCTOR: ENGR. JULIAN N. SEMBLANTE

INTRODUCTION
A console-based application designed to manage student data, including
registration, subject enrollment, and fee tracking.
PROBLEM STATEMENT
The goal of my project is to provide a simple and efficient solution for
managing student information in educational settings, making it easier to
store, retrieve, and update data without the need for complex databases
or manual record-keeping.
FILE HANDLING IN C# AND ITS IMPORTANCE
File handling in C# allows persistent data storage across application
sessions, enabling the reading and writing of data to files (e.g., student
records).
PROJECT OBJECTIVES
Efficiently manage data storage and retrieval through file handling:
The program uses file handling techniques to store and retrieve student data
efficiently.

Implement basic operations (create, read, write, update, delete):

Users can create, read, update, and delete student records, providing flexibility in
managing the data.

Ensure data persistence:

The program saves student data to files, ensuring it remains available for future use.
TECHNOLOGIES AND TOOLS USED
1. programming language and framework:
C# and .NET Framework

2.Visual Studio (or other IDE used):

Visual Studio 2022

3.File Handling Libraries in C# (System.IO): The program relies on the System.IO namespace for managing files,
specifically for operations like creating, reading, writing, and updating text files.
Additional Libraries Used:

System.Collections.Generic: Used for managing collections, such as Dictionary, List, and Queue that store student
data
System.Linq: Provides easy querying of collections and LINQ methods for filtering, selecting, and transforming
data.
System.Text: Useful for manipulating text data (though not heavily used in the current context, it's often used for
efficient string operations).
FEATURES AND FUNCTIONALITIES
Create new files and directories:
The program creates and saves student data files using File.WriteAllText().
Example: Student records are saved to ensure data persistence.

Read data from files:

Existing student data is loaded using File.ReadAllText() to display records.
Example: Student data is available across sessions.

Write and append data to files:

New or updated student data is written to the file.
Example: New student registrations or updates are saved.
FEATURES AND FUNCTIONALITIES
Update and delete data within files:
Student records can be updated or deleted in the file.
Example: A student's course or semester can be modified or removed.

Error handling and exceptions:

The program handles errors like missing files or access issues.
Example: Errors such as "file not found" are caught and managed.
APPLICATION STRUCTURE
User Class: A base class with ID and Password properties, along with an Authenticate() method.
Admin Class: Inherits from User, used for admin login functionality.
Student Class: Inherits from User, with properties like FirstName, LastName, Course, Semester, Subjects, and fee-
related properties. Includes methods for calculating tuition fees, paying fees, and updating student details.
File Handling Methods:

SaveStudentsToFile(): Saves student data to a file.

LoadStudentsFromFile(): Loads student data from a file for later use.

Logical Flow of Operations:

The program reads student data on start, allows fee payment, updating details, and saving changes back to the file.

Why This Structure Was Chosen:

This structure separates concerns clearly: the User class handles authentication, while the Student class focuses
on managing student details and fees. It allows easy extensibility and maintains clarity in handling both student
and administrative functions.
FILE-HANDLING OPERATIONS IN DETAIL
Creating a File
Method Used: File.WriteAllText()
Purpose: Creates a new file or overwrites an existing one to store student data.

Reading a File
Method Used: File.ReadAllText()
Purpose: Reads the content of the file to load student data into the program for processing.

Updating a File
Method Used: File.WriteAllText()
Purpose: After making changes (like adding or deleting students), the file is overwritten with the
updated data.
FILE-HANDLING OPERATIONS IN DETAIL
Deleting a File
Method Used: Not directly used in your program.
Purpose: Instead of deleting the file, student records are removed from the in-memory
collection (using studentAccounts.Remove(id)), and the updated data is saved back to the file.

1. Key Methods from System.IO:

File.Exists(filePath): Checks if a file exists.
File.ReadAllText(filePath): Reads all content from a file.
File.WriteAllText(filePath, content): Writes content to a file.
2. Deleting Data:
Method Used: studentAccounts.Remove(id)
Purpose: Removes a student from the in-memory collection (dictionary), and the updated
list is saved back to the file using File.WriteAllText().
In the LoadStudentsFromFile() method, the program first checks if the file exists
using File.Exists(filePath). If the file is not found, a message is displayed, and the
method exits early. If the file exists, the program reads its entire content into a
string using File.ReadAllText(filePath). The content is then split into individual
student entries using the Split method with double newlines as the delimiter
(Environment.NewLine + Environment.NewLine), ensuring proper separation
between student records. Each student entry is trimmed of extra spaces and
passed to the Student.FromString(entry.Trim()) method, which deserializes the
data into Student objects. These objects are then added to the studentAccounts
dictionary. If an error occurs during the reading or processing of an entry, the
exception is caught, and an error message is printed. Finally, the method outputs
the total number of students successfully loaded from the file.

In the SaveStudentsToFile() method, the program starts by converting each

Student object in the studentAccounts dictionary into its string representation
using student.ToString(). The resulting list of strings is joined with double newlines
to format the student data with proper separation. This formatted string is then
written to the file using File.WriteAllText(filePath, studentDataString), which
overwrites any existing content in the file. Any errors that occur during the file-
writing process, such as file access issues, are caught in a try-catch block, with an
appropriate error message displayed. After the data is successfully written, the
program prints a success message. Both methods are designed with error
handling to ensure that any issues with reading or writing files do not cause the
application to crash.
In my "Student Management System" project, common file handling
errors include file not found, access denied, invalid file format, and I/O
exceptions. These issues can occur due to incorrect paths, lack of
permissions, or file locks. To manage errors, the system checks for file
existence using File.Exists(filePath) and employs try-catch blocks in the
LoadStudentsFromFile() and SaveStudentsToFile() methods to handle
unexpected exceptions. When errors occur, specific messages are
logged. To ensure data integrity, the system validates the format of
student data during reading with Student.FromString(entry.Trim()), and
input validation prevents invalid data from being written. Consistent
formatting is maintained by splitting data with double newlines, which
also serves as a natural check for file integrity.
CHALLENGES AND SOLUTION
Problem: Difficulty in accessing the file due to permission restrictions or the file being in use by another application.
Solution: Implemented checks for file existence using File.Exists(filePath) before attempting to access the file, and
wrapped file reading and writing in try-catch blocks to gracefully handle any file access exceptions. Displaying relevant
error messages informs the user about the specific issue.

Data Consistency and Integrity:

Problem: Ensuring that student data remains consistent and correctly formatted when saving and loading from the file.
Solution: Used consistent formatting (e.g., splitting student entries by double newlines) to maintain the integrity of the file
structure. Additionally, data validation was performed during the loading process using Student.FromString(entry.Trim()) to
catch any improperly formatted entries.

Exception Management:
Problem: Handling unexpected errors during file operations or student data processing.
Solution: Wrapped file operations in try-catch blocks to catch exceptions such as IOException or deserialization errors.
Provided user-friendly error messages, like “Error reading file” or “Error saving students to file,” and ensured that the
application doesn’t crash, making it more resilient.
TEST AND RESULTS
BENEFITS AND APPLICATIONS
In the "Student Management System", file handling offers several advantages for managing
student data efficiently and persistently. The system allows for easy saving and retrieval of
student information like IDs, names..etc by writing to and reading from a file. This file-based
approach ensures that data is retained across sessions, enabling users to load, update, or
delete student records without needing a complex database setup.

The benefits of using file handling in this system include simplicity, low resource usage, and
cost-effectiveness. It is ideal for small-scale systems where complex database solutions are
not necessary. Real-world applications of file handling, as demonstrated in this project,
include student management in educational institutions and creating user-friendly systems
for small schools or organizations that need a reliable way to store and manage data, all
while minimizing overhead costs. This system provides a flexible, straightforward solution to
data storage and management tasks, making it a valuable tool for educational
environments.
FUTURE ENHANCEMENTS
GUI Interface: Adding a graphical interface for more intuitive user interaction.

Database Integration: Integrating with a relational database such as SQL (e.g., MySQL or
SQL Server) for more advanced data management, querying, and scalability.

Advanced File Parsing: Supporting formats like JSON or XML for structured, flexible data
storage.
CONCLUSION
The Student Management System successfully meets the goal of managing student
data through simple file handling. Key achievements include the ability to load,
save, and update student records, as well as implement basic error handling to
ensure data integrity. The project highlighted the importance of validating data
before writing it to a file and handling exceptions to prevent crashes. One of the
main takeaways is the practicality of using file handling in small-scale systems for
easy data management without the overhead of complex databases. The project
also reinforced the significance of error handling, ensuring that user data is
processed correctly and safely.