Forem: hamza zeryouh

Building an AI-Powered Recommendation System with .NET Core and ML.NET

hamza zeryouh — Mon, 20 Oct 2025 16:20:49 +0000

📚 Table of Contents

Introduction & Architecture
Project Setup
Core Domain Models
Database Setup & Context
Repository Pattern Implementation
Content-Based Filtering Engine
Collaborative Filtering with ML.NET
Hybrid Recommendation Engine
API Controllers & Endpoints
Configuration & Dependency Injection
Database Seeding & Test Data
Error Handling & Middleware
Testing
Docker & Deployment
Running the Application

1. Introduction & Architecture {#section-1}

What We're Building

A complete movie recommendation system that suggests personalized movies using:

✅ Content-based filtering (based on movie features)
✅ Collaborative filtering (based on user behavior patterns)
✅ Hybrid approach (combining multiple strategies)
✅ ML.NET matrix factorization (production-ready machine learning)

Architecture Overview

┌─────────────────────────────────────────────────────┐
│                   API Layer                          │
│  Controllers, Middleware, Authentication             │
└──────────────────┬──────────────────────────────────┘
                   │
┌──────────────────▼──────────────────────────────────┐
│              Application/Core Layer                  │
│  Services, Entities, Interfaces, Business Logic      │
└──────────────────┬──────────────────────────────────┘
                   │
┌──────────────────▼──────────────────────────────────┐
│           Infrastructure Layer                       │
│  Repositories, DbContext, ML.NET, Caching            │
└──────────────────┬──────────────────────────────────┘
                   │
┌──────────────────▼──────────────────────────────────┐
│              Database (SQL Server)                   │
│  Movies, Users, Interactions                         │
└─────────────────────────────────────────────────────┘

Tech Stack

.NET 8.0
ML.NET (Recommendation)
Entity Framework Core
SQL Server
Swagger/OpenAPI
xUnit (Testing)

2. Project Setup {#section-2}

Step 1: Create Solution Structure

# Create solution directory
mkdir MovieRecommendation
cd MovieRecommendation

# Create projects
dotnet new webapi -n MovieRecommendation.API
dotnet new classlib -n MovieRecommendation.Core
dotnet new classlib -n MovieRecommendation.Infrastructure
dotnet new xunit -n MovieRecommendation.Tests

# Create solution
dotnet new sln -n MovieRecommendation

# Add projects to solution
dotnet sln add MovieRecommendation.API
dotnet sln add MovieRecommendation.Core
dotnet sln add MovieRecommendation.Infrastructure
dotnet sln add MovieRecommendation.Tests

# Add project references
cd MovieRecommendation.API
dotnet add reference ../MovieRecommendation.Core
dotnet add reference ../MovieRecommendation.Infrastructure
cd ..

cd MovieRecommendation.Infrastructure
dotnet add reference ../MovieRecommendation.Core
cd ..

cd MovieRecommendation.Tests
dotnet add reference ../MovieRecommendation.API
dotnet add reference ../MovieRecommendation.Core
dotnet add reference ../MovieRecommendation.Infrastructure
cd ..

Step 2: Install Required NuGet Packages

# Core project - ML.NET
cd MovieRecommendation.Core
dotnet add package Microsoft.ML --version 3.0.1
dotnet add package Microsoft.ML.Recommender --version 0.21.1
cd ..

# Infrastructure project - EF Core
cd MovieRecommendation.Infrastructure
dotnet add package Microsoft.EntityFrameworkCore --version 8.0.0
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 8.0.0
dotnet add package Microsoft.EntityFrameworkCore.Tools --version 8.0.0
dotnet add package Microsoft.Extensions.Caching.Memory --version 8.0.0
cd ..

# API project
cd MovieRecommendation.API
dotnet add package Swashbuckle.AspNetCore --version 6.5.0
dotnet add package Microsoft.EntityFrameworkCore.Design --version 8.0.0
cd ..

# Tests project
cd MovieRecommendation.Tests
dotnet add package Moq --version 4.20.70
dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 8.0.0
cd ..

3. Core Domain Models {#section-3}

MovieRecommendation.Core/Entities/Movie.cs

namespace MovieRecommendation.Core.Entities;

public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    public List<string> Genres { get; set; } = new();
    public List<string> Actors { get; set; } = new();
    public string Director { get; set; } = string.Empty;
    public int ReleaseYear { get; set; }
    public int DurationMinutes { get; set; }
    public double AverageRating { get; set; }
    public int TotalRatings { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}

MovieRecommendation.Core/Entities/User.cs

namespace MovieRecommendation.Core.Entities;

public class User
{
    public int Id { get; set; }
    public string Username { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public List<string> FavoriteGenres { get; set; } = new();
    public List<string> FavoriteActors { get; set; } = new();
    public int PreferredMinYear { get; set; }
    public int PreferredMaxYear { get; set; } = 2024;
    public int PreferredMinDuration { get; set; }
    public int PreferredMaxDuration { get; set; } = 200;
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}

MovieRecommendation.Core/Entities/UserInteraction.cs

namespace MovieRecommendation.Core.Entities;

public class UserInteraction
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public int MovieId { get; set; }
    public InteractionType Type { get; set; }
    public double? Rating { get; set; } // 1-5 stars
    public DateTime Timestamp { get; set; } = DateTime.UtcNow;

    // Navigation properties
    public User? User { get; set; }
    public Movie? Movie { get; set; }
}

public enum InteractionType
{
    View = 1,
    Rating = 2,
    Favorite = 3,
    WatchedComplete = 4,
    Dismissed = 5
}

MovieRecommendation.Core/Models/MovieRating.cs (ML.NET Models)

using Microsoft.ML.Data;

namespace MovieRecommendation.Core.Models;

public class MovieRating
{
    [LoadColumn(0)]
    public float UserId { get; set; }

    [LoadColumn(1)]
    public float MovieId { get; set; }

    [LoadColumn(2)]
    public float Rating { get; set; }
}

public class MovieRatingPrediction
{
    public float Score { get; set; }
}

MovieRecommendation.Core/Models/RecommendationResult.cs

namespace MovieRecommendation.Core.Models;

public class RecommendationResult
{
    public int MovieId { get; set; }
    public string Title { get; set; } = string.Empty;
    public double OverallScore { get; set; }
    public double ContentScore { get; set; }
    public double CollaborativeScore { get; set; }
    public double PopularityScore { get; set; }
    public Dictionary<string, double> DetailedScores { get; set; } = new();
    public string ReasonForRecommendation { get; set; } = string.Empty;
    public DateTime GeneratedAt { get; set; } = DateTime.UtcNow;
}

public class RecommendationWeights
{
    public double ContentWeight { get; set; } = 0.4;
    public double CollaborativeWeight { get; set; } = 0.3;
    public double PopularityWeight { get; set; } = 0.2;
    public double RecencyWeight { get; set; } = 0.1;

    // Content-based sub-weights
    public double GenreWeight { get; set; } = 0.35;
    public double ActorWeight { get; set; } = 0.25;
    public double YearWeight { get; set; } = 0.20;
    public double DurationWeight { get; set; } = 0.20;
}

4. Database Setup & Context {#section-4}

MovieRecommendation.Infrastructure/Data/AppDbContext.cs

using Microsoft.EntityFrameworkCore;
using MovieRecommendation.Core.Entities;

namespace MovieRecommendation.Infrastructure.Data;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
    {
    }

    public DbSet<Movie> Movies => Set<Movie>();
    public DbSet<User> Users => Set<User>();
    public DbSet<UserInteraction> UserInteractions => Set<UserInteraction>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // Movie configuration
        modelBuilder.Entity<Movie>(entity =>
        {
            entity.ToTable("Movies");
            entity.HasKey(e => e.Id);

            entity.Property(e => e.Title)
                .IsRequired()
                .HasMaxLength(200);

            entity.Property(e => e.Description)
                .HasMaxLength(2000);

            entity.Property(e => e.Director)
                .HasMaxLength(100);

            // Convert List<string> to comma-separated string for storage
            entity.Property(e => e.Genres)
                .HasConversion(
                    v => string.Join(',', v),
                    v => v.Split(',', StringSplitOptions.RemoveEmptyEntries).ToList())
                .HasMaxLength(500);

            entity.Property(e => e.Actors)
                .HasConversion(
                    v => string.Join(',', v),
                    v => v.Split(',', StringSplitOptions.RemoveEmptyEntries).ToList())
                .HasMaxLength(1000);

            // Indexes for better query performance
            entity.HasIndex(e => e.ReleaseYear);
            entity.HasIndex(e => e.AverageRating);
            entity.HasIndex(e => e.CreatedAt);
        });

        // User configuration
        modelBuilder.Entity<User>(entity =>
        {
            entity.ToTable("Users");
            entity.HasKey(e => e.Id);

            entity.Property(e => e.Username)
                .IsRequired()
                .HasMaxLength(100);

            entity.Property(e => e.Email)
                .IsRequired()
                .HasMaxLength(200);

            entity.Property(e => e.FavoriteGenres)
                .HasConversion(
                    v => string.Join(',', v),
                    v => v.Split(',', StringSplitOptions.RemoveEmptyEntries).ToList())
                .HasMaxLength(500);

            entity.Property(e => e.FavoriteActors)
                .HasConversion(
                    v => string.Join(',', v),
                    v => v.Split(',', StringSplitOptions.RemoveEmptyEntries).ToList())
                .HasMaxLength(1000);

            entity.HasIndex(e => e.Username).IsUnique();
            entity.HasIndex(e => e.Email).IsUnique();
        });

        // UserInteraction configuration
        modelBuilder.Entity<UserInteraction>(entity =>
        {
            entity.ToTable("UserInteractions");
            entity.HasKey(e => e.Id);

            entity.Property(e => e.Type)
                .HasConversion<string>()
                .HasMaxLength(50);

            // Relationships
            entity.HasOne(e => e.User)
                .WithMany()
                .HasForeignKey(e => e.UserId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(e => e.Movie)
                .WithMany()
                .HasForeignKey(e => e.MovieId)
                .OnDelete(DeleteBehavior.Cascade);

            // Indexes
            entity.HasIndex(e => new { e.UserId, e.MovieId });
            entity.HasIndex(e => e.Timestamp);
            entity.HasIndex(e => e.Type);
        });
    }
}

5. Repository Pattern Implementation {#section-5}

MovieRecommendation.Core/Repositories/IMovieRepository.cs

using MovieRecommendation.Core.Entities;

namespace MovieRecommendation.Core.Repositories;

public interface IMovieRepository
{
    Task<Movie?> GetByIdAsync(int id);
    Task<List<Movie>> GetAvailableMoviesAsync(int limit);
    Task<List<Movie>> GetMoviesByGenreAsync(string genre, int limit);
    Task<List<Movie>> GetMoviesByActorAsync(string actor, int limit);
    Task<Movie> AddAsync(Movie movie);
    Task UpdateAsync(Movie movie);
    Task DeleteAsync(int id);
}

MovieRecommendation.Core/Repositories/IUserRepository.cs

using MovieRecommendation.Core.Entities;

namespace MovieRecommendation.Core.Repositories;

public interface IUserRepository
{
    Task<User?> GetByIdAsync(int id);
    Task<User?> GetByUsernameAsync(string username);
    Task<User> AddAsync(User user);
    Task UpdateAsync(User user);
    Task DeleteAsync(int id);
}

MovieRecommendation.Core/Repositories/IInteractionRepository.cs

using MovieRecommendation.Core.Entities;

namespace MovieRecommendation.Core.Repositories;

public interface IInteractionRepository
{
    Task<List<UserInteraction>> GetUserInteractionsAsync(int userId);
    Task<List<UserInteraction>> GetAllRatingsAsync();
    Task<UserInteraction> AddAsync(UserInteraction interaction);
    Task<int> GetInteractionCountAsync();
}

MovieRecommendation.Infrastructure/Repositories/MovieRepository.cs

using Microsoft.EntityFrameworkCore;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Infrastructure.Data;

namespace MovieRecommendation.Infrastructure.Repositories;

public class MovieRepository : IMovieRepository
{
    private readonly AppDbContext _context;

    public MovieRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task<Movie?> GetByIdAsync(int id)
    {
        return await _context.Movies.FindAsync(id);
    }

    public async Task<List<Movie>> GetAvailableMoviesAsync(int limit)
    {
        return await _context.Movies
            .OrderByDescending(m => m.CreatedAt)
            .Take(limit)
            .ToListAsync();
    }

    public async Task<List<Movie>> GetMoviesByGenreAsync(string genre, int limit)
    {
        return await _context.Movies
            .Where(m => m.Genres.Contains(genre))
            .OrderByDescending(m => m.AverageRating)
            .Take(limit)
            .ToListAsync();
    }

    public async Task<List<Movie>> GetMoviesByActorAsync(string actor, int limit)
    {
        return await _context.Movies
            .Where(m => m.Actors.Contains(actor))
            .OrderByDescending(m => m.AverageRating)
            .Take(limit)
            .ToListAsync();
    }

    public async Task<Movie> AddAsync(Movie movie)
    {
        _context.Movies.Add(movie);
        await _context.SaveChangesAsync();
        return movie;
    }

    public async Task UpdateAsync(Movie movie)
    {
        _context.Movies.Update(movie);
        await _context.SaveChangesAsync();
    }

    public async Task DeleteAsync(int id)
    {
        var movie = await GetByIdAsync(id);
        if (movie != null)
        {
            _context.Movies.Remove(movie);
            await _context.SaveChangesAsync();
        }
    }
}

MovieRecommendation.Infrastructure/Repositories/UserRepository.cs

using Microsoft.EntityFrameworkCore;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Infrastructure.Data;

namespace MovieRecommendation.Infrastructure.Repositories;

public class UserRepository : IUserRepository
{
    private readonly AppDbContext _context;

    public UserRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task<User?> GetByIdAsync(int id)
    {
        return await _context.Users.FindAsync(id);
    }

    public async Task<User?> GetByUsernameAsync(string username)
    {
        return await _context.Users
            .FirstOrDefaultAsync(u => u.Username == username);
    }

    public async Task<User> AddAsync(User user)
    {
        _context.Users.Add(user);
        await _context.SaveChangesAsync();
        return user;
    }

    public async Task UpdateAsync(User user)
    {
        _context.Users.Update(user);
        await _context.SaveChangesAsync();
    }

    public async Task DeleteAsync(int id)
    {
        var user = await GetByIdAsync(id);
        if (user != null)
        {
            _context.Users.Remove(user);
            await _context.SaveChangesAsync();
        }
    }
}

MovieRecommendation.Infrastructure/Repositories/InteractionRepository.cs

using Microsoft.EntityFrameworkCore;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Infrastructure.Data;

namespace MovieRecommendation.Infrastructure.Repositories;

public class InteractionRepository : IInteractionRepository
{
    private readonly AppDbContext _context;

    public InteractionRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task<List<UserInteraction>> GetUserInteractionsAsync(int userId)
    {
        return await _context.UserInteractions
            .Where(i => i.UserId == userId)
            .OrderByDescending(i => i.Timestamp)
            .ToListAsync();
    }

    public async Task<List<UserInteraction>> GetAllRatingsAsync()
    {
        return await _context.UserInteractions
            .Where(i => i.Type == InteractionType.Rating && i.Rating.HasValue)
            .ToListAsync();
    }

    public async Task<UserInteraction> AddAsync(UserInteraction interaction)
    {
        _context.UserInteractions.Add(interaction);
        await _context.SaveChangesAsync();
        return interaction;
    }

    public async Task<int> GetInteractionCountAsync()
    {
        return await _context.UserInteractions
            .Where(i => i.Type == InteractionType.Rating)
            .CountAsync();
    }
}

6. Content-Based Filtering Engine {#section-6}

MovieRecommendation.Core/Services/IContentBasedEngine.cs

using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Models;

namespace MovieRecommendation.Core.Services;

public interface IContentBasedEngine
{
    Task<double> CalculateSimilarityScore(User user, Movie movie);
    Task<List<RecommendationResult>> GetContentBasedRecommendations(int userId, int limit = 10);
}

MovieRecommendation.Infrastructure/Services/ContentBasedEngine.cs

using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Models;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Core.Services;
using Microsoft.Extensions.Logging;

namespace MovieRecommendation.Infrastructure.Services;

public class ContentBasedEngine : IContentBasedEngine
{
    private readonly IMovieRepository _movieRepository;
    private readonly IUserRepository _userRepository;
    private readonly IInteractionRepository _interactionRepository;
    private readonly ILogger<ContentBasedEngine> _logger;

    public ContentBasedEngine(
        IMovieRepository movieRepository,
        IUserRepository userRepository,
        IInteractionRepository interactionRepository,
        ILogger<ContentBasedEngine> logger)
    {
        _movieRepository = movieRepository;
        _userRepository = userRepository;
        _interactionRepository = interactionRepository;
        _logger = logger;
    }

    public async Task<double> CalculateSimilarityScore(User user, Movie movie)
    {
        var weights = new RecommendationWeights();
        double totalScore = 0.0;

        // Genre similarity (35%)
        if (user.FavoriteGenres.Any())
        {
            var genreScore = CalculateGenreScore(user.FavoriteGenres, movie.Genres);
            totalScore += genreScore * weights.GenreWeight;
        }

        // Actor similarity (25%)
        if (user.FavoriteActors.Any())
        {
            var actorScore = CalculateActorScore(user.FavoriteActors, movie.Actors);
            totalScore += actorScore * weights.ActorWeight;
        }

        // Year preference (20%)
        var yearScore = CalculateYearScore(
            user.PreferredMinYear, user.PreferredMaxYear, movie.ReleaseYear);
        totalScore += yearScore * weights.YearWeight;

        // Duration preference (20%)
        var durationScore = CalculateDurationScore(
            user.PreferredMinDuration, user.PreferredMaxDuration, movie.DurationMinutes);
        totalScore += durationScore * weights.DurationWeight;

        return Math.Max(0.0, Math.Min(1.0, totalScore));
    }

    private double CalculateGenreScore(List<string> userGenres, List<string> movieGenres)
    {
        if (!movieGenres.Any()) return 0.3;

        // Jaccard similarity: intersection / union
        var intersection = userGenres.Intersect(movieGenres, StringComparer.OrdinalIgnoreCase).Count();
        var union = userGenres.Union(movieGenres, StringComparer.OrdinalIgnoreCase).Count();

        if (union == 0) return 0.3;

        double jaccardScore = (double)intersection / union;

        // Bonus if all user preferences are met
        var allPreferencesMet = userGenres.All(g => 
            movieGenres.Contains(g, StringComparer.OrdinalIgnoreCase));

        if (allPreferencesMet && intersection > 0)
            jaccardScore = Math.Min(1.0, jaccardScore + 0.2);

        return jaccardScore;
    }

    private double CalculateActorScore(List<string> userActors, List<string> movieActors)
    {
        if (!movieActors.Any()) return 0.5;

        var matchCount = userActors.Count(ua => 
            movieActors.Contains(ua, StringComparer.OrdinalIgnoreCase));

        if (matchCount == 0) return 0.3;

        return Math.Min(1.0, (double)matchCount / userActors.Count + 0.2);
    }

    private double CalculateYearScore(int minYear, int maxYear, int movieYear)
    {
        if (minYear == 0 && maxYear == 0) return 0.5;

        if (movieYear >= minYear && movieYear <= maxYear)
            return 1.0;

        // Calculate distance from range with tolerance
        int distance;
        if (movieYear < minYear)
            distance = minYear - movieYear;
        else
            distance = movieYear - maxYear;

        var tolerance = 10; // 10 years tolerance
        return Math.Max(0.0, 1.0 - (double)distance / tolerance);
    }

    private double CalculateDurationScore(int minDuration, int maxDuration, int movieDuration)
    {
        if (minDuration == 0 && maxDuration == 0) return 0.5;

        if (movieDuration >= minDuration && movieDuration <= maxDuration)
            return 1.0;

        // Within 20% tolerance
        var midPoint = (minDuration + maxDuration) / 2.0;
        var difference = Math.Abs(movieDuration - midPoint);
        var tolerance = midPoint * 0.2;

        return Math.Max(0.0, 1.0 - difference / tolerance);
    }

    public async Task<List<RecommendationResult>> GetContentBasedRecommendations(
        int userId, int limit = 10)
    {
        var user = await _userRepository.GetByIdAsync(userId);
        if (user == null)
        {
            _logger.LogWarning("User {UserId} not found", userId);
            return new List<RecommendationResult>();
        }

        // Get movies user hasn't interacted with
        var userInteractions = await _interactionRepository.GetUserInteractionsAsync(userId);
        var watchedMovieIds = userInteractions.Select(i => i.MovieId).ToHashSet();

        // Get candidate movies
        var candidateMovies = await _movieRepository.GetAvailableMoviesAsync(limit * 5);
        candidateMovies = candidateMovies
            .Where(m => !watchedMovieIds.Contains(m.Id))
            .ToList();

        var recommendations = new List<RecommendationResult>();

        foreach (var movie in candidateMovies)
        {
            var similarityScore = await CalculateSimilarityScore(user, movie);

            recommendations.Add(new RecommendationResult
            {
                MovieId = movie.Id,
                Title = movie.Title,
                ContentScore = similarityScore,
                DetailedScores = new Dictionary<string, double>
                {
                    ["Genre"] = CalculateGenreScore(user.FavoriteGenres, movie.Genres),
                    ["Actor"] = CalculateActorScore(user.FavoriteActors, movie.Actors),
                    ["Year"] = CalculateYearScore(user.PreferredMinYear, user.PreferredMaxYear, movie.ReleaseYear),
                    ["Duration"] = CalculateDurationScore(user.PreferredMinDuration, user.PreferredMaxDuration, movie.DurationMinutes),
                    ["Rating"] = movie.AverageRating / 5.0
                }
            });
        }

        return recommendations
            .OrderByDescending(r => r.ContentScore)
            .Take(limit)
            .ToList();
    }
}

7. Collaborative Filtering with ML.NET {#section-7}

MovieRecommendation.Core/Services/ICollaborativeEngine.cs

using MovieRecommendation.Core.Models;

namespace MovieRecommendation.Core.Services;

public interface ICollaborativeEngine
{
    Task<bool> TrainModelAsync();
    Task<double> PredictRating(int userId, int movieId);
    Task<List<RecommendationResult>> GetCollaborativeRecommendations(int userId, int limit = 10);
}

MovieRecommendation.Infrastructure/Services/CollaborativeEngine.cs

using Microsoft.ML;
using Microsoft.ML.Trainers;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Logging;
using MovieRecommendation.Core.Models;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Core.Services;

namespace MovieRecommendation.Infrastructure.Services;

public class CollaborativeEngine : ICollaborativeEngine
{
    private readonly IInteractionRepository _interactionRepository;
    private readonly IMovieRepository _movieRepository;
    private readonly IMemoryCache _cache;
    private readonly ILogger<CollaborativeEngine> _logger;
    private readonly MLContext _mlContext;

    private const string ModelCacheKey = "collaborative_model";
    private readonly TimeSpan ModelCacheExpiration = TimeSpan.FromHours(24);

    public CollaborativeEngine(
        IInteractionRepository interactionRepository,
        IMovieRepository movieRepository,
        IMemoryCache cache,
        ILogger<CollaborativeEngine> logger)
    {
        _interactionRepository = interactionRepository;
        _movieRepository = movieRepository;
        _cache = cache;
        _logger = logger;
        _mlContext = new MLContext(seed: 0);
    }

    public async Task<bool> TrainModelAsync()
    {
        try
        {
            _logger.LogInformation("Starting collaborative filtering model training...");

            // Get training data
            var interactions = await _interactionRepository.GetAllRatingsAsync();

            if (interactions.Count < 100)
            {
                _logger.LogWarning(
                    "Not enough data to train model. Need at least 100 ratings, got {Count}", 
                    interactions.Count);
                return false;
            }

            // Convert to ML.NET format
            var trainingData = interactions.Select(i => new MovieRating
            {
                UserId = i.UserId,
                MovieId = i.MovieId,
                Rating = (float)(i.Rating ?? 3.0)
            }).ToList();

            var dataView = _mlContext.Data.LoadFromEnumerable(trainingData);

            // Split data for validation
            var dataSplit = _mlContext.Data.TrainTestSplit(dataView, testFraction: 0.2);

            // Configure matrix factorization
            var options = new MatrixFactorizationTrainer.Options
            {
                MatrixColumnIndexColumnName = nameof(MovieRating.UserId),
                MatrixRowIndexColumnName = nameof(MovieRating.MovieId),
                LabelColumnName = nameof(MovieRating.Rating),
                NumberOfIterations = 20,
                ApproximationRank = 100,
                LearningRate = 0.001,
                Quiet = false
            };

            // Train the model
            _logger.LogInformation("Training matrix factorization model...");
            var trainer = _mlContext.Recommendation().Trainers.MatrixFactorization(options);
            var model = trainer.Fit(dataSplit.TrainSet);

            // Evaluate
            var predictions = model.Transform(dataSplit.TestSet);
            var metrics = _mlContext.Regression.Evaluate(
                predictions, 
                labelColumnName: nameof(MovieRating.Rating));

            _logger.LogInformation(
                "Model trained. RMSE: {RMSE:F3}, R²: {RSquared:F3}", 
                metrics.RootMeanSquaredError, 
                metrics.RSquared);

            // Cache the model
            var cacheOptions = new MemoryCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = ModelCacheExpiration,
                Size = 100
            };
            _cache.Set(ModelCacheKey, model, cacheOptions);

            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error training collaborative filtering model");
            return false;
        }
    }

    public async Task<double> PredictRating(int userId, int movieId)
    {
        try
        {
            if (!_cache.TryGetValue(ModelCacheKey, out ITransformer? model) || model == null)
            {
                _logger.LogDebug("Model not in cache, returning neutral score");
                return 2.5;
            }

            var predictionEngine = _mlContext.Model
                .CreatePredictionEngine<MovieRating, MovieRatingPrediction>(model);

            var input = new MovieRating
            {
                UserId = userId,
                MovieId = movieId
            };

            var prediction = predictionEngine.Predict(input);

            // Clamp to 0-5 range
            return Math.Max(0, Math.Min(5, prediction.Score));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error predicting rating for user {UserId}, movie {MovieId}", 
                userId, movieId);
            return 2.5;
        }
    }

    public async Task<List<RecommendationResult>> GetCollaborativeRecommendations(
        int userId, int limit = 10)
    {
        try
        {
            var userInteractions = await _interactionRepository.GetUserInteractionsAsync(userId);
            var watchedMovieIds = userInteractions.Select(i => i.MovieId).ToHashSet();

            var candidateMovies = await _movieRepository.GetAvailableMoviesAsync(limit * 5);
            candidateMovies = candidateMovies
                .Where(m => !watchedMovieIds.Contains(m.Id))
                .ToList();

            var recommendations = new List<RecommendationResult>();

            foreach (var movie in candidateMovies)
            {
                var predictedRating = await PredictRating(userId, movie.Id);
                var normalizedScore = predictedRating / 5.0;

                recommendations.Add(new RecommendationResult
                {
                    MovieId = movie.Id,
                    Title = movie.Title,
                    CollaborativeScore = normalizedScore
                });
            }

            return recommendations
                .OrderByDescending(r => r.CollaborativeScore)
                .Take(limit)
                .ToList();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting collaborative recommendations for user {UserId}", userId);
            return new List<RecommendationResult>();
        }
    }
}

8. Hybrid Recommendation Engine {#section-8}

MovieRecommendation.Core/Services/IRecommendationEngine.cs

using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Models;

namespace MovieRecommendation.Core.Services;

public interface IRecommendationEngine
{
    Task<List<RecommendationResult>> GetRecommendations(
        int userId, 
        int limit = 10, 
        RecommendationWeights? weights = null);

    Task TrackInteraction(int userId, int movieId, InteractionType type, double? rating = null);
}

MovieRecommendation.Infrastructure/Services/RecommendationEngine.cs

using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Models;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Core.Services;
using Microsoft.Extensions.Logging;

namespace MovieRecommendation.Infrastructure.Services;

public class RecommendationEngine : IRecommendationEngine
{
    private readonly IContentBasedEngine _contentEngine;
    private readonly ICollaborativeEngine _collaborativeEngine;
    private readonly IMovieRepository _movieRepository;
    private readonly IInteractionRepository _interactionRepository;
    private readonly ILogger<RecommendationEngine> _logger;

    public RecommendationEngine(
        IContentBasedEngine contentEngine,
        ICollaborativeEngine collaborativeEngine,
        IMovieRepository movieRepository,
        IInteractionRepository interactionRepository,
        ILogger<RecommendationEngine> logger)
    {
        _contentEngine = contentEngine;
        _collaborativeEngine = collaborativeEngine;
        _movieRepository = movieRepository;
        _interactionRepository = interactionRepository;
        _logger = logger;
    }

    public async Task<List<RecommendationResult>> GetRecommendations(
        int userId, 
        int limit = 10, 
        RecommendationWeights? weights = null)
    {
        weights ??= new RecommendationWeights();

        try
        {
            _logger.LogInformation("Generating recommendations for user {UserId} with limit {Limit}", 
                userId, limit);

            // Get recommendations from both engines in parallel
            var contentTask = _contentEngine.GetContentBasedRecommendations(userId, limit * 3);
            var collaborativeTask = _collaborativeEngine.GetCollaborativeRecommendations(userId, limit * 3);

            await Task.WhenAll(contentTask, collaborativeTask);

            var contentRecommendations = contentTask.Result;
            var collaborativeRecommendations = collaborativeTask.Result;

            // Merge recommendations
            var mergedRecommendations = MergeRecommendations(
                contentRecommendations, 
                collaborativeRecommendations);

            // Calculate overall scores
            foreach (var recommendation in mergedRecommendations)
            {
                var movie = await _movieRepository.GetByIdAsync(recommendation.MovieId);
                if (movie == null) continue;

                // Calculate popularity score
                var popularityScore = CalculatePopularityScore(movie);
                recommendation.PopularityScore = popularityScore;

                // Calculate recency score
                var recencyScore = CalculateRecencyScore(movie);

                // Calculate overall weighted score
                recommendation.OverallScore = 
                    (recommendation.ContentScore * weights.ContentWeight) +
                    (recommendation.CollaborativeScore * weights.CollaborativeWeight) +
                    (popularityScore * weights.PopularityWeight) +
                    (recencyScore * weights.RecencyWeight);

                // Generate human-readable explanation
                recommendation.ReasonForRecommendation = 
                    GenerateRecommendationReason(recommendation);
            }

            var finalRecommendations = mergedRecommendations
                .OrderByDescending(r => r.OverallScore)
                .Take(limit)
                .ToList();

            _logger.LogInformation(
                "Generated {Count} recommendations for user {UserId}", 
                finalRecommendations.Count, userId);

            return finalRecommendations;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error generating recommendations for user {UserId}", userId);
            return new List<RecommendationResult>();
        }
    }

    private List<RecommendationResult> MergeRecommendations(
        List<RecommendationResult> contentRecs,
        List<RecommendationResult> collaborativeRecs)
    {
        var merged = new Dictionary<int, RecommendationResult>();

        // Add content-based recommendations
        foreach (var rec in contentRecs)
        {
            merged[rec.MovieId] = rec;
        }

        // Merge collaborative recommendations
        foreach (var rec in collaborativeRecs)
        {
            if (merged.ContainsKey(rec.MovieId))
            {
                // Update existing recommendation with collaborative score
                merged[rec.MovieId].CollaborativeScore = rec.CollaborativeScore;
            }
            else
            {
                // Add new recommendation
                merged[rec.MovieId] = rec;
            }
        }

        return merged.Values.ToList();
    }

    private double CalculatePopularityScore(Core.Entities.Movie movie)
    {
        // Combine rating quality and number of ratings
        if (movie.TotalRatings == 0) 
            return 0.3; // New movies get neutral score

        // Normalize rating (0-5 scale to 0-1)
        var ratingScore = movie.AverageRating / 5.0;

        // Normalize popularity (use logarithmic scale for diminishing returns)
        var popularityScore = Math.Min(1.0, Math.Log10(movie.TotalRatings + 1) / 5.0);

        // Weighted combination: 70% rating, 30% popularity
        return (ratingScore * 0.7) + (popularityScore * 0.3);
    }

    private double CalculateRecencyScore(Core.Entities.Movie movie)
    {
        var daysSinceCreation = (DateTime.UtcNow - movie.CreatedAt).Days;

        // Recent movies get higher score
        if (daysSinceCreation <= 30) return 1.0;      // New (last month)
        if (daysSinceCreation <= 90) return 0.8;      // Recent (last 3 months)
        if (daysSinceCreation <= 180) return 0.6;     // Semi-recent (last 6 months)
        if (daysSinceCreation <= 365) return 0.4;     // This year
        return 0.2;                                    // Older
    }

    private string GenerateRecommendationReason(RecommendationResult recommendation)
    {
        var reasons = new List<string>();

        // Check content-based factors
        if (recommendation.ContentScore > 0.7)
            reasons.Add("matches your preferences");

        // Check collaborative filtering
        if (recommendation.CollaborativeScore > 0.7)
            reasons.Add("loved by users like you");

        // Check popularity
        if (recommendation.PopularityScore > 0.7)
            reasons.Add("highly rated by many viewers");

        // Check detailed scores
        if (recommendation.DetailedScores.TryGetValue("Genre", out var genreScore) 
            && genreScore > 0.8)
            reasons.Add("in your favorite genre");

        if (recommendation.DetailedScores.TryGetValue("Actor", out var actorScore) 
            && actorScore > 0.8)
            reasons.Add("features your favorite actors");

        // Generate natural language explanation
        if (!reasons.Any())
            return "Recommended for you based on our analysis";

        if (reasons.Count == 1)
            return $"Recommended because it {reasons[0]}";

        if (reasons.Count == 2)
            return $"Recommended because it {reasons[0]} and {reasons[1]}";

        var lastReason = reasons.Last();
        reasons.RemoveAt(reasons.Count - 1);
        return $"Recommended because it {string.Join(", ", reasons)}, and {lastReason}";
    }

    public async Task TrackInteraction(
        int userId, 
        int movieId, 
        InteractionType type, 
        double? rating = null)
    {
        try
        {
            var interaction = new UserInteraction
            {
                UserId = userId,
                MovieId = movieId,
                Type = type,
                Rating = rating,
                Timestamp = DateTime.UtcNow
            };

            await _interactionRepository.AddAsync(interaction);

            _logger.LogInformation(
                "Tracked interaction: User {UserId}, Movie {MovieId}, Type {Type}, Rating {Rating}", 
                userId, movieId, type, rating);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error tracking interaction");
            throw;
        }
    }
}

9. API Controllers & Endpoints {#section-9}

MovieRecommendation.API/Controllers/RecommendationsController.cs

using Microsoft.AspNetCore.Mvc;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Models;
using MovieRecommendation.Core.Services;

namespace MovieRecommendation.API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class RecommendationsController : ControllerBase
{
    private readonly IRecommendationEngine _recommendationEngine;
    private readonly ICollaborativeEngine _collaborativeEngine;
    private readonly ILogger<RecommendationsController> _logger;

    public RecommendationsController(
        IRecommendationEngine recommendationEngine,
        ICollaborativeEngine collaborativeEngine,
        ILogger<RecommendationsController> logger)
    {
        _recommendationEngine = recommendationEngine;
        _collaborativeEngine = collaborativeEngine;
        _logger = logger;
    }

    /// <summary>
    /// Get personalized movie recommendations for a user
    /// </summary>
    /// <param name="userId">User ID</param>
    /// <param name="limit">Number of recommendations (default: 10, max: 50)</param>
    /// <returns>List of recommended movies with scores</returns>
    [HttpGet("user/{userId}")]
    [ProducesResponseType(typeof(List<RecommendationResult>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
    public async Task<ActionResult<List<RecommendationResult>>> GetRecommendations(
        int userId,
        [FromQuery] int limit = 10)
    {
        if (userId <= 0)
            return BadRequest(new { error = "Invalid user ID" });

        if (limit <= 0 || limit > 50)
            return BadRequest(new { error = "Limit must be between 1 and 50" });

        try
        {
            var recommendations = await _recommendationEngine.GetRecommendations(userId, limit);
            return Ok(recommendations);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting recommendations for user {UserId}", userId);
            return StatusCode(500, new { error = "An error occurred while getting recommendations" });
        }
    }

    /// <summary>
    /// Track user interaction with a movie
    /// </summary>
    /// <param name="request">Interaction details</param>
    [HttpPost("track")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<IActionResult> TrackInteraction([FromBody] TrackInteractionRequest request)
    {
        if (request.UserId <= 0 || request.MovieId <= 0)
            return BadRequest(new { error = "Invalid user or movie ID" });

        if (request.Type == InteractionType.Rating && 
            (request.Rating < 1 || request.Rating > 5))
            return BadRequest(new { error = "Rating must be between 1 and 5" });

        try
        {
            await _recommendationEngine.TrackInteraction(
                request.UserId,
                request.MovieId,
                request.Type,
                request.Rating);

            return Ok(new { message = "Interaction tracked successfully" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error tracking interaction");
            return StatusCode(500, new { error = "An error occurred while tracking interaction" });
        }
    }

    /// <summary>
    /// Train the collaborative filtering ML model
    /// </summary>
    [HttpPost("train")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<IActionResult> TrainModel()
    {
        try
        {
            _logger.LogInformation("Manual model training triggered");
            var success = await _collaborativeEngine.TrainModelAsync();

            if (success)
                return Ok(new { message = "Model trained successfully" });
            else
                return BadRequest(new { error = "Model training failed - not enough data" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error training model");
            return StatusCode(500, new { error = "An error occurred while training model" });
        }
    }
}

public record TrackInteractionRequest(
    int UserId,
    int MovieId,
    InteractionType Type,
    double? Rating = null);

MovieRecommendation.API/Controllers/MoviesController.cs

using Microsoft.AspNetCore.Mvc;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Repositories;

namespace MovieRecommendation.API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class MoviesController : ControllerBase
{
    private readonly IMovieRepository _movieRepository;
    private readonly ILogger<MoviesController> _logger;

    public MoviesController(IMovieRepository movieRepository, ILogger<MoviesController> logger)
    {
        _movieRepository = movieRepository;
        _logger = logger;
    }

    /// <summary>
    /// Get all movies with pagination
    /// </summary>
    [HttpGet]
    [ProducesResponseType(typeof(List<Movie>), StatusCodes.Status200OK)]
    public async Task<ActionResult<List<Movie>>> GetMovies([FromQuery] int limit = 20)
    {
        if (limit <= 0 || limit > 100)
            return BadRequest(new { error = "Limit must be between 1 and 100" });

        var movies = await _movieRepository.GetAvailableMoviesAsync(limit);
        return Ok(movies);
    }

    /// <summary>
    /// Get a specific movie by ID
    /// </summary>
    [HttpGet("{id}")]
    [ProducesResponseType(typeof(Movie), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<Movie>> GetMovie(int id)
    {
        var movie = await _movieRepository.GetByIdAsync(id);
        if (movie == null)
            return NotFound(new { error = $"Movie with ID {id} not found" });

        return Ok(movie);
    }

    /// <summary>
    /// Get movies by genre
    /// </summary>
    [HttpGet("genre/{genre}")]
    [ProducesResponseType(typeof(List<Movie>), StatusCodes.Status200OK)]
    public async Task<ActionResult<List<Movie>>> GetMoviesByGenre(string genre, [FromQuery] int limit = 20)
    {
        var movies = await _movieRepository.GetMoviesByGenreAsync(genre, limit);
        return Ok(movies);
    }

    /// <summary>
    /// Create a new movie
    /// </summary>
    [HttpPost]
    [ProducesResponseType(typeof(Movie), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<Movie>> CreateMovie([FromBody] CreateMovieRequest request)
    {
        var movie = new Movie
        {
            Title = request.Title,
            Description = request.Description,
            Genres = request.Genres,
            Actors = request.Actors,
            Director = request.Director,
            ReleaseYear = request.ReleaseYear,
            DurationMinutes = request.DurationMinutes,
            AverageRating = 0,
            TotalRatings = 0
        };

        var created = await _movieRepository.AddAsync(movie);
        return CreatedAtAction(nameof(GetMovie), new { id = created.Id }, created);
    }
}

public record CreateMovieRequest(
    string Title,
    string Description,
    List<string> Genres,
    List<string> Actors,
    string Director,
    int ReleaseYear,
    int DurationMinutes);

MovieRecommendation.API/Controllers/UsersController.cs

using Microsoft.AspNetCore.Mvc;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Repositories;

namespace MovieRecommendation.API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserRepository _userRepository;
    private readonly ILogger<UsersController> _logger;

    public UsersController(IUserRepository userRepository, ILogger<UsersController> logger)
    {
        _userRepository = userRepository;
        _logger = logger;
    }

    /// <summary>
    /// Get user by ID
    /// </summary>
    [HttpGet("{id}")]
    [ProducesResponseType(typeof(User), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<User>> GetUser(int id)
    {
        var user = await _userRepository.GetByIdAsync(id);
        if (user == null)
            return NotFound(new { error = $"User with ID {id} not found" });

        return Ok(user);
    }

    /// <summary>
    /// Create a new user
    /// </summary>
    [HttpPost]
    [ProducesResponseType(typeof(User), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<User>> CreateUser([FromBody] CreateUserRequest request)
    {
        // Check if username exists
        var existingUser = await _userRepository.GetByUsernameAsync(request.Username);
        if (existingUser != null)
            return BadRequest(new { error = "Username already exists" });

        var user = new User
        {
            Username = request.Username,
            Email = request.Email,
            FavoriteGenres = request.FavoriteGenres ?? new List<string>(),
            FavoriteActors = request.FavoriteActors ?? new List<string>(),
            PreferredMinYear = request.PreferredMinYear,
            PreferredMaxYear = request.PreferredMaxYear,
            PreferredMinDuration = request.PreferredMinDuration,
            PreferredMaxDuration = request.PreferredMaxDuration
        };

        var created = await _userRepository.AddAsync(user);
        return CreatedAtAction(nameof(GetUser), new { id = created.Id }, created);
    }

    /// <summary>
    /// Update user preferences
    /// </summary>
    [HttpPut("{id}/preferences")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> UpdatePreferences(
        int id, 
        [FromBody] UpdatePreferencesRequest request)
    {
        var user = await _userRepository.GetByIdAsync(id);
        if (user == null)
            return NotFound(new { error = $"User with ID {id} not found" });

        user.FavoriteGenres = request.FavoriteGenres;
        user.FavoriteActors = request.FavoriteActors;
        user.PreferredMinYear = request.PreferredMinYear;
        user.PreferredMaxYear = request.PreferredMaxYear;
        user.PreferredMinDuration = request.PreferredMinDuration;
        user.PreferredMaxDuration = request.PreferredMaxDuration;

        await _userRepository.UpdateAsync(user);
        return NoContent();
    }
}

public record CreateUserRequest(
    string Username,
    string Email,
    List<string>? FavoriteGenres,
    List<string>? FavoriteActors,
    int PreferredMinYear,
    int PreferredMaxYear,
    int PreferredMinDuration,
    int PreferredMaxDuration);

public record UpdatePreferencesRequest(
    List<string> FavoriteGenres,
    List<string> FavoriteActors,
    int PreferredMinYear,
    int PreferredMaxYear,
    int PreferredMinDuration,
    int PreferredMaxDuration);

10. Configuration & Dependency Injection {#section-10}

MovieRecommendation.API/appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MovieRecommendation;Trusted_Connection=True;TrustServerCertificate=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "Microsoft.EntityFrameworkCore": "Warning",
      "MovieRecommendation": "Debug"
    }
  },
  "AllowedHosts": "*",
  "RecommendationSettings": {
    "DefaultLimit": 10,
    "MaxLimit": 50,
    "CacheExpirationHours": 24,
    "MinimumInteractionsForTraining": 100,
    "TrainingIntervalHours": 24
  },
  "Cors": {
    "AllowedOrigins": [
      "http://localhost:3000",
      "http://localhost:4200",
      "http://localhost:5173"
    ]
  }
}

MovieRecommendation.API/appsettings.Development.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MovieRecommendationDev;Trusted_Connection=True;TrustServerCertificate=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information",
      "Microsoft.EntityFrameworkCore": "Information"
    }
  }
}

MovieRecommendation.API/Program.cs (COMPLETE)

using Microsoft.EntityFrameworkCore;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Core.Services;
using MovieRecommendation.Infrastructure.Data;
using MovieRecommendation.Infrastructure.Repositories;
using MovieRecommendation.Infrastructure.Services;
using MovieRecommendation.API.Middleware;

var builder = WebApplication.CreateBuilder(args);

// ===== Add Services =====

// Controllers
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();

// Swagger/OpenAPI
builder.Services.AddSwaggerGen(options =>
{
    options.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
    {
        Title = "Movie Recommendation API",
        Version = "v1",
        Description = "AI-powered movie recommendation system using ML.NET and collaborative filtering",
        Contact = new Microsoft.OpenApi.Models.OpenApiContact
        {
            Name = "Your Name",
            Email = "your.email@example.com"
        }
    });

    // Include XML comments if available
    var xmlFile = $"{System.Reflection.Assembly.GetExecutingAssembly().GetName().Name}.xml";
    var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
    if (File.Exists(xmlPath))
    {
        options.IncludeXmlComments(xmlPath);
    }
});

// Database Context
builder.Services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection"),
        sqlOptions =>
        {
            sqlOptions.EnableRetryOnFailure(
                maxRetryCount: 5,
                maxRetryDelay: TimeSpan.FromSeconds(30),
                errorNumbersToAdd: null);
            sqlOptions.CommandTimeout(60);
        });
});

// Memory Cache
builder.Services.AddMemoryCache(options =>
{
    options.SizeLimit = 1024; // MB
    options.CompactionPercentage = 0.75;
});

// Logging
builder.Services.AddLogging(logging =>
{
    logging.ClearProviders();
    logging.AddConsole();
    logging.AddDebug();
    if (builder.Environment.IsDevelopment())
    {
        logging.SetMinimumLevel(LogLevel.Debug);
    }
});

// Register Repositories
builder.Services.AddScoped<IMovieRepository, MovieRepository>();
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<IInteractionRepository, InteractionRepository>();

// Register Recommendation Services
builder.Services.AddScoped<IContentBasedEngine, ContentBasedEngine>();
builder.Services.AddScoped<ICollaborativeEngine, CollaborativeEngine>();
builder.Services.AddScoped<IRecommendationEngine, RecommendationEngine>();

// Background Services
builder.Services.AddHostedService<ModelTrainingBackgroundService>();

// CORS
var allowedOrigins = builder.Configuration.GetSection("Cors:AllowedOrigins").Get<string[]>() 
    ?? new[] { "http://localhost:3000" };

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.WithOrigins(allowedOrigins)
              .AllowAnyMethod()
              .AllowAnyHeader()
              .AllowCredentials();
    });
});

// Health Checks
builder.Services.AddHealthChecks()
    .AddDbContextCheck<AppDbContext>("database");

// ===== Build App =====

var app = builder.Build();

// ===== Configure Middleware Pipeline =====

// Global Exception Handling
app.UseMiddleware<GlobalExceptionMiddleware>();

// Development-specific middleware
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "Movie Recommendation API v1");
        options.RoutePrefix = string.Empty; // Swagger at root
    });
    app.UseDeveloperExceptionPage();
}
else
{
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseCors();
app.UseAuthorization();

// Health check endpoint
app.MapHealthChecks("/health");

// Map controllers
app.MapControllers();

// ===== Database Initialization =====

using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;
    try
    {
        var context = services.GetRequiredService<AppDbContext>();
        var logger = services.GetRequiredService<ILogger<Program>>();

        logger.LogInformation("Applying database migrations...");
        await context.Database.MigrateAsync();

        if (app.Environment.IsDevelopment())
        {
            logger.LogInformation("Seeding database...");
            await DatabaseSeeder.SeedAsync(context, logger);
        }

        logger.LogInformation("Database initialization completed");
    }
    catch (Exception ex)
    {
        var logger = services.GetRequiredService<ILogger<Program>>();
        logger.LogError(ex, "An error occurred while initializing the database");
        throw;
    }
}

// ===== Run Application =====

app.Run();

11. Database Seeding & Test Data {#section-11}

MovieRecommendation.Infrastructure/Data/DatabaseSeeder.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using MovieRecommendation.Core.Entities;

namespace MovieRecommendation.Infrastructure.Data;

public static class DatabaseSeeder
{
    public static async Task SeedAsync(AppDbContext context, ILogger logger)
    {
        try
        {
            // Check if already seeded
            if (await context.Movies.AnyAsync())
            {
                logger.LogInformation("Database already seeded");
                return;
            }

            logger.LogInformation("Seeding movies...");
            await SeedMoviesAsync(context);

            logger.LogInformation("Seeding users...");
            await SeedUsersAsync(context);

            logger.LogInformation("Seeding interactions...");
            await SeedInteractionsAsync(context);

            logger.LogInformation("Database seeding completed successfully");
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error seeding database");
            throw;
        }
    }

    private static async Task SeedMoviesAsync(AppDbContext context)
    {
        var movies = new List<Movie>
        {
            new Movie
            {
                Title = "The Shawshank Redemption",
                Description = "Two imprisoned men bond over a number of years, finding solace and eventual redemption through acts of common decency.",
                Genres = new List<string> { "Drama" },
                Actors = new List<string> { "Tim Robbins", "Morgan Freeman", "Bob Gunton" },
                Director = "Frank Darabont",
                ReleaseYear = 1994,
                DurationMinutes = 142,
                AverageRating = 4.9,
                TotalRatings = 2500000,
                CreatedAt = DateTime.UtcNow.AddDays(-365)
            },
            new Movie
            {
                Title = "The Dark Knight",
                Description = "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, Batman must accept one of the greatest psychological tests.",
                Genres = new List<string> { "Action", "Crime", "Drama" },
                Actors = new List<string> { "Christian Bale", "Heath Ledger", "Aaron Eckhart" },
                Director = "Christopher Nolan",
                ReleaseYear = 2008,
                DurationMinutes = 152,
                AverageRating = 4.8,
                TotalRatings = 2300000,
                CreatedAt = DateTime.UtcNow.AddDays(-300)
            },
            new Movie
            {
                Title = "Inception",
                Description = "A thief who steals corporate secrets through the use of dream-sharing technology is given the inverse task of planting an idea.",
                Genres = new List<string> { "Sci-Fi", "Action", "Thriller" },
                Actors = new List<string> { "Leonardo DiCaprio", "Tom Hardy", "Ellen Page" },
                Director = "Christopher Nolan",
                ReleaseYear = 2010,
                DurationMinutes = 148,
                AverageRating = 4.7,
                TotalRatings = 2100000,
                CreatedAt = DateTime.UtcNow.AddDays(-250)
            },
            new Movie
            {
                Title = "The Godfather",
                Description = "The aging patriarch of an organized crime dynasty transfers control of his clandestine empire to his reluctant son.",
                Genres = new List<string> { "Crime", "Drama" },
                Actors = new List<string> { "Marlon Brando", "Al Pacino", "James Caan" },
                Director = "Francis Ford Coppola",
                ReleaseYear = 1972,
                DurationMinutes = 175,
                AverageRating = 4.9,
                TotalRatings = 1800000,
                CreatedAt = DateTime.UtcNow.AddDays(-400)
            },
            new Movie
            {
                Title = "Pulp Fiction",
                Description = "The lives of two mob hitmen, a boxer, a gangster and his wife intertwine in four tales of violence and redemption.",
                Genres = new List<string> { "Crime", "Drama" },
                Actors = new List<string> { "John Travolta", "Uma Thurman", "Samuel L. Jackson" },
                Director = "Quentin Tarantino",
                ReleaseYear = 1994,
                DurationMinutes = 154,
                AverageRating = 4.7,
                TotalRatings = 1900000,
                CreatedAt = DateTime.UtcNow.AddDays(-350)
            },
            new Movie
            {
                Title = "Forrest Gump",
                Description = "The presidencies of Kennedy and Johnson unfold through the perspective of an Alabama man with an IQ of 75.",
                Genres = new List<string> { "Drama", "Romance" },
                Actors = new List<string> { "Tom Hanks", "Robin Wright", "Gary Sinise" },
                Director = "Robert Zemeckis",
                ReleaseYear = 1994,
                DurationMinutes = 142,
                AverageRating = 4.6,
                TotalRatings = 1950000,
                CreatedAt = DateTime.UtcNow.AddDays(-330)
            },
            new Movie
            {
                Title = "The Matrix",
                Description = "A computer hacker learns from mysterious rebels about the true nature of his reality and his role in the war against its controllers.",
                Genres = new List<string> { "Sci-Fi", "Action" },
                Actors = new List<string> { "Keanu Reeves", "Laurence Fishburne", "Carrie-Anne Moss" },
                Director = "Lana Wachowski",
                ReleaseYear = 1999,
                DurationMinutes = 136,
                AverageRating = 4.6,
                TotalRatings = 1850000,
                CreatedAt = DateTime.UtcNow.AddDays(-280)
            },
            new Movie
            {
                Title = "Interstellar",
                Description = "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
                Genres = new List<string> { "Sci-Fi", "Drama", "Adventure" },
                Actors = new List<string> { "Matthew McConaughey", "Anne Hathaway", "Jessica Chastain" },
                Director = "Christopher Nolan",
                ReleaseYear = 2014,
                DurationMinutes = 169,
                AverageRating = 4.6,
                TotalRatings = 1700000,
                CreatedAt = DateTime.UtcNow.AddDays(-200)
            },
            new Movie
            {
                Title = "The Silence of the Lambs",
                Description = "A young FBI cadet must receive the help of an incarcerated cannibal killer to catch another serial killer.",
                Genres = new List<string> { "Thriller", "Crime", "Drama" },
                Actors = new List<string> { "Jodie Foster", "Anthony Hopkins", "Lawrence A. Bonney" },
                Director = "Jonathan Demme",
                ReleaseYear = 1991,
                DurationMinutes = 118,
                AverageRating = 4.6,
                TotalRatings = 1400000,
                CreatedAt = DateTime.UtcNow.AddDays(-380)
            },
            new Movie
            {
                Title = "The Green Mile",
                Description = "The lives of guards on Death Row are affected by one of their charges: a black man accused of child murder.",
                Genres = new List<string> { "Drama", "Fantasy" },
                Actors = new List<string> { "Tom Hanks", "Michael Clarke Duncan", "David Morse" },
                Director = "Frank Darabont",
                ReleaseYear = 1999,
                DurationMinutes = 189,
                AverageRating = 4.6,
                TotalRatings = 1300000,
                CreatedAt = DateTime.UtcNow.AddDays(-290)
            },
            // Add 10 more varied movies
            new Movie
            {
                Title = "The Avengers",
                Description = "Earth's mightiest heroes must come together to stop Loki and his alien army.",
                Genres = new List<string> { "Action", "Adventure", "Sci-Fi" },
                Actors = new List<string> { "Robert Downey Jr.", "Chris Evans", "Scarlett Johansson" },
                Director = "Joss Whedon",
                ReleaseYear = 2012,
                DurationMinutes = 143,
                AverageRating = 4.3,
                TotalRatings = 1600000,
                CreatedAt = DateTime.UtcNow.AddDays(-220)
            },
            new Movie
            {
                Title = "Titanic",
                Description = "A seventeen-year-old aristocrat falls in love with a kind but poor artist aboard the luxurious, ill-fated R.M.S. Titanic.",
                Genres = new List<string> { "Romance", "Drama" },
                Actors = new List<string> { "Leonardo DiCaprio", "Kate Winslet", "Billy Zane" },
                Director = "James Cameron",
                ReleaseYear = 1997,
                DurationMinutes = 194,
                AverageRating = 4.4,
                TotalRatings = 1100000,
                CreatedAt = DateTime.UtcNow.AddDays(-310)
            },
            new Movie
            {
                Title = "Gladiator",
                Description = "A former Roman General sets out to exact vengeance against the corrupt emperor who murdered his family.",
                Genres = new List<string> { "Action", "Drama", "Adventure" },
                Actors = new List<string> { "Russell Crowe", "Joaquin Phoenix", "Connie Nielsen" },
                Director = "Ridley Scott",
                ReleaseYear = 2000,
                DurationMinutes = 155,
                AverageRating = 4.5,
                TotalRatings = 1400000,
                CreatedAt = DateTime.UtcNow.AddDays(-270)
            },
            new Movie
            {
                Title = "The Departed",
                Description = "An undercover cop and a mole in the police attempt to identify each other while infiltrating an Irish gang in Boston.",
                Genres = new List<string> { "Crime", "Drama", "Thriller" },
                Actors = new List<string> { "Leonardo DiCaprio", "Matt Damon", "Jack Nicholson" },
                Director = "Martin Scorsese",
                ReleaseYear = 2006,
                DurationMinutes = 151,
                AverageRating = 4.5,
                TotalRatings = 1300000,
                CreatedAt = DateTime.UtcNow.AddDays(-260)
            },
            new Movie
            {
                Title = "The Prestige",
                Description = "After a tragic accident, two stage magicians engage in a battle to create the ultimate illusion.",
                Genres = new List<string> { "Drama", "Mystery", "Thriller" },
                Actors = new List<string> { "Christian Bale", "Hugh Jackman", "Scarlett Johansson" },
                Director = "Christopher Nolan",
                ReleaseYear = 2006,
                DurationMinutes = 130,
                AverageRating = 4.5,
                TotalRatings = 1200000,
                CreatedAt = DateTime.UtcNow.AddDays(-255)
            },
            new Movie
            {
                Title = "Django Unchained",
                Description = "With the help of a German bounty hunter, a freed slave sets out to rescue his wife from a brutal Mississippi plantation owner.",
                Genres = new List<string> { "Western", "Drama" },
                Actors = new List<string> { "Jamie Foxx", "Christoph Waltz", "Leonardo DiCaprio" },
                Director = "Quentin Tarantino",
                ReleaseYear = 2012,
                DurationMinutes = 165,
                AverageRating = 4.5,
                TotalRatings = 1400000,
                CreatedAt = DateTime.UtcNow.AddDays(-215)
            },
            new Movie
            {
                Title = "The Grand Budapest Hotel",
                Description = "A writer encounters the owner of an aging high-class hotel, who tells him of his early years.",
                Genres = new List<string> { "Comedy", "Drama", "Adventure" },
                Actors = new List<string> { "Ralph Fiennes", "F. Murray Abraham", "Mathieu Amalric" },
                Director = "Wes Anderson",
                ReleaseYear = 2014,
                DurationMinutes = 99,
                AverageRating = 4.4,
                TotalRatings = 850000,
                CreatedAt = DateTime.UtcNow.AddDays(-195)
            },
            new Movie
            {
                Title = "Mad Max: Fury Road",
                Description = "In a post-apocalyptic wasteland, a woman rebels against a tyrannical ruler in search for her homeland.",
                Genres = new List<string> { "Action", "Adventure", "Sci-Fi" },
                Actors = new List<string> { "Tom Hardy", "Charlize Theron", "Nicholas Hoult" },
                Director = "George Miller",
                ReleaseYear = 2015,
                DurationMinutes = 120,
                AverageRating = 4.5,
                TotalRatings = 950000,
                CreatedAt = DateTime.UtcNow.AddDays(-180)
            },
            new Movie
            {
                Title = "The Social Network",
                Description = "As Harvard student Mark Zuckerberg creates the social networking site Facebook.",
                Genres = new List<string> { "Biography", "Drama" },
                Actors = new List<string> { "Jesse Eisenberg", "Andrew Garfield", "Justin Timberlake" },
                Director = "David Fincher",
                ReleaseYear = 2010,
                DurationMinutes = 120,
                AverageRating = 4.4,
                TotalRatings = 680000,
                CreatedAt = DateTime.UtcNow.AddDays(-245)
            },
            new Movie
            {
                Title = "Whiplash",
                Description = "A promising young drummer enrolls at a cut-throat music conservatory where his dreams hang in the balance.",
                Genres = new List<string> { "Drama", "Music" },
                Actors = new List<string> { "Miles Teller", "J.K. Simmons", "Melissa Benoist" },
                Director = "Damien Chazelle",
                ReleaseYear = 2014,
                DurationMinutes = 106,
                AverageRating = 4.6,
                TotalRatings = 830000,
                CreatedAt = DateTime.UtcNow.AddDays(-190)
            }
        };

        await context.Movies.AddRangeAsync(movies);
        await context.SaveChangesAsync();
    }

    private static async Task SeedUsersAsync(AppDbContext context)
    {
        var users = new List<User>
        {
            new User
            {
                Username = "john_doe",
                Email = "john@example.com",
                FavoriteGenres = new List<string> { "Action", "Sci-Fi", "Thriller" },
                FavoriteActors = new List<string> { "Leonardo DiCaprio", "Christian Bale", "Tom Hardy" },
                PreferredMinYear = 2000,
                PreferredMaxYear = 2024,
                PreferredMinDuration = 90,
                PreferredMaxDuration = 180,
                CreatedAt = DateTime.UtcNow.AddDays(-180)
            },
            new User
            {
                Username = "jane_smith",
                Email = "jane@example.com",
                FavoriteGenres = new List<string> { "Drama", "Romance" },
                FavoriteActors = new List<string> { "Tom Hanks", "Morgan Freeman", "Kate Winslet" },
                PreferredMinYear = 1990,
                PreferredMaxYear = 2020,
                PreferredMinDuration = 100,
                PreferredMaxDuration = 200,
                CreatedAt = DateTime.UtcNow.AddDays(-150)
            },
            new User
            {
                Username = "mike_johnson",
                Email = "mike@example.com",
                FavoriteGenres = new List<string> { "Crime", "Thriller", "Drama" },
                FavoriteActors = new List<string> { "Al Pacino", "Robert De Niro", "Matt Damon" },
                PreferredMinYear = 1970,
                PreferredMaxYear = 2015,
                PreferredMinDuration = 120,
                PreferredMaxDuration = 180,
                CreatedAt = DateTime.UtcNow.AddDays(-120)
            },
            new User
            {
                Username = "sarah_williams",
                Email = "sarah@example.com",
                FavoriteGenres = new List<string> { "Comedy", "Adventure", "Drama" },
                FavoriteActors = new List<string> { "Tom Hanks", "Robin Williams", "Bill Murray" },
                PreferredMinYear = 1995,
                PreferredMaxYear = 2024,
                PreferredMinDuration = 90,
                PreferredMaxDuration = 150,
                CreatedAt = DateTime.UtcNow.AddDays(-90)
            },
            new User
            {
                Username = "alex_brown",
                Email = "alex@example.com",
                FavoriteGenres = new List<string> { "Sci-Fi", "Action", "Adventure" },
                FavoriteActors = new List<string> { "Keanu Reeves", "Matthew McConaughey", "Scarlett Johansson" },
                PreferredMinYear = 2000,
                PreferredMaxYear = 2024,
                PreferredMinDuration = 100,
                PreferredMaxDuration = 170,
                CreatedAt = DateTime.UtcNow.AddDays(-60)
            }
        };

        await context.Users.AddRangeAsync(users);
        await context.SaveChangesAsync();
    }

    private static async Task SeedInteractionsAsync(AppDbContext context)
    {
        var random = new Random(42); // Fixed seed for reproducibility
        var interactions = new List<UserInteraction>();

        // User 1 (John): Likes Action, Sci-Fi, Thriller
        interactions.AddRange(new[]
        {
            CreateInteraction(1, 2, InteractionType.Rating, 5.0, -30),  // The Dark Knight
            CreateInteraction(1, 3, InteractionType.Rating, 5.0, -28),  // Inception
            CreateInteraction(1, 7, InteractionType.Rating, 4.5, -25),  // The Matrix
            CreateInteraction(1, 8, InteractionType.Rating, 4.5, -20),  // Interstellar
            CreateInteraction(1, 11, InteractionType.Rating, 4.0, -15), // The Avengers
            CreateInteraction(1, 1, InteractionType.View, null, -10),
            CreateInteraction(1, 4, InteractionType.View, null, -8),
            CreateInteraction(1, 14, InteractionType.Rating, 4.5, -5), // The Departed
        });

        // User 2 (Jane): Likes Drama, Romance
        interactions.AddRange(new[]
        {
            CreateInteraction(2, 1, InteractionType.Rating, 5.0, -25),  // Shawshank
            CreateInteraction(2, 6, InteractionType.Rating, 5.0, -23),  // Forrest Gump
            CreateInteraction(2, 10, InteractionType.Rating, 4.5, -20), // The Green Mile
            CreateInteraction(2, 12, InteractionType.Rating, 4.0, -18), // Titanic
            CreateInteraction(2, 4, InteractionType.Rating, 4.5, -15),  // The Godfather
            CreateInteraction(2, 2, InteractionType.View, null, -10),
            CreateInteraction(2, 5, InteractionType.Rating, 4.0, -5),   // Pulp Fiction
        });

        // User 3 (Mike): Likes Crime, Thriller, Drama
        interactions.AddRange(new[]
        {
            CreateInteraction(3, 4, InteractionType.Rating, 5.0, -30),  // The Godfather
            CreateInteraction(3, 5, InteractionType.Rating, 5.0, -28),  // Pulp Fiction
            CreateInteraction(3, 2, InteractionType.Rating, 4.5, -25),  // The Dark Knight
            CreateInteraction(3, 9, InteractionType.Rating, 4.5, -22),  // Silence of the Lambs
            CreateInteraction(3, 14, InteractionType.Rating, 5.0, -18), // The Departed
            CreateInteraction(3, 1, InteractionType.Rating, 4.5, -15),  // Shawshank
            CreateInteraction(3, 15, InteractionType.Rating, 4.0, -10), // The Prestige
        });

        // User 4 (Sarah): Likes Comedy, Adventure, Drama
        interactions.AddRange(new[]
        {
            CreateInteraction(4, 6, InteractionType.Rating, 5.0, -28),  // Forrest Gump
            CreateInteraction(4, 1, InteractionType.Rating, 4.5, -25),  // Shawshank
            CreateInteraction(4, 17, InteractionType.Rating, 5.0, -20), // Grand Budapest Hotel
            CreateInteraction(4, 13, InteractionType.Rating, 4.0, -18), // Gladiator
            CreateInteraction(4, 10, InteractionType.Rating, 4.5, -15), // The Green Mile
            CreateInteraction(4, 12, InteractionType.View, null, -10),
        });

        // User 5 (Alex): Likes Sci-Fi, Action, Adventure
        interactions.AddRange(new[]
        {
            CreateInteraction(5, 7, InteractionType.Rating, 5.0, -30),  // The Matrix
            CreateInteraction(5, 3, InteractionType.Rating, 5.0, -27),  // Inception
            CreateInteraction(5, 8, InteractionType.Rating, 5.0, -24),  // Interstellar
            CreateInteraction(5, 11, InteractionType.Rating, 4.5, -20), // The Avengers
            CreateInteraction(5, 2, InteractionType.Rating, 4.5, -17),  // The Dark Knight
            CreateInteraction(5, 18, InteractionType.Rating, 4.5, -12), // Mad Max
            CreateInteraction(5, 13, InteractionType.Rating, 4.0, -8),  // Gladiator
        });

        // Add some random interactions for variety
        for (int i = 1; i <= 5; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                var movieId = random.Next(1, 21);
                var rating = 3.0 + (random.NextDouble() * 2.0); // 3.0 to 5.0
                var daysAgo = random.Next(1, 90);

                // Avoid duplicates
                if (!interactions.Any(x => x.UserId == i && x.MovieId == movieId))
                {
                    interactions.Add(CreateInteraction(i, movieId, InteractionType.Rating, rating, -daysAgo));
                }
            }
        }

        await context.UserInteractions.AddRangeAsync(interactions);
        await context.SaveChangesAsync();
    }

    private static UserInteraction CreateInteraction(
        int userId, 
        int movieId, 
        InteractionType type, 
        double? rating, 
        int daysAgo)
    {
        return new UserInteraction
        {
            UserId = userId,
            MovieId = movieId,
            Type = type,
            Rating = rating,
            Timestamp = DateTime.UtcNow.AddDays(daysAgo)
        };
    }
}

12. Error Handling & Middleware {#section-12}

MovieRecommendation.API/Middleware/GlobalExceptionMiddleware.cs

using System.Net;
using System.Text.Json;

namespace MovieRecommendation.API.Middleware;

public class GlobalExceptionMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<GlobalExceptionMiddleware> _logger;
    private readonly IHostEnvironment _environment;

    public GlobalExceptionMiddleware(
        RequestDelegate next,
        ILogger<GlobalExceptionMiddleware> _logger,
        IHostEnvironment environment)
    {
        _next = next;
        this._logger = _logger;
        _environment = environment;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An unhandled exception occurred: {Message}", ex.Message);
            await HandleExceptionAsync(context, ex);
        }
    }

    private Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

        var response = new
        {
            error = "An error occurred processing your request",
            message = _environment.IsDevelopment() ? exception.Message : "Internal server error",
            stackTrace = _environment.IsDevelopment() ? exception.StackTrace : null,
            timestamp = DateTime.UtcNow
        };

        var options = new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = _environment.IsDevelopment()
        };

        var json = JsonSerializer.Serialize(response, options);
        return context.Response.WriteAsync(json);
    }
}

MovieRecommendation.Infrastructure/Services/ModelTrainingBackgroundService.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using MovieRecommendation.Core.Services;

namespace MovieRecommendation.Infrastructure.Services;

public class ModelTrainingBackgroundService : BackgroundService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly ILogger<ModelTrainingBackgroundService> _logger;
    private readonly TimeSpan _trainingInterval = TimeSpan.FromHours(24);

    public ModelTrainingBackgroundService(
        IServiceProvider serviceProvider,
        ILogger<ModelTrainingBackgroundService> logger)
    {
        _serviceProvider = serviceProvider;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Model Training Background Service started");

        // Wait 1 minute before first training attempt
        await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                _logger.LogInformation("Starting scheduled model training...");

                using var scope = _serviceProvider.CreateScope();
                var collaborativeEngine = scope.ServiceProvider
                    .GetRequiredService<ICollaborativeEngine>();

                var success = await collaborativeEngine.TrainModelAsync();

                if (success)
                {
                    _logger.LogInformation("Scheduled model training completed successfully");
                }
                else
                {
                    _logger.LogWarning("Scheduled model training failed - not enough data");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in model training background service");
            }

            // Wait for next training interval
            await Task.Delay(_trainingInterval, stoppingToken);
        }

        _logger.LogInformation("Model Training Background Service stopped");
    }
}

13. Testing {#section-13}

MovieRecommendation.Tests/ContentBasedEngineTests.cs

using Xunit;
using Moq;
using Microsoft.Extensions.Logging;
using MovieRecommendation.Core.Entities;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Infrastructure.Services;

namespace MovieRecommendation.Tests;

public class ContentBasedEngineTests
{
    private readonly Mock<IMovieRepository> _mockMovieRepo;
    private readonly Mock<IUserRepository> _mockUserRepo;
    private readonly Mock<IInteractionRepository> _mockInteractionRepo;
    private readonly Mock<ILogger<ContentBasedEngine>> _mockLogger;
    private readonly ContentBasedEngine _engine;

    public ContentBasedEngineTests()
    {
        _mockMovieRepo = new Mock<IMovieRepository>();
        _mockUserRepo = new Mock<IUserRepository>();
        _mockInteractionRepo = new Mock<IInteractionRepository>();
        _mockLogger = new Mock<ILogger<ContentBasedEngine>>();

        _engine = new ContentBasedEngine(
            _mockMovieRepo.Object,
            _mockUserRepo.Object,
            _mockInteractionRepo.Object,
            _mockLogger.Object);
    }

    [Fact]
    public async Task CalculateSimilarityScore_ExactGenreMatch_ReturnsHighScore()
    {
        // Arrange
        var user = new User
        {
            Id = 1,
            FavoriteGenres = new List<string> { "Action", "Sci-Fi" },
            PreferredMinYear = 2000,
            PreferredMaxYear = 2024
        };

        var movie = new Movie
        {
            Id = 1,
            Genres = new List<string> { "Action", "Sci-Fi" },
            ReleaseYear = 2020,
            DurationMinutes = 120,
            AverageRating = 4.5
        };

        // Act
        var score = await _engine.CalculateSimilarityScore(user, movie);

        // Assert
        Assert.True(score > 0.7, $"Expected score > 0.7, got {score}");
    }

    [Fact]
    public async Task CalculateSimilarityScore_NoGenreMatch_ReturnsLowScore()
    {
        // Arrange
        var user = new User
        {
            Id = 1,
            FavoriteGenres = new List<string> { "Romance", "Comedy" },
            PreferredMinYear = 2000,
            PreferredMaxYear = 2024
        };

        var movie = new Movie
        {
            Id = 1,
            Genres = new List<string> { "Horror", "Thriller" },
            ReleaseYear = 2020,
            DurationMinutes = 120,
            AverageRating = 4.5
        };

        // Act
        var score = await _engine.CalculateSimilarityScore(user, movie);

        // Assert
        Assert.True(score < 0.5, $"Expected score < 0.5, got {score}");
    }

    [Fact]
    public async Task GetContentBasedRecommendations_ReturnsLimitedResults()
    {
        // Arrange
        var userId = 1;
        var limit = 5;

        var user = new User
        {
            Id = userId,
            FavoriteGenres = new List<string> { "Action" }
        };

        var movies = Enumerable.Range(1, 10).Select(i => new Movie
        {
            Id = i,
            Title = $"Movie {i}",
            Genres = new List<string> { "Action" },
            ReleaseYear = 2020,
            DurationMinutes = 120,
            AverageRating = 4.0
        }).ToList();

        _mockUserRepo.Setup(r => r.GetByIdAsync(userId))
            .ReturnsAsync(user);
        _mockInteractionRepo.Setup(r => r.GetUserInteractionsAsync(userId))
            .ReturnsAsync(new List<UserInteraction>());
        _mockMovieRepo.Setup(r => r.GetAvailableMoviesAsync(It.IsAny<int>()))
            .ReturnsAsync(movies);

        // Act
        var recommendations = await _engine.GetContentBasedRecommendations(userId, limit);

        // Assert
        Assert.NotNull(recommendations);
        Assert.True(recommendations.Count <= limit);
    }
}

MovieRecommendation.Tests/RecommendationEngineTests.cs

using Xunit;
using Moq;
using Microsoft.Extensions.Logging;
using MovieRecommendation.Core.Models;
using MovieRecommendation.Core.Repositories;
using MovieRecommendation.Core.Services;
using MovieRecommendation.Infrastructure.Services;

namespace MovieRecommendation.Tests;

public class RecommendationEngineTests
{
    [Fact]
    public async Task GetRecommendations_CombinesBothEngines()
    {
        // Arrange
        var mockContentEngine = new Mock<IContentBasedEngine>();
        var mockCollaborativeEngine = new Mock<ICollaborativeEngine>();
        var mockMovieRepo = new Mock<IMovieRepository>();
        var mockInteractionRepo = new Mock<IInteractionRepository>();
        var mockLogger = new Mock<ILogger<RecommendationEngine>>();

        var contentResults = new List<RecommendationResult>
        {
            new RecommendationResult { MovieId = 1, ContentScore = 0.9 },
            new RecommendationResult { MovieId = 2, ContentScore = 0.8 }
        };

        var collaborativeResults = new List<RecommendationResult>
        {
            new RecommendationResult { MovieId = 1, CollaborativeScore = 0.85 },
            new RecommendationResult { MovieId = 3, CollaborativeScore = 0.75 }
        };

        mockContentEngine.Setup(e => e.GetContentBasedRecommendations(It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync(contentResults);
        mockCollaborativeEngine.Setup(e => e.GetCollaborativeRecommendations(It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync(collaborativeResults);

        var engine = new RecommendationEngine(
            mockContentEngine.Object,
            mockCollaborativeEngine.Object,
            mockMovieRepo.Object,
            mockInteractionRepo.Object,
            mockLogger.Object);

        // Act
        var recommendations = await engine.GetRecommendations(1, 10);

        // Assert
        Assert.NotNull(recommendations);
        mockContentEngine.Verify(e => e.GetContentBasedRecommendations(1, 30), Times.Once);
        mockCollaborativeEngine.Verify(e => e.GetCollaborativeRecommendations(1, 30), Times.Once);
    }
}

14. Docker & Deployment {#section-14}

Dockerfile

# Build stage
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

# Copy project files
COPY ["MovieRecommendation.API/MovieRecommendation.API.csproj", "MovieRecommendation.API/"]
COPY ["MovieRecommendation.Core/MovieRecommendation.Core.csproj", "MovieRecommendation.Core/"]
COPY ["MovieRecommendation.Infrastructure/MovieRecommendation.Infrastructure.csproj", "MovieRecommendation.Infrastructure/"]

# Restore dependencies
RUN dotnet restore "MovieRecommendation.API/MovieRecommendation.API.csproj"

# Copy everything else
COPY . .

# Build
WORKDIR "/src/MovieRecommendation.API"
RUN dotnet build "MovieRecommendation.API.csproj" -c Release -o /app/build

# Publish
FROM build AS publish
RUN dotnet publish "MovieRecommendation.API.csproj" -c Release -o /app/publish /p:UseAppHost=false

# Runtime stage
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
EXPOSE 80
EXPOSE 443

COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MovieRecommendation.API.dll"]

docker-compose.yml

version: '3.8'

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: movie-recommendation-api
    ports:
      - "5000:80"
      - "5001:443"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ASPNETCORE_URLS=http://+:80
      - ConnectionStrings__DefaultConnection=Server=db;Database=MovieRecommendation;User=sa;Password=YourStrong@Passw0rd123;TrustServerCertificate=True;MultipleActiveResultSets=true
    depends_on:
      - db
    networks:
      - movie-network
    restart: unless-stopped

  db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    container_name: movie-recommendation-db
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=YourStrong@Passw0rd123
      - MSSQL_PID=Express
    ports:
      - "1433:1433"
    volumes:
      - sqldata:/var/opt/mssql
    networks:
      - movie-network
    restart: unless-stopped
    healthcheck:
      test: /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P YourStrong@Passw0rd123 -Q "SELECT 1" || exit 1
      interval: 10s
      timeout: 3s
      retries: 10
      start_period: 10s

networks:
  movie-network:
    driver: bridge

volumes:
  sqldata:
    driver: local

.dockerignore

**/.dockerignore
**/.env
**/.git
**/.gitignore
**/.vs
**/.vscode
**/*.*proj.user
**/*.dbmdl
**/*.jfm
**/bin
**/charts
**/docker-compose*
**/compose*
**/Dockerfile*
**/node_modules
**/npm-debug.log
**/obj
**/secrets.dev.yaml
**/values.dev.yaml
README.md

15. Running the Application {#section-15}

Prerequisites

.NET 8.0 SDK installed
SQL Server or Docker
Visual Studio 2022 / VS Code / Rider

Option 1: Run Locally (Without Docker)

Step 1: Update Connection String

Edit appsettings.Development.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MovieRecommendationDev;Trusted_Connection=True;TrustServerCertificate=True"
  }
}

Step 2: Create Database & Apply Migrations

# Navigate to API project
cd MovieRecommendation.API

# Add migration
dotnet ef migrations add InitialCreate --project ../MovieRecommendation.Infrastructure --startup-project .

# Update database
dotnet ef database update --project ../MovieRecommendation.Infrastructure --startup-project .

Step 3: Run the Application

dotnet run

The API will be available at:

HTTP: http://localhost:5000
HTTPS: https://localhost:5001
Swagger UI: http://localhost:5000 (root)

Option 2: Run with Docker

# Build and start containers
docker-compose up -d

# View logs
docker-compose logs -f api

# Stop containers
docker-compose down

The API will be available at:

HTTP: http://localhost:5000

Testing the API

1. Create a User:

curl -X POST "http://localhost:5000/api/users" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "testuser",
    "email": "test@example.com",
    "favoriteGenres": ["Action", "Sci-Fi"],
    "favoriteActors": ["Leonardo DiCaprio"],
    "preferredMinYear": 2000,
    "preferredMaxYear": 2024,
    "preferredMinDuration": 90,
    "preferredMaxDuration": 180
  }'

2. Get Recommendations:

curl "http://localhost:5000/api/recommendations/user/1?limit=10"

3. Track Interaction:

curl -X POST "http://localhost:5000/api/recommendations/track" \
  -H "Content-Type: application/json" \
  -d '{
    "userId": 1,
    "movieId": 2,
    "type": "Rating",
    "rating": 5.0
  }'

4. Train ML Model:

curl -X POST "http://localhost:5000/api/recommendations/train"

5. Get Movies:

curl "http://localhost:5000/api/movies?limit=20"

Sample Response

[
  {
    "movieId": 3,
    "title": "Inception",
    "overallScore": 0.89,
    "contentScore": 0.92,
    "collaborativeScore": 0.85,
    "popularityScore": 0.91,
    "detailedScores": {
      "Genre": 0.95,
      "Actor": 0.88,
      "Year": 1.0,
      "Duration": 0.90,
      "Rating": 0.94
    },
    "reasonForRecommendation": "Recommended because it matches your preferences, in your favorite genre, and features your favorite actors",
    "generatedAt": "2024-01-15T10:30:00Z"
  }
]

🎉 COMPLETE! What You've Built

✅ Features Implemented:

Content-Based Filtering
- Genre matching with Jaccard similarity
- Actor preference matching
- Year and duration compatibility
- Multi-factor weighted scoring
Collaborative Filtering
- ML.NET matrix factorization
- User behavior pattern recognition
- Rating prediction
- Automated model training
Hybrid Recommendation
- Combines multiple strategies
- Configurable weights
- Popularity and recency factors
- Human-readable explanations
Production-Ready Infrastructure
- Clean architecture (Core/Infrastructure/API)
- Repository pattern
- Dependency injection
- Error handling middleware
- Background services
- Database seeding
- Health checks
API Features
- RESTful endpoints
- Swagger documentation
- Input validation
- CORS support
- Logging
DevOps
- Docker support
- docker-compose for local development
- Database migrations
- Unit tests

📈 Next Steps & Enhancements

Phase 2 Improvements:

Add authentication (JWT/OAuth)
Implement Redis caching
Add rate limiting
Create admin dashboard
Add user feedback collection
Implement A/B testing framework

Phase 3 Advanced Features:

Deep learning models (neural collaborative filtering)
Image-based recommendations
Natural language search
Real-time recommendations with SignalR
Multi-armed bandit algorithms
Contextual recommendations (time, location, device)

🔗 Resources

📝 Summary

You now have a complete, production-ready AI recommendation system with:

✅ 2 recommendation strategies (content + collaborative)
✅ ML.NET integration for machine learning
✅ Clean architecture with separation of concerns
✅ Full CRUD API with Swagger docs
✅ Database with EF Core
✅ Docker containerization
✅ Unit tests
✅ Background ML model training
✅ 20+ sample movies and test data

The system is ready to run, test, and extend! 🚀

💬 Questions? Issues? Improvements?

I'd love to hear your thoughts and feedback!

🔗 Connect with me on LinkedIn: HAMZA ZERYOUH

Whether you have questions about the implementation, suggestions for improvements, or want to share your own ML.NET experiences – feel free to reach out!

📧 Let's discuss:

How you're using ML.NET in production
Challenges you faced with recommendation systems
Ideas for Part 2 of this tutorial

Found this helpful? Don't forget to:

⭐ Star the repository (if you create one)
🔄 Share this article with your network
💬 Drop a comment with your experience

#dotnet #machinelearning #mlnet #ai #tutorial #recommendations #cleanarchitecture

Building a Production-Ready AI Recommendation Engine: A Deep Dive into ML.NET Implementation

hamza zeryouh — Thu, 04 Sep 2025 18:34:51 +0000

How I built a hybrid recommendation system that achieves 87% accuracy for a rental marketplace platform

The Challenge
Architecture Overview
Core Algorithms & Implementation
Trust Scoring System
Performance & Reliability
Frontend Integration
Results & Metrics
Code Examples
Lessons Learned
Future Enhancements

The Challenge

When building Goorfa, a rental marketplace platform, I faced a critical challenge: how do you help users find the perfect room and roommate matches in a sea of listings? Traditional search and filter approaches weren't enough - users needed intelligent, personalized recommendations that could understand their preferences and predict what they'd actually like.

The platform needed to handle:

Room recommendations based on budget, location, amenities, and preferences
Roommate matching considering lifestyle compatibility, age preferences, and social factors
Trust scoring to ensure user safety and reliability
Real-time learning from user interactions
High availability with graceful degradation

Architecture Overview

I implemented a hybrid recommendation system using ML.NET that combines multiple AI approaches:

graph TB
    A[User Request] --> B[Recommendation Engine]
    B --> C[Content-Based Filtering]
    B --> D[Collaborative Filtering]
    B --> E[Trust Scoring]
    B --> F[Compatibility Scoring]

    C --> G[Hybrid Score Combination]
    D --> G
    E --> G
    F --> G

    G --> H[Ranked Recommendations]
    H --> I[Fallback Strategy]
    I --> J[Response to User]

    K[User Interactions] --> L[ML Model Training]
    L --> D

Technology Stack

Backend: .NET 9, ML.NET, Entity Framework Core
Frontend: Angular 17, TypeScript, RxJS
Database: SQL Server with optimized indexing
Caching: In-memory caching with Redis
Architecture: Clean Architecture with CQRS pattern

Core Algorithms & Implementation

1. Content-Based Filtering

The content-based algorithm matches users with rooms/roommates based on attribute similarity:

public async Task<IEnumerable<RecommendationResult>> GetRoomRecommendations(
    string userId, 
    int limit = 10, 
    RecommendationWeights? weights = null)
{
    var user = await _userRepository.GetByIdAsync(userId);
    var rooms = await _roomRepository.GetAvailableRoomsAsync(limit * 3);

    foreach (var room in rooms)
    {
        var recommendationResult = new RecommendationResult
        {
            ItemId = room.Id.ToString(),
            ItemType = "Room"
        };

        // Content-based score calculation
        var contentScore = await GetContentBasedScore(userId, room.Id.ToString());
        recommendationResult.ContentBasedScore = contentScore;

        // Trust score integration
        var trustScore = await _trustScoreService.CalculateRoomTrustScore(room.UserId, room.Id.ToString());
        recommendationResult.TrustScore = trustScore;

        // Calculate overall score
        recommendationResult.OverallScore = 
            (contentScore * weights.ContentBasedWeight) +
            (trustScore * weights.TrustWeight);
    }

    return recommendations.OrderByDescending(r => r.OverallScore).Take(limit);
}

2. Mathematical Formulas

Room Matching Formula:

ContentScore = (BudgetScore × 0.25) + (LocationScore × 0.25) + 
               (PropertyTypeScore × 0.15) + (AmenityScore × 0.15) + 
               (RoomTypeScore × 0.10) + (AvailabilityScore × 0.10)

Budget Score Calculation:

private float CalculateBudgetScore(Domain.Entities.User user, Domain.Entities.Room room)
{
    if (!user.BudgetMin.HasValue || !user.BudgetMax.HasValue)
        return 0.5f; // Neutral if no budget specified

    var roomPrice = room.RentAmount;

    if (roomPrice >= user.BudgetMin && roomPrice <= user.BudgetMax)
        return 1.0f; // Perfect match

    // Calculate how far outside the budget with 20% tolerance
    if (roomPrice < user.BudgetMin)
    {
        var difference = user.BudgetMin.Value - roomPrice;
        var tolerance = user.BudgetMin.Value * 0.2m; // 20% tolerance
        return Math.Max(0.0f, 1.0f - (float)(difference / tolerance));
    }
    else
    {
        var difference = roomPrice - user.BudgetMax.Value;
        var tolerance = user.BudgetMax.Value * 0.2m; // 20% tolerance
        return Math.Max(0.0f, 1.0f - (float)(difference / tolerance));
    }
}

Roommate Compatibility Formula:

CompatibilityScore = (LifestyleScore × 0.30) + (AgeScore × 0.20) + 
                     (GenderScore × 0.15) + (ScheduleScore × 0.15) + 
                     (HobbyScore × 0.10) + (CleanlinessScore × 0.10)

3. Collaborative Filtering with ML.NET

I implemented Matrix Factorization using ML.NET for collaborative filtering:

public async Task<bool> TrainCollaborativeModel(IEnumerable<RoomUserInteraction> interactions)
{
    try
    {
        var dataView = _mlContext.Data.LoadFromEnumerable(interactions);

        var options = new MatrixFactorizationTrainer.Options
        {
            MatrixColumnIndexColumnName = "UserId",
            MatrixRowIndexColumnName = "RoomId",
            LabelColumnName = "Rating",
            NumberOfIterations = 20,
            ApproximationRank = 100,
            LearningRate = 0.1,
            Quiet = true
        };

        var pipeline = _mlContext.Recommendation().Trainers.MatrixFactorization(options);
        _collaborativeModel = pipeline.Fit(dataView);

        // Cache the trained model for 24 hours
        _cache.Set(ModelCacheKey, _collaborativeModel, ModelCacheExpiration);

        return true;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to train collaborative model");
        return false;
    }
}

Implicit Rating System:

Book: 5.0 (highest engagement)
Contact: 4.0 (strong interest)
Save: 3.0 (moderate interest)
Share: 3.5 (social validation)
View: 2.0 (basic interest)

4. Cosine Similarity for User Matching

For roommate recommendations, I use cosine similarity to find users with similar preferences:

private float CalculateCosineSimilarity(float[] vector1, float[] vector2)
{
    if (vector1.Length != vector2.Length)
        return 0.0f;

    double dotProduct = 0.0;
    double norm1 = 0.0;
    double norm2 = 0.0;

    for (int i = 0; i < vector1.Length; i++)
    {
        dotProduct += vector1[i] * vector2[i];
        norm1 += vector1[i] * vector1[i];
        norm2 += vector2[i] * vector2[i];
    }

    if (norm1 == 0.0 || norm2 == 0.0)
        return 0.0f;

    return (float)(dotProduct / (Math.Sqrt(norm1) * Math.Sqrt(norm2)));
}

Trust Scoring System

The trust scoring system is crucial for user safety in a rental marketplace. I implemented a multi-factor approach:

Trust Score Calculation

public async Task<float> CalculateDynamicTrustScoreAsync(string userId)
{
    var factors = await GetEnhancedTrustFactorsAsync(userId);
    var breakdown = await CalculateTrustScoreBreakdownAsync(factors);

    return breakdown.OverallScore;
}

private async Task<TrustScoreBreakdown> CalculateTrustScoreBreakdownAsync(EnhancedTrustScoreFactors factors)
{
    var breakdown = new TrustScoreBreakdown();

    // Verification Score (40%)
    breakdown.VerificationScore = CalculateEnhancedVerificationScore(factors);
    breakdown.VerificationWeight = 0.4f;

    // Rating Score (25%)
    breakdown.RatingScore = CalculateEnhancedRatingScore(factors);
    breakdown.RatingWeight = 0.25f;

    // Activity Score (20%)
    breakdown.ActivityScore = CalculateEnhancedActivityScore(factors);
    breakdown.ActivityWeight = 0.2f;

    // History Score (15%)
    breakdown.HistoryScore = CalculateEnhancedHistoryScore(factors);
    breakdown.HistoryWeight = 0.15f;

    // Calculate overall score
    breakdown.OverallScore = 
        (breakdown.VerificationScore * breakdown.VerificationWeight) +
        (breakdown.RatingScore * breakdown.RatingWeight) +
        (breakdown.ActivityScore * breakdown.ActivityWeight) +
        (breakdown.HistoryScore * breakdown.HistoryWeight);

    return breakdown;
}

Verification Factors

private float CalculateEnhancedVerificationScore(EnhancedTrustScoreFactors factors)
{
    float score = 0.0f;

    // Email verification (required)
    if (factors.IsEmailVerified) score += 0.25f;

    // Phone verification
    if (factors.IsPhoneVerified) score += 0.20f;

    // Photo verification
    if (factors.IsPhotoVerified) score += 0.20f;

    // Identity verification (highest weight)
    if (factors.IsIdentityVerified) score += 0.30f;

    // Agency verification bonus
    if (factors.IsAgencyVerified) score += 0.05f;

    return Math.Min(1.0f, score);
}

Performance & Reliability

1. Intelligent Caching Strategy

// Caching configuration
private readonly TimeSpan ModelCacheExpiration = TimeSpan.FromHours(24);
private readonly TimeSpan TrustScoreCacheExpiration = TimeSpan.FromHours(6);
private readonly TimeSpan UserInteractionCacheExpiration = TimeSpan.FromMinutes(30);

2. 4-Level Fallback System

I implemented a comprehensive fallback strategy to ensure 99.9% uptime:

private executeFallbackStrategy(
  request: RecommendationRequest, 
  originalError: any
): Observable<RecommendationResponse> {
  this.fallbackModeSubject.next(true);

  // Fallback 1: Content-based recommendations only
  return this.getContentBasedRecommendations(request)
    .pipe(
      catchError(error => {
        // Fallback 2: Popular items
        return this.getPopularItems(request)
          .pipe(
            catchError(error => {
              // Fallback 3: Cached results
              return this.getCachedRecommendations()
                .pipe(
                  catchError(error => {
                    // Final fallback: Empty response with helpful message
                    return this.getEmptyFallback(originalError);
                  })
                );
            })
          );
      })
    );
}

3. Performance Optimizations

Parallel Processing: Multiple recommendations calculated simultaneously
Pre-filtering: Geographic and availability filtering before ML processing
Connection Pooling: Optimized database connections
Memory Management: Efficient ML.NET model lifecycle

Frontend Integration

Enhanced Recommendation Service

@Injectable({
  providedIn: 'root'
})
export class EnhancedRecommendationService {
  private readonly fallbackTimeout = 5000; // 5 seconds
  private readonly maxRetries = 2;

  getRecommendations(request: RecommendationRequest): Observable<RecommendationResponse> {
    this.loadingSubject.next(true);
    this.fallbackModeSubject.next(false);

    const currentUserId = this.authService.getCurrentUserId();
    if (!currentUserId) {
      return this.getUnauthenticatedFallback();
    }

    return this.getRecommendationsWithFallback(request, currentUserId);
  }

  private getRecommendationsWithFallback(
    request: RecommendationRequest, 
    userId: string
  ): Observable<RecommendationResponse> {
    return this.http.get<ApiResponse<RecommendationResponse>>(`${this.baseUrl}`, {
      params: this.buildParams(request, userId)
    })
    .pipe(
      timeout(this.fallbackTimeout),
      retry(this.maxRetries),
      map(response => {
        this.loadingSubject.next(false);
        this.fallbackModeSubject.next(false);

        const recommendations = response.data;
        this.recommendationsSubject.next(recommendations);
        return recommendations;
      }),
      catchError(error => {
        console.warn('⚠️ Primary recommendation service failed, trying fallbacks:', error);
        return this.executeFallbackStrategy(request, error);
      })
    );
  }
}

Interaction Tracking

trackInteraction(itemId: string, type: 'view' | 'save' | 'contact' | 'book', rating?: number): void {
  const userId = this.authService.getCurrentUserId();
  if (!userId) return;

  this.http.post('/api/v1/interactions/track', {
    userId,
    itemId,
    type,
    rating,
    timestamp: new Date().toISOString()
  }).subscribe({
    next: () => console.log('✅ Interaction tracked successfully'),
    error: (error) => console.warn('⚠️ Failed to track interaction:', error)
  });
}

Results & Metrics

Performance Improvements

Metric	Before	After	Improvement
Response Time	2-5 seconds	<1 second	80% faster
Uptime	95%	99.9%	4.9% improvement
Cache Hit Rate	60%	85%	25% improvement
Error Recovery	Basic	4-level fallback	100% improvement
User Engagement	45%	73%	28% improvement
Match Accuracy	65%	87%	22% improvement

Business Impact

87% recommendation accuracy - Users find relevant matches
73% higher engagement - Users interact more with recommendations
45% faster booking process - Reduced time to find and book rooms
Enhanced user trust - Advanced verification and scoring system

Code Examples

API Endpoint Implementation

[HttpGet("/api/v1/recommendations")]
public async Task<IActionResult> GetRecommendations(
    [FromQuery] string userId,
    [FromQuery] RecommendationType type = RecommendationType.Both,
    [FromQuery] int roomLimit = 10,
    [FromQuery] int roommateLimit = 10,
    [FromQuery] bool includeDetailedScores = true,
    [FromQuery] bool includeReasons = true)
{
    var request = new GetRecommendationsQuery
    {
        UserId = userId,
        Type = type,
        RoomLimit = roomLimit,
        RoommateLimit = roommateLimit,
        IncludeDetailedScores = includeDetailedScores,
        IncludeReasons = includeReasons
    };

    var result = await _mediator.Send(request);

    if (result.IsSuccess)
    {
        return Ok(ApiResponse<RecommendationResponse>.SuccessResult(
            result.Value, 
            "Recommendations retrieved successfully"));
    }

    return BadRequest(ApiResponse<RecommendationResponse>.ErrorResult(
        result.Error, 
        "Failed to retrieve recommendations"));
}

Custom Recommendation Weights

// Room search optimized weights
var roomWeights = new RecommendationWeights
{
    ContentBasedWeight = 0.35f,
    CollaborativeWeight = 0.25f,
    TrustWeight = 0.15f,
    LocationWeight = 0.15f,
    PriceWeight = 0.10f
};

// Roommate matching optimized weights
var roommateWeights = new RecommendationWeights
{
    ContentBasedWeight = 0.20f,
    CollaborativeWeight = 0.20f,
    TrustWeight = 0.25f,
    LocationWeight = 0.10f,
    PriceWeight = 0.05f,
    CompatibilityWeight = 0.20f
};

Lessons Learned

1. Hybrid Approach is Key

Relying on a single algorithm (content-based or collaborative) wasn't sufficient. The hybrid approach provides better coverage and accuracy.

2. Trust Scoring is Critical

In a marketplace, user safety is paramount. The trust scoring system significantly improved user confidence and platform reliability.

3. Fallback Strategies are Essential

ML services can fail. Having multiple fallback levels ensures the platform remains functional even when the AI components are unavailable.

4. Real-time Learning Matters

Tracking user interactions and continuously improving the model leads to better recommendations over time.

5. Performance Optimization is Ongoing

Caching, parallel processing, and database optimization are crucial for handling scale.

Future Enhancements

Phase 2 (Next 3 months)

Deep Learning Models: Neural collaborative filtering
NLP Integration: Description text analysis for better matching
Image Analysis: Room photo quality assessment
Real-time Learning: Online model updates without downtime

Phase 3 (Next 6 months)

Multi-armed Bandit: Exploration vs exploitation optimization
Graph Neural Networks: Social network analysis for roommate matching
Seasonal Patterns: Time-based recommendations
Price Prediction: Dynamic pricing suggestions

Conclusion

Building a production-ready AI recommendation system requires more than just implementing algorithms. It requires:

Robust architecture with proper separation of concerns
Comprehensive testing and monitoring
Performance optimization for scale
User safety through trust scoring
Reliability through fallback strategies
Continuous improvement through real-time learning

The result is a system that doesn't just show listings - it understands what users want and helps them find it, while maintaining high performance and reliability.

Key Technologies Used:

ML.NET for machine learning
.NET 9 for backend services
Angular 17 for frontend
Entity Framework Core for data access
Clean Architecture principles

The system is now handling thousands of recommendations daily with 99.9% uptime and 87% accuracy. The hybrid approach ensures we're not just relying on one algorithm - we're combining the best of content-based filtering, collaborative filtering, and trust scoring to deliver recommendations users can actually trust and act on.

What challenges have you faced building recommendation systems? I'd love to hear about your experiences in the comments below!

Tags: #MachineLearning #MLNET #RecommendationEngine #DotNet #Angular #PropTech #AI #SoftwareDevelopment

C# Language Trick – Pattern Matching

hamza zeryouh — Sat, 09 Aug 2025 12:39:02 +0000

🔥 This C# 9+ feature can replace multiple if statements

Instead of:

if (shape is Circle c) { /* ... */ }
else if (shape is Rectangle r) { /* ... */ }
else if (shape is Triangle t) { /* ... */ }

Do this:

var area = shape switch
{
    Circle c => Math.PI * c.Radius * c.Radius,
    Rectangle r => r.Width * r.Height,
    Triangle t => t.Base * t.Height / 2,
    _ => throw new ArgumentException("Unknown shape")
};

Benefits:

More readable
Safer (compiler checks exhaustiveness)
Easier to maintain

What’s your favorite modern C# feature?

🧠Stack vs Heap in C# (.NET Core) – Complete Guide with Examples

hamza zeryouh — Sat, 09 Aug 2025 12:35:55 +0000

Memory in C# (and .NET Core) is divided into two key regions: Stack and Heap. Both are essential for memory management, but they serve different purposes and behave differently. Understanding how they work helps you write faster and more reliable applications.

🔷 The Stack in C

The Stack is a memory region used to store:

Value types (int, bool, struct, etc.)
Local variables
Method call data (like parameters and return addresses)

It's called a "stack" because it works like a stack of plates - the last item pushed is the first one popped. Once a method ends, all its stack-allocated memory is cleaned up automatically.

✅ Key Characteristics

Automatic cleanup after method execution
Fast access due to LIFO structure
Limited size (typically 1MB per thread)
Stores value types and method data
No memory leaks or manual management

💡 Stack Memory Example

void UseStack()
{
    int a = 10;       // Stored on the stack
    int b = 20;       // Also on the stack
    int result = a + b;
    Console.WriteLine(result); // Output: 30
}

Here, all variables (a, b, result) are value types, so they are allocated on the stack. When the method finishes, this memory is automatically freed.

🔶 The Heap in C

The Heap is a region of memory used for dynamic memory allocation. It's where reference types (objects, arrays, classes) live. Heap memory is managed by the Garbage Collector (GC) in .NET Core, which frees unused objects automatically.

✅ Key Characteristics

Used for reference types (classes, arrays, etc.)
Garbage collected, not cleaned up immediately
Slower access due to pointer dereferencing
Flexible size, can grow at runtime
Allows objects to live beyond method scope

💡 Heap Memory Example

class Person
{
    public string Name;
}

void UseHeap()
{
    Person p = new Person();  // Allocated on the heap
    p.Name = "Alice";
    Console.WriteLine(p.Name);  // Output: Alice
}

In this case:

p is a reference stored on the stack.
The actual Person object is stored on the heap.

The GC eventually frees the heap memory once there are no more references to the object.

🔄 Comparison Table: Stack vs Heap in C

Feature	Stack	Heap
Memory Management	Automatic on method exit	Automatic via Garbage Collector
Type Stored	Value types (`int`, `struct`)	Reference types (`class`, `array`)
Access Speed	Very fast	Slower due to indirection
Lifetime	Scoped to function/method	Lives as long as references exist
Size Limit	Fixed (usually ~1MB/thread)	Dynamically growing
Leak Risk	None	Possible if references persist
Use Case	Temporary/local values	Long-lived or shared objects

🔁 Rewriting Heap to Use Stack (Optimization Tip)

You can optimize memory by replacing heap allocation with stack allocation using struct or Span<T>.

🆚 `class` (Heap) vs `struct` (Stack)

// Heap
class PointClass
{
    public int X;
    public int Y;
}

// Stack
struct PointStruct
{
    public int X;
    public int Y;
}

void Compare()
{
    PointClass pc = new PointClass();   // Heap
    PointStruct ps = new PointStruct(); // Stack
}

PointClass is a reference type, stored on the heap.
PointStruct is a value type, stored on the stack.

Use struct when:

You need fast, short-lived data.
You don’t need inheritance or polymorphism.

⚡ Advanced Stack Usage: `Span<T>` and `stackalloc`

void UseSpan()
{
    Span<int> numbers = stackalloc int[5];  // Stack-based array
    numbers[0] = 10;
    numbers[1] = 20;
    Console.WriteLine(numbers[0] + numbers[1]);  // Output: 30
}

stackalloc allocates memory directly on the stack.
Span<T> provides safe and efficient access to that memory.
Useful in performance-critical scenarios (e.g., parsing, buffer processing).

⚠️ Note: You cannot return Span<T> from a method-it must stay within the method scope because it’s backed by stack memory.

🚨 Common Memory Problems

❗ Stack Overflow

Occurs when you use too much stack memory, usually due to infinite or very deep recursion.

void Recurse()
{
    Recurse();  // Stack overflow
}

Each call pushes a new stack frame. Eventually, the stack runs out of space and crashes.

❗ Memory Leaks (Heap)

While C# has a garbage collector, memory leaks can still happen if you hold on to references unintentionally (e.g., through static variables or events).

class BigObject
{
    public byte[] Data = new byte[1024 * 1024]; // 1MB
}

static List<BigObject> leakyList = new();

void LeakMemory()
{
    leakyList.Add(new BigObject());  // Keeps growing, never released
}

✅ Best Practices

Use the Stack when:
- You know the data size at compile time
- Data only lives within a method
- Performance is critical
Use the Heap when:
- You need reference semantics
- Objects are large or dynamic in size
- You need data to persist across method calls
Avoid memory leaks:
- Unsubscribe from events
- Dispose of IDisposable objects
- Don’t retain unnecessary references

🔚 Final Thoughts

In .NET Core, memory management is largely automated. However, understanding the difference between Stack and Heap gives you control to optimize performance and avoid hidden bugs.

TL;DR:

Stack = Fast, small, temporary, automatic cleanup.
Heap = Flexible, long-lived, garbage collected.
Use struct and Span<T> to reduce heap usage and boost performance.

☁️ Powerful Cloud-Based Image Uploading with Watermark in .NET Core

hamza zeryouh — Fri, 25 Jul 2025 14:04:18 +0000

☁️ Powerful Cloud-Based Image Uploading with Watermark in .NET Core

Handling image uploads in web applications can get tricky — especially when you want to:

Optimize images for size and performance
Add a dynamic text watermark
Upload to a cloud provider like Cloudinary
Handle bulk uploads and deletions
Ensure clean logging and error handling

In this post, I’ll walk you through a robust service I built using Cloudinary + .NET Core that solves all of that — with extensibility and performance in mind.

✅ Features of This Service

This service is designed to handle all major image workflows for a backend API:

✅ Upload a single image with optional watermark
✅ Upload multiple images in parallel
✅ Resize & optimize images before uploading
✅ Add custom watermark text (like branding)
✅ Delete images from Cloudinary
✅ Full logging and error reporting
✅ Adjustable watermark style and quality

⚙️ Key Technologies Used

Cloudinary .NET SDK
System.Drawing for image resizing and optimization
ASP.NET Core + Dependency Injection
ILogger for clean logs
IFormFile for file handling in ASP.NET Core APIs

🧠 How It Works

🔹 1. Upload with Optimization

Before uploading, the image is:

Read from the stream
Resized based on predefined rules
Saved as optimized JPEG with 90% quality
Sent to Cloudinary using ImageUploadParams

var optimizedStream = await ConvertAndOptimizeImage(file);

🔹 2. Add Watermark

You can define a custom watermark using Cloudinary's transformation API:

new Transformation()
  .Overlay(new TextLayer("GOORFA.COM")
  .FontFamily("Arial")
  .FontSize(80)
  .FontWeight("bold"))
  .Gravity("center")
  .Opacity(60)
  .Color("#FFFFFF")
  .Flags("layer_apply");

🔹 3. Upload Multiple Images in Parallel

Uses Task.WhenAll() to efficiently upload many files at once:

var uploadTasks = files.Select(file => UploadImageAsync(file, folder));
await Task.WhenAll(uploadTasks);

🔹 4. Delete by Public ID

Clean removal of uploaded files using Cloudinary's destroy API:

var result = await _cloudinary.DestroyAsync(new DeletionParams(publicId));

📦 Sample Use Case

You can easily use this service in a controller like this:

[HttpPost("upload")]
public async Task<IActionResult> UploadImage(IFormFile file)
{
    var result = await _imageUploadService.UploadImageWithTextWatermarkAsync(file);
    return Ok(result.SecureUrl);
}

💡 Optimization Highlights

Uses System.Drawing for high-quality resizing
Smart logic to scale down large images, skip resizing small ones
Uses JPEG encoding with ImageCodecInfo for compression control
Clean architecture: interface-based service, separated config, reusable watermark logic

🔐 Watermark Configuration

You can easily tweak the watermark style using the WatermarkConfig class:

public class WatermarkConfig
{
    public string Text = "GOORFA.COM";
    public string FontFamily = "Arial";
    public int FontSize = 20;
    public string Color = "#FFFFFF";
    public int Opacity = 50;
    public string Position = "center";
}

📎 Summary

This .NET Core service:

Improves UX by compressing images
Adds professional watermarks with ease
Scales efficiently for bulk uploads
Integrates tightly with Cloudinary's CDN

🔗 Want the full source code?

Let me know in the comments or DM me — I’ll be happy to share a GitHub repo or Gist if there's interest. 😊

#dotnet #cloudinary #aspnetcore #developer #imageupload #webapi #backend #goorfa #cloud

🔥 10 Things Junior Developers Should Avoid Doing (If You Want to Grow Fast)

hamza zeryouh — Fri, 25 Jul 2025 13:45:25 +0000

Entering the world of software development is exciting—but it's also easy to fall into habits that slow your progress or frustrate your team. Whether you're in your first job or working on personal projects, avoiding these common pitfalls will save you time, reduce bugs, and accelerate your growth.

Here’s a list of the top “don’ts” every junior developer should keep in mind:

❌ 1. Don’t Be Afraid to Ask Questions

Mistake: Struggling silently for hours on one issue.
Fix: Try to solve the problem yourself first, but if you're stuck for more than 30 minutes, ask! Good teams encourage curiosity and communication. It's not a weakness—it's efficiency.

❌ 2. Don’t Skip the Fundamentals

Mistake: Rushing into frameworks or tools without understanding core concepts.
Fix: Make sure you understand the basics of programming (like loops, conditions, OOP), how the web works (HTTP, APIs), and tools like Git. They’re the foundation of everything else.

❌ 3. Don’t Over-Engineer

Mistake: Writing overly complex code that’s hard to understand or maintain.
Fix: Simple code is better than clever code. Clear and readable always wins. Solve today’s problem—don’t build an over-complicated system for problems you might have later.

❌ 4. Don’t Ignore Git Best Practices

Mistake: Pushing directly to the main branch or not using meaningful commit messages.
Fix: Learn to use branches, write clean commit history, and open pull requests. It’ll make you a better team player and avoid messy codebases.

❌ 5. Don’t Avoid Documentation

Mistake: Assuming you’ll remember everything later.
Fix: Document setup instructions, environment variables, and any tricky parts of the code. And write helpful comments—not just what the code does, but why it does it.

❌ 6. Don’t Skip Testing

Mistake: Relying only on manual testing or skipping it entirely.
Fix: Learn to write simple unit tests. It builds confidence in your code and catches bugs early. If you build habits now, they’ll stick as projects grow.

❌ 7. Don’t Take Code Reviews Personally

Mistake: Feeling attacked when someone points out issues in your code.
Fix: Feedback is how you grow. Even senior developers get corrections. Instead of reacting defensively, ask why the change is better—you’ll learn much faster.

❌ 8. Don’t Build Based on Assumptions

Mistake: Jumping into coding without clarifying the requirements.
Fix: Take time to fully understand the problem. Ask questions. What’s the user trying to do? What’s the expected behavior? This avoids rework and frustration.

❌ 9. Don’t Copy-Paste Without Understanding

Mistake: Grabbing code from Stack Overflow and hoping it works.
Fix: Always take time to understand what a piece of code does and why it works. If you can’t explain it, you shouldn’t use it—yet.

❌ 10. Don’t Stop Learning

Mistake: Treating the job like a 9-to-5 with no growth mindset.
Fix: Stay curious. Follow developers on YouTube or Twitter, build side projects, read documentation. Just 30–60 minutes a day adds up fast.

🧠 Final Thought: Avoid the Pitfalls, Grow with Purpose

You don’t need to know everything to be a great junior developer—but avoiding these common mistakes can help you stand out, earn trust, and build a strong foundation for the future.

Keep asking, keep learning, and keep coding. The rest will come.

🎯 Azure Certification Role Map: Path to Mastery

hamza zeryouh — Tue, 22 Jul 2025 06:48:35 +0000

1. Cloud Beginner / Developer / IT Pro

Goal: Build foundational knowledge & start hands-on Azure.

AZ-900: Microsoft Azure Fundamentals
What you learn: Cloud concepts, core Azure services, pricing, security basics.
Why: Perfect starting point for any Azure role.
AZ-204: Developing Solutions for Microsoft Azure
What you learn: Developing cloud apps & services with Azure SDKs, storage, compute, security, messaging.
Role: Azure Developer.

2. Azure Administrator / Operations Engineer

Goal: Manage and operate Azure infrastructure.

AZ-104: Microsoft Azure Administrator
What you learn: Managing Azure identities, governance, storage, compute, virtual networking, monitoring.
Role: Azure Administrator, Cloud Operations Engineer.
AZ-500: Microsoft Azure Security Technologies (Optional but recommended)
What you learn: Secure Azure workloads, identity management, platform protection.
Role: Security-focused admins or engineers.

3. Azure Solutions Architect

Goal: Design scalable, secure cloud solutions.

AZ-305: Designing Microsoft Azure Infrastructure Solutions What you learn: Design compute, network, storage, security, apps, and infrastructure solutions. Prerequisite: Recommended to have AZ-104 or AZ-204 first. Role: Azure Solutions Architect.

4. Azure DevOps Engineer

Goal: Automate and streamline cloud app delivery.

AZ-400: Designing and Implementing Microsoft DevOps Solutions What you learn: DevOps practices, CI/CD pipelines, infrastructure as code, configuration management, monitoring. Role: DevOps Engineer.

5. Azure Data Engineer / AI Specialist

For data-focused roles:

DP-900: Microsoft Azure Data Fundamentals (start here)
DP-203: Data Engineering on Microsoft Azure
AI-102: Designing and Implementing an Azure AI Solution

6. Advanced & Specialty Certifications

AZ-700: Designing and Implementing Microsoft Azure Networking Solutions
AZ-600: Configuring and Operating a Hybrid Cloud with Microsoft Azure Stack Hub
AZ-220: Microsoft Azure IoT Developer
SC-900: Microsoft Security, Compliance, and Identity Fundamentals

📌 Tips for Mastery

Hands-on Practice: Use Azure free tier, Microsoft Learn labs, GitHub repos.
Study Paths: Microsoft Learn offers free guided modules per certification.
Community: Join Azure forums, local user groups, and follow Azure blogs.
Project Experience: Build real projects; e.g., deploy microservices, set up CI/CD pipelines.

🤝 Follow Me for More Tips & Guides

If you want to stay updated on Azure certifications, .NET Core development, clean architecture, and scalable backend systems, connect with me:

🔗 LinkedIn – Hamza Zeryouh
💻 GitHub – @hamzazeryouh

I regularly share tutorials, best practices, and real-world projects to help developers grow.

From Zero to Modular Monolith in .NET Core: Master Event-Driven Architecture

hamza zeryouh — Tue, 22 Jul 2025 06:34:37 +0000

Introduction

When starting with microservices, developers often encounter complexity in deployment, data consistency, and testing. But what if you could structure your app like microservices—modular, isolated, well-organized—without the overhead of distributed systems?

That’s the idea behind a Modular Monolith.

This guide will teach you how to build a modular monolith in .NET Core, with:

Database-per-module schema
Per-module configuration
Outbox & Inbox event patterns
Domain event dispatching
Beginner-friendly advice and examples

1. What Is a Modular Monolith?

A Modular Monolith is a single application broken into feature-based modules, each with:

Its own domain logic
Its own data schema
Its own application services
Its own event handlers

Everything is in one codebase and deployment, but behaves as if they’re separate services.

2. Solution Structure

Your solution should separate concerns clearly per module:

/src
  /ModularMonolith.WebApi   → entry point (host)
  /Modules
    /Articles
      /Application           → use cases & services
      /Domain                → entities, value objects, domain events
      /Infrastructure        → EF Core, repositories
      /API                   → controllers (optional)
      /Outbox                → outbox logic

3. Project Setup

dotnet new sln -n ModularMonolithDemo
mkdir src
cd src
dotnet new webapi -n ModularMonolith.WebApi
dotnet sln ../ModularMonolithDemo.sln add ModularMonolith.WebApi

Now, create class libraries:

dotnet new classlib -n Modules.Articles.Domain
dotnet new classlib -n Modules.Articles.Application
dotnet new classlib -n Modules.Articles.Infrastructure

Add references between them:

Application → Domain
Infrastructure → Application, Domain

Best Practice: Think in Modules

Ask yourself:

What domain language do I need? (e.g. "Article", "Publish", "Author")
What does each module own?
Can this module be tested without others?

4. Per-Module Database Schema

Use PostgreSQL schemas or SQL Server schemas to isolate tables.

SQL (PostgreSQL):

CREATE SCHEMA articles;

CREATE TABLE articles.articles (
    id UUID PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT NOT NULL,
    created_at TIMESTAMP NOT NULL,
    updated_at TIMESTAMP
);

In EF Core:

modelBuilder.HasDefaultSchema("articles");
modelBuilder.Entity<Article>().ToTable("articles");

⚙️ 5. Module-Level Configuration

Use an extension method to isolate module config.

ArticlesModule.cs:

public static class ArticlesModule
{
    public static IServiceCollection AddArticlesModule(this IServiceCollection services, IConfiguration config)
    {
        services.AddDbContext<ArticlesDbContext>(options =>
            options.UseNpgsql(config.GetConnectionString("DefaultConnection")));

        services.AddScoped<IArticleService, ArticleService>();

        return services;
    }
}

Then in Program.cs:

builder.Services.AddArticlesModule(builder.Configuration);

6. Create an Article (Service Example)

In the Application layer:

public class CreateArticleCommand
{
    public string Title { get; set; }
    public string Content { get; set; }
}

public class ArticleService : IArticleService
{
    private readonly ArticlesDbContext _db;
    private readonly IDomainEventDispatcher _dispatcher;

    public async Task CreateArticleAsync(CreateArticleCommand command)
    {
        var article = new Article(command.Title, command.Content);

        _db.Articles.Add(article);

        await _dispatcher.AddAsync(new ArticleCreatedEvent(article.Id, article.Title));
        await _db.SaveChangesAsync();
    }
}

7. Outbox Pattern (Event Publishing)

Why Outbox?
To guarantee that events aren't lost, especially when publishing to a message bus.

Step-by-step:

1. Create Outbox Table:

CREATE TABLE articles.outbox_messages (
    id UUID PRIMARY KEY,
    type VARCHAR(250) NOT NULL,
    payload TEXT NOT NULL,
    occurred_on TIMESTAMP NOT NULL,
    processed_on TIMESTAMP NULL
);

2. Add Message to Outbox:

public class OutboxMessage
{
    public Guid Id { get; set; }
    public string Type { get; set; }
    public string Payload { get; set; }
    public DateTime OccurredOn { get; set; }
    public DateTime? ProcessedOn { get; set; }
}

public class DomainEventDispatcher : IDomainEventDispatcher
{
    private readonly ArticlesDbContext _db;

    public Task AddAsync<T>(T domainEvent) where T : class
    {
        var message = new OutboxMessage
        {
            Id = Guid.NewGuid(),
            Type = domainEvent.GetType().Name,
            Payload = JsonSerializer.Serialize(domainEvent),
            OccurredOn = DateTime.UtcNow
        };

        _db.OutboxMessages.Add(message);
        return Task.CompletedTask;
    }
}

8. Background Worker for Outbox Dispatch

public class OutboxPublisherWorker : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            using var scope = _scopeFactory.CreateScope();
            var db = scope.ServiceProvider.GetRequiredService<ArticlesDbContext>();

            var messages = await db.OutboxMessages
                .Where(x => x.ProcessedOn == null)
                .ToListAsync();

            foreach (var message in messages)
            {
                // Here you would publish to RabbitMQ, Kafka, etc.
                Console.WriteLine($"[Outbox] Publishing event {message.Type}");

                message.ProcessedOn = DateTime.UtcNow;
            }

            await db.SaveChangesAsync();
            await Task.Delay(3000);
        }
    }
}

9. Inbox Pattern for Idempotent Event Handling

Add InboxMessage table:

CREATE TABLE articles.inbox_messages (
    id UUID PRIMARY KEY,
    message_type VARCHAR(250),
    received_on TIMESTAMP,
    processed_on TIMESTAMP
);

Before processing any event:

Check if it exists in inbox_messages
If yes → skip
If not → process and save to inbox

10. Events Between Modules

Example:

ArticlePublishedEvent (in Domain):

public record ArticlePublishedEvent(Guid Id, string Title) : IDomainEvent;

Handler (in Notifications module):

public class SendNotificationHandler : IEventHandler<ArticlePublishedEvent>
{
    public async Task HandleAsync(ArticlePublishedEvent @event)
    {
        // Send an email, log to audit table, etc.
    }
}

Advice for Junior Developers

Start with 2 modules, like:

Articles
Notifications

Focus on:

Separation of responsibilities
Using domain language
Consistent naming (Domain, Application, etc.)

Add unit tests per module using xUnit

Don’t jump to microservices too early—modular monolith scales better initially

Resources

📌 Final Thoughts

In this guide, you’ve learned how to:

✅ Build a Modular Monolith in .NET Core
✅ Structure your app using Clean Architecture principles
✅ Implement Outbox/Inbox patterns for reliable event handling
✅ Keep your app modular, testable, and future-proof

💡 This architecture gives you the best of both worlds—the simplicity of a monolith with the boundaries and scalability of microservices, without the distributed headaches.

🤝 Stay Connected

If you found this helpful and want more content like this (clean .NET, architecture tips, and backend patterns), feel free to connect and follow me:

🔗 LinkedIn – Hamza Zeryouh
💻 GitHub – @hamzazeryouh

🧠 I regularly share insights and examples on .NET Core, clean architecture, and real-world dev practices.

🚀 .NET Query Performance: Fixing Slow Queries with Practical Techniques

hamza zeryouh — Mon, 21 Jul 2025 13:03:16 +0000

As backend developers, we often encounter performance issues due to inefficient queries. A single unoptimised query can slow down your entire application, increase cloud database costs, and frustrate users.

Here are powerful and practical techniques to optimise your queries in .NET (Entity Framework Core):

1. Use AsNoTracking() for Read-Only Queries

Use EF Core logging, MiniP

When retrieving data only for reading, use .AsNoTracking() to skip change tracking, reducing memory usage and improving speed.

var products = await dbContext.Products .AsNoTracking() .ToListAsync();

Why? EF won’t track changes, reducing overhead for read-heavy operations.

2. Select Only Required Columns

Fetching entire entities when you only need specific fields wastes resources.

Bad:

var users = await dbContext.Users.ToListAsync();

Good:

var userNames = await dbContext.Users .Select(u => u.Name) .ToListAsync();
Why? Smaller data loads mean faster queries and less memory usage.

3. Prevent N+1 Query Problems

Fetching related data within loops leads to multiple database hits (N+1 issue). Instead, use .Include() for eager loading:

var orders = await dbContext.Orders .Include(o => o.OrderItems) .ToListAsync();

🔧 Tip: Use .ThenInclude() for nested navigation properties.

4. Always Filter at Database Level

Use EF Core logging, MiniP

Applying .Where() after loading data into memory leads to performance issues.

Bad:

var orders = await dbContext.Orders.ToListAsync();
var filtered = orders.Where(o => o.Status == "Delivered");

Good:

var filtered = await dbContext.Orders .Where(o => o.Status == "Delivered") .ToListAsync();

Why? Let SQL handle filtering efficiently instead of your server.

5. Use Any() for Existence Checks

Checking for existence with .Count() > 0 scans the entire table, slowing performance.

Good:

bool hasOrders = await dbContext.Orders.AnyAsync();

6. Paginate Large Datasets

Returning thousands of records in one go is rarely needed. Always implement pagination:

var page = await dbContext.Users .OrderBy(u => u.Id) .Skip(10) .Take(10) .ToListAsync();

Why? This reduces memory usage and improves response time.

7. Use Proper Indexing

Ensure your database has indexes on frequently queried fields like foreign keys and search columns. This significantly improves lookup speed.

8. Cache Static or Rarely Changed Data

For data that doesn’t change often (e.g. country lists, categories), implement in-memory caching or distributed caching like Redis to reduce repeated DB hits.

9. Optimise LINQ Queries

Complex LINQ queries can generate inefficient SQL. Always check the generated SQL to ensure queries are fully translated and no client-side evaluations occur.

*10. Profile Your Queries *

profiler, or your SQL server’s execution plan analyser to detect:
• Slow queries
• Missing indexes
• Inefficient query translations

11. Use AsSplitQuery() for Multiple Includes

When you load multiple related collections, EF Core by default uses a single SQL query with JOINs. This can lead to Cartesian explosion, duplicating data and consuming lots of memory.

Solution: .AsSplitQuery()

var orders = await dbContext.Orders
.Include(o => o.OrderItems)
.Include(o => o.ShippingAddress)
.AsSplitQuery()
.ToListAsync();

Why? EF Core executes one query per Include, avoiding large JOIN result sets and improving performance in many scenarios.

When to use: For queries with multiple collections where JOINed queries create performance issues.
When to avoid: For simple includes, as multiple queries add slight latency.

Final Thoughts

Optimising queries is essential for:
• Fast user experiences
• Lower cloud costs
• Scalable and maintainable applications

What other query optimisation techniques do you use daily? Share in the comments to help others learn and grow.

DotNet #EntityFramework #Performance #Backend #SoftwareEngineering #CleanCode #Optimization #Coding

Why You Should Start with a Modular Monolith Before Jumping into Microservices

hamza zeryouh — Thu, 08 May 2025 11:16:32 +0000

In the era of distributed systems, microservices are often hailed as the golden standard for scalable architecture. Companies like Netflix and Amazon made them famous, leading many startups and teams to believe they need microservices from day one. But is it really the best path forward?

Not necessarily.

For most early-stage products and growing teams, starting with a Modular Monolith is a smarter, faster, and more sustainable decision. Let’s dive into what it means and why it’s a better starting point.

What is a Modular Monolith?

A modular monolith is a single deployable application structured internally into well-separated modules. Each module represents a feature or a domain (e.g., User, Orders, Payments) and communicates with others via clean interfaces.

It offers the same internal boundaries and discipline you’d aim for in a microservices architecture—without the overhead of distributed systems.

Why Start with a Modular Monolith?

1. Simplicity in Deployment

Microservices require orchestration (Docker, Kubernetes), service discovery, load balancing, and more. In contrast, a modular monolith is just one app, one database, one deploy—easy to host and debug.

Ideal for MVPs and fast iteration cycles.

2. Faster Development

You don’t need to spin up multiple services or manage inter-service communication. All modules live in the same codebase and memory space, making refactoring and feature development much faster.

3. Easier Debugging and Testing

Monoliths don’t suffer from network latency or distributed tracing problems. With logs and stack traces in one place, debugging becomes drastically easier.

4. Lower Infrastructure Costs

Microservices come with cost: each service might need its own container, CI/CD pipeline, monitoring tools, and hosting. A modular monolith is cost-effective, especially for small teams and startups.

5. Natural Path to Microservices (When Needed)

If your system grows and you hit scaling or team autonomy limits, you can extract a well-designed module into its own microservice.

A modular monolith lays the groundwork for microservices—without the premature complexity.

Best Practices for Modular Monoliths

Use Domain-Driven Design (DDD) to define module boundaries.
Encapsulate logic: no direct access to internal state of other modules.
Use dependency injection and interfaces to enforce loose coupling.
Consider modular folder structure, namespaces, and clear API boundaries.
Include internal contracts but expose only what’s necessary.

Final Thoughts

Don’t be fooled by the hype. Microservices are not a silver bullet—they’re a scaling strategy, not a starting point.

Start small. Stay focused. Build a solid foundation with a modular monolith—and evolve to microservices only when your system and team truly require it.

Start smart. Scale later.

Mastering FluentValidation in .NET Core

hamza zeryouh — Sat, 18 Jan 2025 18:41:09 +0000

Introduction

Data validation is a fundamental aspect of any application, ensuring that user inputs meet the required criteria before processing. FluentValidation is a powerful .NET library that simplifies the validation process while maintaining clean and maintainable code.

In this article, we will explore:

Why FluentValidation?
Setting up FluentValidation in .NET Core
Writing custom validators
Integrating FluentValidation with CQRS
Handling localization for multilingual validation messages

Why FluentValidation?

Key Benefits:

✅ Separation of Concerns – Keeps validation logic separate from business rules.
✅ Improved Readability – Uses an expressive, fluent API for defining validation rules.
✅ Reusable & Maintainable – Eliminates repetitive validation logic across multiple components.
✅ Supports Complex Validations – Easily handle conditional and cross-field validations.
✅ Built-in Localization – Supports multi-language validation messages.
✅ Seamless Integration – Works well with ASP.NET Core and Dependency Injection.

1️⃣ Installing FluentValidation

To get started, install the FluentValidation package via NuGet:

Install-Package FluentValidation.AspNetCore

Then, register FluentValidation in Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Register FluentValidation
builder.Services.AddControllers();
builder.Services.AddFluentValidationAutoValidation();
builder.Services.AddValidatorsFromAssemblyContaining<CarValidator>();

var app = builder.Build();
app.UseAuthorization();
app.MapControllers();
app.Run();

2️⃣ Creating a Validator Class

Let's define a Car model and create a validator for it:

public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
    public string VIN { get; set; }
    public int Year { get; set; }
    public decimal PricePerDay { get; set; }
}

Writing a Validator for the `Car` Model

using FluentValidation;

public class CarValidator : AbstractValidator<Car>
{
    public CarValidator()
    {
        RuleFor(car => car.Make)
            .NotEmpty().WithMessage("Make is required")
            .MaximumLength(50).WithMessage("Make cannot exceed 50 characters");

        RuleFor(car => car.Model)
            .NotEmpty().WithMessage("Model is required")
            .MaximumLength(50).WithMessage("Model cannot exceed 50 characters");

        RuleFor(car => car.VIN)
            .NotEmpty().WithMessage("VIN is required")
            .Matches("^[A-HJ-NPR-Z0-9]{17}$").WithMessage("VIN must be exactly 17 characters");

        RuleFor(car => car.Year)
            .InclusiveBetween(1886, DateTime.UtcNow.Year)
            .WithMessage($"Year must be between 1886 and {DateTime.UtcNow.Year}");

        RuleFor(car => car.PricePerDay)
            .GreaterThan(0).WithMessage("Price per day must be greater than zero");
    }
}

3️⃣ Using FluentValidation in Controllers

[ApiController]
[Route("api/cars")]
public class CarController : ControllerBase
{
    [HttpPost]
    public IActionResult CreateCar([FromBody] Car car)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        return Ok("Car successfully created");
    }
}

With FluentValidation, validation happens automatically, and invalid requests return structured error messages.

4️⃣ Advanced: Integrating FluentValidation with CQRS

In a CQRS (Command Query Responsibility Segregation) architecture, FluentValidation helps validate commands before they reach the handler.

Define a `CreateCarCommand`:

using MediatR;
public class CreateCarCommand : IRequest<int>
{
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }
}

Create a Validator for the Command:

public class CreateCarCommandValidator : AbstractValidator<CreateCarCommand>
{
    public CreateCarCommandValidator()
    {
        RuleFor(command => command.Make).NotEmpty().WithMessage("Make is required");
        RuleFor(command => command.Model).NotEmpty().WithMessage("Model is required");
        RuleFor(command => command.Year).InclusiveBetween(1886, DateTime.UtcNow.Year);
    }
}

Register and Validate in a Handler:

public class CreateCarCommandHandler : IRequestHandler<CreateCarCommand, int>
{
    public async Task<int> Handle(CreateCarCommand request, CancellationToken cancellationToken)
    {
        // Business logic for car creation
        return await Task.FromResult(1);
    }
}

Now, whenever CreateCarCommand is executed, FluentValidation ensures the request is valid before reaching the handler.

5️⃣ Localization Support (Multi-language Validation Messages)

To support multiple languages, integrate a translation service:

RuleFor(car => car.Make)
    .NotEmpty().WithMessage(_ => _translationService.GetTranslation("MakeRequired"));

Example Translation Service:

public interface ITranslationService
{
    string GetTranslation(string key);
}

public class TranslationService : ITranslationService
{
    private readonly Dictionary<string, string> _translations = new()
    {
        { "MakeRequired", "La marque est requise" } // French Example
    };

    public string GetTranslation(string key)
    {
        return _translations.TryGetValue(key, out var value) ? value : key;
    }
}

This way, validation messages can be translated dynamically based on the user's language.

Conclusion

FluentValidation is a powerful tool for managing input validation in .NET Core applications. It keeps validation logic clean, reusable, and maintainable while supporting complex business rules, CQRS integration, and localization.

🚀 Want More Advanced Logic?

Check out a full GitHub example integrating FluentValidation with CQRS:

🔗 GitHub – FluentValidation with CQRS

Are you using FluentValidation in your projects? Let’s discuss in the comments! 👇

DotNetCore #FluentValidation #Csharp #CQRS #SoftwareDevelopment #CleanCode #ASPNetCore #BackendDevelopment

.NET Core Developer Roadmap 2025

hamza zeryouh — Tue, 07 Jan 2025 11:32:03 +0000

To stay ahead in the fast-evolving world of .NET Core development, it's essential to follow a structured learning path. Here’s the .NET Core Developer Roadmap for 2025 that will guide you from the fundamentals to advanced topics.

1. C# Fundamentals

Before diving into .NET Core, mastering C# fundamentals is crucial.

Basic Syntax and Data Types: Learn about variables, data types, operators, and control structures.
Object-Oriented Programming (OOP):
- Classes and Objects: Understand how to define classes and create instances.
- Inheritance: Grasp the concept of class hierarchies and inheritance.
- Polymorphism: Learn how the same method can behave differently based on the object type.
- Encapsulation: Understand how to hide internal object details and provide access through methods.
- Abstraction: Learn how to define abstract classes and interfaces.
Collections and LINQ: Master collections such as lists, dictionaries, and LINQ queries to manipulate data.
Exception Handling: Learn how to handle errors using try, catch, finally, and custom exceptions.
Asynchronous Programming:
- async/await: Grasp the fundamentals of asynchronous programming to improve app performance.
- Task Parallel Library: Learn about parallel and concurrent programming using tasks.
- Threading: Understand how threads work and how to manage them.

2. .NET Core Basics

Now that you’re comfortable with C#, dive into the .NET Core framework.

Understanding .NET Core Architecture: Learn about the core components of .NET Core and how they interact.
CLI Commands: Get familiar with the .NET Core Command-Line Interface (CLI) to manage projects and dependencies.
Project Structure: Understand the layout of a typical .NET Core project and the role of each file/folder.
Configuration:
- appsettings.json: Learn how to manage application settings.
- Environment Variables: Set up environment-specific configurations.
- User Secrets: Secure sensitive data for development purposes.
Dependency Injection: Master the built-in DI container for decoupling classes.
Middleware: Learn how middleware works in handling HTTP requests.
Logging: Understand logging best practices and how to log events.
Error Handling: Implement global error handling to enhance user experience.

3. Web Development

3.1 ASP.NET Core

ASP.NET Core is a robust web framework for building scalable, secure web applications.

MVC Pattern: Understand the Model-View-Controller pattern and its application.
Razor Pages: Use Razor Pages to build dynamic web pages.
Routing: Learn how URL patterns map to controllers and actions.
Controllers and Views: Master how to create and render views from controllers.
Model Binding: Bind data from views to model objects.
Validation: Implement validation logic for user inputs.
Filters: Learn how to use filters for logging, authentication, and authorization.
Areas: Organize your application into areas for better modularity.

3.2 Web APIs

Building APIs with .NET Core is a vital skill for modern web development.

RESTful Services: Learn how to create scalable and stateless REST APIs.
HTTP Methods: Understand GET, POST, PUT, DELETE, and PATCH methods.
Status Codes: Use HTTP status codes correctly for API responses.
API Versioning: Implement versioning to maintain backward compatibility.
Content Negotiation: Handle different response formats (JSON, XML).
CORS: Configure Cross-Origin Resource Sharing for security.
API Documentation (Swagger/OpenAPI): Use Swagger for interactive API documentation.
Rate Limiting: Prevent abuse by limiting the rate of requests.
API Security: Secure your API using best practices, including authentication and authorization.

4. Database Technologies

4.1 Entity Framework Core

Entity Framework Core (EF Core) is the ORM tool for interacting with databases.

Code First Approach: Define models in code and generate the database schema.
Database First Approach: Reverse engineer models from an existing database.
Migrations: Manage database changes over time.
CRUD Operations: Learn how to create, read, update, and delete data.
Relationships: Master 1-to-1, 1-to-many, and many-to-many relationships.
Lazy Loading vs Eager Loading: Understand when to load related data lazily or eagerly.
Query Optimization: Optimize queries for better performance.

4.2 Database Systems

In addition to EF Core, you should be familiar with various databases.

SQL Server: The most widely used relational database in .NET.
PostgreSQL: An open-source relational database known for its reliability.
MongoDB: A NoSQL database for flexible data storage.
Redis: Use Redis for caching to enhance performance.

5. Security

Security is a crucial aspect of any application.

Authentication:
- JWT: Use JSON Web Tokens for stateless authentication.
- OAuth 2.0: Implement authorization using OAuth 2.0.
- OpenID Connect: Use OpenID Connect for secure authentication.
Authorization:
- Role-based: Implement role-based access control.
- Policy-based: Use policies to handle complex authorization logic.
- Claims-based: Use claims to manage user-specific data.
Data Protection: Encrypt sensitive data to ensure privacy.
HTTPS: Use HTTPS to secure communications between clients and servers.
Cross-Site Scripting (XSS): Prevent XSS attacks by sanitizing user inputs.
Cross-Site Request Forgery (CSRF): Protect against CSRF attacks with anti-forgery tokens.
SQL Injection Prevention: Safeguard your application from SQL injection attacks.

6. Testing

Testing is essential for delivering robust applications.

Unit Testing:
- MSTest: Use MSTest for unit testing .NET applications.
- NUnit: NUnit is a popular testing framework.
- xUnit: Another widely used testing framework.
Integration Testing: Test how different parts of your application work together.
Mocking:
- Moq: Use Moq to mock dependencies in unit tests.
- NSubstitute: An alternative to Moq for mocking.
Test Coverage: Ensure your tests cover all critical parts of your application.
TDD (Test Driven Development): Adopt a test-first approach to writing code.

7. Advanced Concepts

7.1 Design Patterns

Understanding design patterns is crucial for writing clean, maintainable code.

Repository Pattern: Abstract data access into repositories.
Factory Pattern: Use factories to create objects without exposing the instantiation logic.
Singleton Pattern: Ensure only one instance of a class is created.
Observer Pattern: Implement event-driven architecture.
Strategy Pattern: Use different algorithms interchangeably.
SOLID Principles: Follow the SOLID principles for better object-oriented design.

7.2 Architecture

Learn modern architectural approaches to building scalable and maintainable applications.

Clean Architecture: Separate concerns to improve code maintainability.
Microservices: Design applications as a set of loosely coupled services.
Domain-Driven Design (DDD): Focus on the core business logic.
CQRS: Implement Command Query Responsibility Segregation for better scalability.
Event Sourcing: Use events to capture state changes in the system.

10. Additional Skills

10.1 Frontend Technologies

Having knowledge of frontend technologies can be a valuable addition.

HTML/CSS: Master the basics of web markup and styling.
JavaScript: Learn JavaScript to manipulate the DOM and handle events.
TypeScript: Use TypeScript for better type safety in JavaScript development.
Angular/React/Vue.js: Get familiar with popular JavaScript frameworks.
Blazor: For .NET developers, Blazor allows you to build interactive web UIs using C# instead of JavaScript.

Best Practices & Tips

Always follow coding standards and conventions.
Write clean, maintainable code.
Implement proper error handling.
Use async/await where appropriate.
Implement proper logging.
Write comprehensive documentation.
Follow security best practices.
Optimize performance.
Write unit tests.
Keep learning and staying updated.

Recommended Learning Path

Start with C# fundamentals.
Move to .NET Core basics.
Learn web development with ASP.NET Core.
Master database operations with Entity Framework.
Implement security features.
Practice testing.
Study advanced concepts.
Explore cloud deployment.
Learn monitoring and optimization.
Keep practicing and building projects.

Project Ideas for Practice

Task Management System
E-commerce Platform
Blog Engine
API Gateway
Authentication Service
Real-time Chat Application
File Storage Service
Payment Processing System
Booking System
Social Media API

🚀 Want to take your career and business to the next level?

Follow me on LinkedIn for more insights on mastering .NET Core development, microservices, and business strategies that can help you grow and achieve success! 💡

💻 Whether you're looking to sharpen your technical skills or learn actionable strategies to scale your business, I've got you covered with valuable tips, articles, and resources.

👉 Follow me now for more exclusive content: LinkedIn Profile

Let’s connect and grow together! 🚀