An excellent illustration of how various components of a.NET program interact is a car rental system. User identification, customer management, car availability, rental operations, database connectivity, validation, and session management are all included.
This post will examine how to use C#, Entity Framework Core, SQL Server, and a layered architecture to construct the essential components of a console-based car rental application.
The application divides duties across several tiers. Repositories manage database operations, services execute business logic, and Entity Framework Core facilitates communication with SQL Server.
The application supports features such as:
- User registration and login
- Customer management
- Vehicle management
- Vehicle rental
- Vehicle return
- Rental validation
- Session management
- Email sending
- Entity Framework Core migrations
- SQL Server database connectivity
- Console-based menus
Application Architecture
The application follows a layered structure:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | Console Application | v Business Logic Layer (BLL) | v Data Access Layer (DAL) | v Entity Framework Core | v SQL Server Database |
The main responsibilities of the layers are:
| Layer | Responsibility |
|---|---|
| Console/UI | Displays menus and receives user input |
| BLL | Contains application and business rules |
| DAL | Handles database operations |
| Entity Framework Core | Maps C# objects to database tables |
| SQL Server | Stores application data |
| Shared | Contains common models, enums, and result objects |
| Utilities | Contains reusable validation and helper functionality |
This separation makes it easier to maintain the application because each layer has a specific responsibility.
Installing Entity Framework Core Packages
The first step is to install the Entity Framework Core packages required by the application.
Using the Package Manager Console, run:
1 2 3 4 5 | Install-Package Microsoft.EntityFrameworkCore Install-Package Microsoft.EntityFrameworkCore.SqlServer Install-Package Microsoft.EntityFrameworkCore.Tools Install-Package Microsoft.EntityFrameworkCore.Design |
The packages are used for different purposes.
Microsoft.EntityFrameworkCoreprovides the core EF Core functionality.Microsoft.EntityFrameworkCore.SqlServerprovides SQL Server support.Microsoft.EntityFrameworkCore.Toolsprovides commands such asAdd-MigrationandUpdate-Database.Microsoft.EntityFrameworkCore.Designprovides design-time functionality required by EF Core tooling.
Reading the Database Connection from appsettings.json
Instead of placing the SQL Server connection string directly inside the DbContext, the application can store it in appsettings.json.
The configuration-related packages can be installed using:
1 2 3 4 5 | Install-Package Microsoft.Extensions.Configuration Install-Package Microsoft.Extensions.Configuration.Json Install-Package Microsoft.Extensions.Configuration.FileExtensions Install-Package Microsoft.Extensions.FileProviders.Physical |
The connection string should contain placeholders when publishing an article.
1 2 3 4 5 6 | { "ConnectionStrings": { "DefaultConnection": "Data Source=YOUR_SERVER;Initial Catalog=YOUR_DATABASE;User ID=YOUR_USER;Password=YOUR_PASSWORD;TrustServerCertificate=True;" } } |
Never publish real database credentials in source code or an article.
The DefaultConnection name is later used by the DbContext to retrieve the connection string.
Creating the AppDbContext
The AppDbContext class inherits from DbContext and represents the database session used by Entity Framework Core.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | using DAL.Entities; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Configuration; namespace DAL.Context { public class AppDbContext : DbContext { public DbSet<User> Users { get; set; } public DbSet<Customer> Customers { get; set; } public DbSet<Vehicle> Vehicles { get; set; } public DbSet<Rental> Rentals { get; set; } protected override void OnConfiguring( DbContextOptionsBuilder optionsBuilder) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .Build(); string? connection = config.GetConnectionString("DefaultConnection"); if (string.IsNullOrEmpty(connection)) { throw new Exception("Connection string not found."); } optionsBuilder.UseSqlServer(connection); } } } |
Each DbSet<T> represents an entity that Entity Framework Core maps to a database table.
For example:
1 2 | public DbSet<Vehicle> Vehicles { get; set; } |
allows the application to query and manage vehicle records through Entity Framework Core.
Configuring Entity Relationships
The application contains relationships between users, customers, vehicles, and rentals.
These relationships can be configured in the OnModelCreating() method.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); modelBuilder.Entity<Customer>() .HasOne(c => c.User) .WithOne(u => u.Customer) .HasForeignKey<Customer>(c => c.UserId) .OnDelete(DeleteBehavior.Restrict); modelBuilder.Entity<Rental>() .HasOne(r => r.Customer) .WithMany(c => c.Rentals) .HasForeignKey(r => r.CustomerId) .OnDelete(DeleteBehavior.Restrict); modelBuilder.Entity<Rental>() .HasOne(r => r.Vehicle) .WithMany(v => v.Rentals) .HasForeignKey(r => r.VehicleId) .OnDelete(DeleteBehavior.Restrict); } |
There are three important relationships here.
User and Customer
A user has a corresponding customer record, creating a one-to-one relationship.
1 2 3 | .HasOne(c => c.User) .WithOne(u => u.Customer) |
The UserId property is used as the foreign key in the Customer entity.
Customer and Rental
A customer can have multiple rental records.
1 2 3 | .HasOne(r => r.Customer) .WithMany(c => c.Rentals) |
This creates a one-to-many relationship.
Vehicle and Rental
A vehicle can be associated with multiple rental records over time.
1 2 3 | .HasOne(r => r.Vehicle) .WithMany(v => v.Rentals) |
DeleteBehavior.Restrict prevents related records from being automatically deleted when a referenced record is deleted.
Adding Seed Data
Entity Framework Core can also insert initial data into the database through HasData().
For example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | modelBuilder.Entity<User>().HasData( new User { Id = 1, Email = "user1@example.com", Password = "CHANGE_ME", IsAdmin = true }, new User { Id = 2, Email = "user2@example.com", Password = "CHANGE_ME", IsAdmin = false } ); |
For demonstration purposes, seed data can be useful during development.
However, passwords should never be stored as plain text in a real application. Passwords should be securely hashed before being stored in the database.
Vehicle records can also be seeded:
1 2 3 4 5 6 7 8 9 10 11 12 13 | modelBuilder.Entity<Vehicle>().HasData( new Vehicle { Id = 1, Name = Name.HondaCity, Category = Category.Car, RentPerDay = 2500, FuelType = FuelType.Petrol, TotalUnits = 5, AvailableUnits = 5 } ); |
Creating the Database with EF Core Migrations
Once the DbContext and entities are configured, create the initial migration using:
1 2 | Add-Migration InitialCreate |
The migration contains the database schema changes detected by Entity Framework Core.
To apply the migration to SQL Server, run:
1 2 | Update-Database |
This creates or updates the database based on the migration.
The basic workflow is:
1 2 3 4 5 6 7 8 9 10 11 | Create/Update Entity | v Add-Migration | v Update-Database | v SQL Server |
Managing User Sessions
Because this is a console application, the application uses a simple session manager to keep track of the currently logged-in user.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | public static User? CurrentUser { get; private set; } public static void Login(User user) { CurrentUser = user; } public static void Logout() { CurrentUser = null; } public static bool IsLoggedIn() { return CurrentUser != null; } public static bool IsAdmin => CurrentUser?.IsAdmin ?? false; |
When login succeeds, the current user is stored in CurrentUser.
When the user logs out, the value is set to null.
The IsLoggedIn() method can then be used to determine whether the user has an active session.
For a simple console application this approach is straightforward. It should not be treated as a replacement for a proper authentication and authorization mechanism in a web or distributed production application.
Validating Email and Password
The application uses a regular expression to perform basic email validation.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | public class EmailValidator { private static readonly Regex _regex = new Regex( @"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.Compiled | RegexOptions.IgnoreCase); public static string? ValidateEmail(string email) { if (string.IsNullOrEmpty(email)) { return Messages.EmptyEmail; } if (!_regex.IsMatch(email)) { return Messages.InvalidEmail; } return null; } public static string? ValidatePass(string pass) { if (string.IsNullOrEmpty(pass)) { return Messages.EmptyPass; } return null; } } |
The email validation checks whether the value is empty and whether it follows the expected email pattern.
The password validation in this example only checks whether the password is empty. A production application should use stronger password requirements and secure password hashing.
Creating a Result Wrapper
The application uses a generic Result<T> class to return both the operation status and the associated data.
1 2 3 4 5 6 7 8 9 | public class Result<T> { public bool Success { get; set; } public string Message { get; set; } = string.Empty; public T? Data { get; set; } } |
This provides a consistent structure for service responses.
For example:
1 2 3 4 5 6 7 | return new Result<bool> { Success = false, Message = "Vehicle is not available.", Data = false }; |
Instead of returning only a Boolean value, the service can also provide a meaningful message.
Implementing User Services
The UserServices class contains the business logic related to vehicle rentals and returns.
It depends on repositories for vehicles, customers, and rentals.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | public class UserServices : IUserServices { private readonly IVehicleRepository _vehicleRepo; private readonly ICustomerRepository _customerRepo; private readonly IRentalRepository _rentalRepo; public UserServices() { _vehicleRepo = new VehicleRepository(); _customerRepo = new CustomerRepository(); _rentalRepo = new RentalRepository(); } } |
The service does not directly perform database queries. Instead, it communicates with repository classes.
This keeps database access separate from business rules.
Getting Available Vehicles
The service can retrieve vehicle records through the vehicle repository.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | public async Task<Result<List<Vehicle>>> GetAllAvailableVehiclesAsync() { var vehicles = await _vehicleRepo.GetAllVehiclesAsync(); if (vehicles.Count == 0) { return new Result<List<Vehicle>> { Success = false, Message = "No available vehicles found.", Data = vehicles }; } return new Result<List<Vehicle>> { Success = true, Message = "Available vehicles retrieved successfully.", Data = vehicles }; } |
The method returns a Result<List<Vehicle>>, allowing the caller to determine whether the operation succeeded and retrieve the vehicle list.
If the repository is intended to return only vehicles with available units, that filtering should be implemented explicitly in the repository query.
Renting a Vehicle
The RentVehicleAsync() method contains the main business rules for renting a vehicle.
First, the number of rental days is validated.
1 2 3 4 5 6 7 8 9 10 | if (rentalDays < 1 || rentalDays > 30) { return new Result<bool> { Success = false, Message = "Rental days must be between 1 and 30.", Data = false }; } |
Next, the current user is retrieved from the session.
1 2 3 4 5 | int userId = SessionManager.CurrentUser!.Id; var customer = await _customerRepo.GetCustomerByUserIdAsync(userId); |
If the customer does not exist, the operation stops.
The selected vehicle is then retrieved.
1 2 3 4 5 6 7 8 9 10 11 12 13 | var vehicle = await _vehicleRepo.GetVehicleByIdAsync(vehicleId); if (vehicle == null) { return new Result<bool> { Success = false, Message = "Vehicle not found.", Data = false }; } |
The application also checks whether the vehicle has available units.
1 2 3 4 5 6 7 8 9 10 | if (vehicle.AvailableUnits <= 0) { return new Result<bool> { Success = false, Message = "Vehicle is not available.", Data = false }; } |
The service then checks the customer’s active rental count.
1 2 3 4 5 6 7 8 9 10 11 12 13 | int activeRentalCount = await _rentalRepo.GetActiveRentalCountAsync(customer.Id); if (activeRentalCount >= 2) { return new Result<bool> { Success = false, Message = "You cannot have more than 2 active rentals.", Data = false }; } |
It also prevents the customer from renting the same vehicle while an existing rental is active.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | bool alreadyRented = await _rentalRepo.HasActiveRentalForVehicleAsync( customer.Id, vehicleId); if (alreadyRented) { return new Result<bool> { Success = false, Message = "You have already rented this vehicle.", Data = false }; } |
Once all validations pass, the rental amount is calculated.
1 2 3 | decimal baseAmount = vehicle.RentPerDay * rentalDays; |
A new Rental object is then created.
1 2 3 4 5 6 7 8 9 10 11 12 | Rental rental = new Rental { CustomerId = customer.Id, VehicleId = vehicle.Id, RentedOn = DateTime.Now, DueDate = DateTime.Now.AddDays(rentalDays), RentalDays = rentalDays, BaseAmount = baseAmount, PenaltyAmount = 0, Status = Status.active }; |
The available vehicle count is reduced by one:
1 2 | vehicle.AvailableUnits--; |
Finally, both the rental and vehicle are updated.
1 2 3 | await _rentalRepo.AddRentalAsync(rental); await _vehicleRepo.UpdateVehicleAsync(vehicle); |
The method returns a successful result:
1 2 3 4 5 6 7 | return new Result<bool> { Success = true, Message = "Vehicle rented successfully.", Data = true }; |
Returning a Vehicle
The ReturnVehicleAsync() method handles the return process.
First, the rental is retrieved.
1 2 3 4 5 6 7 8 9 10 11 12 13 | var rental = await _rentalRepo.GetRentalByIdAsync(rentalId); if (rental == null) { return new Result<bool> { Success = false, Message = "Rental not found.", Data = false }; } |
The application then checks whether the rental is still active.
1 2 3 4 5 6 7 8 9 10 | if (rental.Status != Status.active) { return new Result<bool> { Success = false, Message = "Only active rentals can be returned.", Data = false }; } |
The rental is marked as returned.
1 2 3 | rental.ReturnedOn = DateTime.Now; rental.Status = Status.returned; |
The associated vehicle is retrieved and its available unit count is increased.
1 2 3 4 5 6 7 8 9 10 | var vehicle = await _vehicleRepo.GetVehicleByIdAsync(rental.VehicleId); if (vehicle != null) { vehicle.AvailableUnits++; await _vehicleRepo.UpdateVehicleAsync(vehicle); } |
Finally, the rental record is updated.
1 2 | await _rentalRepo.UpdateRentalAsync(rental); |
This keeps the rental status and vehicle availability synchronized.
Viewing Customer Rentals
The current customer’s rentals can be retrieved using the session information.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | public async Task<List<Rental>> ViewMyRentalsAsync() { int userID = SessionManager.CurrentUser!.Id; var customer = await _customerRepo.GetCustomerByUserIdAsync(userID); if (customer == null) { return new List<Rental>(); } return await _rentalRepo .GetRentalsByCustomerIdAsync(customer.Id); } |
The current user’s ID is obtained from SessionManager, and the corresponding customer record is then used to retrieve rental history.
Creating the Console Menu
The Program.cs file controls the main application flow.
The application first checks whether a user is logged in.
1 2 3 4 5 6 7 8 9 10 11 12 | while (true) { if (!SessionManager.IsLoggedIn()) { // Public menu } else { // Logged-in user menu } } |
For users who are not logged in, the application provides options such as login, registration, and quitting the application.
After successful authentication, the application can display different options based on the user’s role.
A regular user can access operations such as:
1 2 3 4 5 6 | View Available Vehicles Rent a Vehicle Return a Vehicle View My Rentals Logout |
An administrator can be provided with administrative operations according to the application’s requirements.
Adding Console UI Packages
The application can use Spectre.Console for a more structured console interface.
Install it using:
1 2 | Install-Package Spectre.Console |
For example:
1 2 3 | AnsiConsole.MarkupLine( "[green]Welcome to Vehicle Rental System[/]"); |
The package can also be used to create selection menus.
1 2 3 4 5 6 7 8 9 10 | var choice = AnsiConsole.Prompt( new SelectionPrompt<string>() .Title("Choose an option") .AddChoices( "View Available Vehicles", "Rent a Vehicle", "Return a Vehicle", "View My Rentals", "Logout")); |
This provides a menu-based interface instead of requiring the user to enter numeric choices manually.
Sending Email Notifications
The application defines an interface for email sending:
1 2 3 4 5 6 7 8 | public interface IEmailSender { Task SendEmailAsync( string toEmail, string subject, string body); } |
An implementation can use SMTP to send the email.
For example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | public class EmailSender : IEmailSender { public async Task SendEmailAsync( string toEmail, string subject, string body) { var smtp = new SmtpClient( "smtp.example.com", 587) { Credentials = new NetworkCredential( "YOUR_EMAIL", "YOUR_PASSWORD"), EnableSsl = true }; var message = new MailMessage( "YOUR_EMAIL", toEmail, subject, body); await smtp.SendMailAsync(message); } } |
Credentials should never be hard-coded in source code. In a real application, SMTP settings should be stored securely using configuration, environment variables, or a suitable secret-management solution.
Application Workflow
The main vehicle rental workflow can be summarized as follows:
- Start the console application.
- Display the public menu.
- Register a new user or log in.
- Store the authenticated user in the session manager.
- Display user-specific options.
- Retrieve available vehicles from the database.
- Select a vehicle and rental duration.
- Validate the rental request.
- Create a rental record.
- Reduce the available vehicle count.
- Return the vehicle when the rental is completed.
- Update the rental status.
- Increase the vehicle’s available unit count.
- Log out when the session is finished.
Important Production Considerations
The supplied implementation demonstrates the core application flow, but some areas require additional work before using a similar design in a production system.
Password Security
Passwords should never be stored as plain text. Use a secure password hashing mechanism and never include real passwords in seed data or source control.
Database Transactions
The rental operation changes more than one piece of data. Both the rental record and vehicle availability should be updated consistently. A database transaction can be considered to prevent one operation from succeeding while the other fails.
Connection String Security
Database usernames and passwords should not be committed to source control or published in articles.
Authorization
Checking whether a user is an administrator should be backed by proper authorization rules at the service or application boundary.
Error Handling
The current examples primarily handle expected validation failures. Production applications should also handle database exceptions, connection failures, and unexpected errors.
Date and Time Handling
The example uses DateTime.Now. Applications that operate across different time zones should consider a consistent date and time strategy, such as storing UTC timestamps where appropriate.
Common Problems and Troubleshooting
Migration Command Is Not Recognized
Make sure the Entity Framework Core tools package is installed:
1 2 | Install-Package Microsoft.EntityFrameworkCore.Tools |
Then rebuild the project and run:
1 2 | Add-Migration InitialCreate |
Connection String Not Found
Verify that:
appsettings.jsonexists.- The file is copied to the application’s output directory when required.
- The connection string is named
DefaultConnection. - The connection string contains valid database settings.
Database Connection Fails
Check the SQL Server instance name, database name, authentication credentials, and network connectivity.
Vehicle Availability Becomes Incorrect
Rental and return operations update AvailableUnits. These changes should be performed consistently and, for concurrent applications, should be protected against conflicting updates.
Advantages
This architecture provides several benefits:
- Separates business logic from database access.
- Makes the application easier to maintain.
- Uses Entity Framework Core for database operations.
- Provides reusable service and repository classes.
- Supports asynchronous database operations.
- Centralizes session information.
- Provides reusable result objects.
- Allows the console interface to be changed without moving business rules into the UI layer.
Disadvantages
There are also some limitations:
- The current session manager is suitable mainly for a simple console application.
- Direct object creation of repositories and services makes dependency injection more difficult.
- Error handling needs to be expanded for production use.
- Password handling needs stronger security.
- Database transactions should be considered for operations that update multiple records.
- Some validation is performed only at the application level and should also be enforced where appropriate at the database or service level.
Conclusion
A vehicle rental system is a useful example for understanding how a C# application can be divided into multiple layers. In this implementation, the console application handles user interaction, the business layer contains rental rules, repositories handle data access, Entity Framework Core communicates with SQL Server, and the session manager keeps track of the logged-in user.
The application also demonstrates several common .NET concepts, including Entity Framework Core migrations, database relationships, seed data, asynchronous methods, validation, generic result wrappers, and repository-based data access.
The implementation provides a foundation for a vehicle rental application. Before using the same approach in a production system, additional attention should be given to password hashing, secure configuration, authorization, transaction handling, error handling, and concurrency.
Recommendation for ASP.NET 10.0 Hosting
A solid base for developing online services and applications is ASP.NET. Before creating an ASP.NET web application, you must be proficient in JavaScript, HTML, CSS, and C#. There are thousands of web hosting providers offering ASP.NET hosting on the market. However, there are relatively few web hosting providers that offer top-notch ASP.NET hosting.
ASP.NET is the best development language in Windows platform, which is released by Microsoft and widely used to build all types of dynamic Web sites and XML Web services. With this article, we’re going to help you to find the best ASP.NET Hosting solution in Europe based on reliability, features, price, performance and technical support. After we reviewed about 30+ ASP.NET hosting providers in Europe, our Best ASP.NET Hosting Award in Europe goes to HostForLIFE.eu, one of the fastest growing private companies and one of the most reliable hosting providers in Europe.
