Welcome to my GitHub profile! I'm a software developer with 15+ years of experience in building scalable and maintainable applications, specializing in efficient database solutions. I enjoy working with modern technologies and constantly strive to refine my skills.
- 🌱 Continuously leveling up in .NET and modern C#, with a focus on API design and architecture.
- 🔭 I’m currently working on expanding my knowledge of Entity Framework Core to deepen my understanding of data access strategies.
- 🤔 I’m looking for help with code reviews and having someone go through my code to correct me where I might be wrong or suggest improvements.
- 💬 Exploring modern C# and .NET. Always happy to share what I’ve learned or discuss things I’m still figuring out.
- Languages: FoxPro, Visual FoxPro, HTML, CSS, JavaScript, C#
- Frameworks: .NET, ASP.NET Core, Entity Framework Core, Bootstrap
- Tools: Git, GitHub, Docker
- Editors and IDEs: LINQPad, Visual Studio, JetBrains Rider, Visual Studio Code
- Database Technologies: FoxPro, Visual FoxPro, SQL Server
🖥️ ShirtsApi-ArchitecturalDocs An educational walkthrough of a secure, filter-based ASP.NET Core Web API with flowcharts, claim-based validation, and clean architecture, inspired by course-based learning.
🖥️ Request Validation In Minimal APIs A .NET 9 application that demonstrates the use of minimal APIs in ASP.NET Core. This project includes various features such as global exception handling, CORS, HTTPS redirection, health checks, OpenAPI documentation, and more.
🖥️ API Versioning & Keyed Services in .NET 9 A reference-grade ASP.NET Core Web API built with .NET 9, showcasing both controller and minimal endpoint implementations. Highlights include API versioning, keyed service injection, fail-fast DI validation, and dual OpenAPI UIs via Swagger UI and Scalar. Designed as a hands-on guide for building scalable, version-aware APIs with clarity, discoverability, and modern tooling.
🖥️ Bearer Token Auth Demo
A minimal API application built with .NET 10, showcasing ASP.NET Core Identity with AddBearerToken() introduced in .NET 8. It features secure token-based authentication, role-based authorization, auto-generated endpoints via MapIdentityApi, OpenAPI integration, Scalar UI, and developer-friendly documentation.
🖥️ Global Exception Middleware Demo
A reference-grade ASP.NET Core demo built with .NET 9, showcasing centralized error handling using IExceptionHandler, ProblemDetailsFactory, and FluentValidation. Includes structured error responses, visual pipeline flow via Mermaid chart, and production-ready practices for Minimal APIs.
🖥️ Manual DTO Mapping via Extension Methods A reference-grade ASP.NET Core Minimal API demo built with precision and clarity. It features explicit DTO transformations using extension methods, a clean repository pattern backed by EF Core with SQLite, intentional JSON serialization, and a well-structured architecture that prioritizes separation of concerns and audit-safe updates.
🖥️ Hosted Services in ASP.NET Core An ASP.NET Core project built with .NET 9 that illustrates key hosted service patterns through clear, beginner-friendly examples. Covers timed execution, scoped service activation, and queue-based task processing. Ideal for developers seeking a practical introduction to background tasks in ASP.NET Core.
🖥️ C# Enum Mastery: Advanced Patterns, Metadata, and Flag Operations A focused .NET repository that demonstrates advanced C# enum usage, including attribute-driven metadata, flagged/composite operations, custom type converters, and idiomatic iteration techniques. With in-depth, example-driven documentation, it’s perfect for developers seeking authoritative patterns for metadata-rich enums covering everything from reflection and extension methods to real-world UI mapping and DTO integration.
🖥️ LearnBlazor
A personal Blazor exploration log capturing the components, configurations, and experiments from my ongoing Blazor journey. Originally created to demonstrate PersistentComponentState in community discussions, this repository now serves as a record of what I’ve learned and a reference point for future exploration.
📝 API Project Architecture A structured walkthrough of how to layer an ASP.NET Core API project covering controllers, services, repositories, and validation with clarity and purpose.
📝 Repository Pattern – ASP.NET Core Web API A practical guide to implementing the repository pattern to decouple data access logic and promote testability in your Web API projects.
📝 Understanding Service Registration & Keyed Services in Dependency Injection Explains how to register multiple implementations of the same interface using keys — a powerful technique for advanced DI scenarios.
📝 Mastering Service Registration in Dependency Injection
Covers the different lifetimes (Transient, Scoped, Singleton) and registration strategies to help you build flexible and maintainable services.
📝 Mastering Dependency Injection: Effective Ways to Inject Dependencies in C# A hands-on comparison of constructor, property, and interface injection with examples to help you choose the right approach for your use case.
👉 Click to view
These are completed demos and experiments that I've already explored locally. What's pending is documentation, polishing, and publishing to GitHub. Each entry reflects a focused concept or architectural decision I wanted to validate firsthand. This section serves as a personal publishing queue. Quietly organized and ready when time allows.
🖥️ Minimal API Validation in .NET 10
Planned Repo: MinimalApiValidation-DotNet10
🏷️ Tags: Validation, Minimal API, Preview Features, .NET 10
Explore new features introduced in .NET 10 Previews:
- Auto-validation for request bodies in Minimal APIs using
builder.Services.AddValidation();introduced in Preview 3. - Support for
DataAnnotationattributes directly on C#recordtypes introduced in Preview 4. - Includes a comparison of behavior between Minimal APIs and traditional MVC controllers.
🖥️ Manual DTO Mapping via Extension Methods
Planned Repo: DtoMappingWithExtensionMethods
🏷️ Tags: DTO, Mapping, Extension Methods, Clean Code
- Demonstrates clean and controlled DTO ↔ Entity mapping using extension methods.
- Avoids the overhead of external mappers like AutoMapper and places mapping logic where it's accessible and testable.
🏅 Promoted to Featured Work
🖥️ C# Enum Mastery: Advanced Patterns, Metadata, and Flag Operations
Planned Repo: AdvancedEnumPatterns
🏷️ Tags: Enums, Metadata, Attributes, Flags, FastEnums
- Progressively explores enum usage from basic iteration to advanced concepts like reading custom attributes, using
TypeConverterfor friendly string output, and bitwise combination withFlags. - Includes performance optimization via
FastEnums(source generator library).
🏅 Promoted to Featured Work
🖥️ Global Exception Handling
Planned Repo: GlobalExceptionMiddleware-Demo
🏷️ Tags: Error Handling, Middleware, API, Resilience
- Implements centralized error handling in ASP.NET Core using custom handlers.
- Captures exceptions and responds with structured error payloads—ideal for consistent API behavior.
🏅 Promoted to Featured Work
🖥️ Background & Hosted Services
Planned Repo: HostedServicesInAspNetCore
🏷️ Tags: Background Processing, Hosted Services, Lifecycle, Cancellation
Demonstrates background processing patterns using multiple approaches:
BackgroundService: A streamlined base class for long-running tasks with support for scoped services and graceful cancellation.IHostedService: Interface-based implementation for startup tasks, timers, and background loops.IHostedLifetimeService: Introduced in .NET 8 for managing full lifecycle hooks (startup, shutdown, failure handling).
🏅 Promoted to Featured Work
🖥️ Repository Pattern + Generic Support
Planned Repo: RepositoryPatternWithGenericSupport
🏷️ Tags: Repository, Data Access, Abstraction, EF Core
Demonstrates two complementary data access patterns:
- Traditional Repository Pattern: Entity-specific interfaces focused on database CRUD operations, keeping persistence logic separate from business decisions.
- Generic Repository Pattern: Shared
IRepository<T>approach for reusable CRUD functionality across multiple entities. Helpful for consistency and reducing repetition.
🖥️ C# 14 Extension Method Demo
Planned Repo: ExtensionMethods-CSharp14-Demo
🏷️ Tags: C# 14, Syntax, Extension Methods, Utility
- Showcases the new syntax for declaring extension methods introduced in C# 14.
- This demo emphasizes improved readability, expressive method design, and clean separation of functionality without altering original types.
- Ideal for utility libraries, functional helpers, and designing fluent code experiences.
🖥️ QuestPDF Layout Demo
Planned Repo: QuestPDF-LayoutShowcase
🏷️ Tags: PDF Generation, QuestPDF, Layout, Templates
- Generates visually rich multi-page PDFs with custom fonts, dynamic columns, rows, headers, and placeholders.
- Demonstrates layout precision and developer-friendly styling.
🖥️ Culture-Aware Unit Testing
Planned Repo: CultureAwareUnitTests-DotNet
🏷️ Tags: Localization, CultureInfo, Unit Tests, Threading
- Validates cultural formatting behavior for dates and currency across multiple locales (
pt-PT,en-IN,ru-RU, and others). - The demo highlights how
Thread.CurrentCultureandThread.CurrentUICulturecan be programmatically controlled during tests to simulate global user experiences.
🖥️ Factory Pattern in ASP.NET Core
Planned Repo: FactoryPatternInAspNetCore
🏷️ Tags: Factory, Keyed Services, Design Patterns, Dependency Injection
- Contrasts traditional Factory Pattern usage with Keyed Services introduced in .NET 8.
- Good for understanding runtime resolution, DI flexibility, and design pattern evolution.
These topics emerged while building my demos. They’re either things I’d like to write about or jot down for future reference. Most of them focus on practical .NET features and architectural patterns, with an emphasis on clarity over completeness. If they eventually turn into blog posts or guides, great. If not, they still mark what caught my interest along the way.
| Feature | Highlights Worth Covering |
|---|---|
| Rate Limiting | Built-in support in .NET 8, flexible limiter types (fixed, sliding, token bucket), custom policies |
| Health Checks | Monitor app health with built-in checks, custom endpoints, readiness/liveness probes, and UI tools |
| Anti-Forgery Tokens | CSRF protection using tokens, secure cookie/header setup, and strategies for Razor Pages and APIs |
| Model Validation | Server-side validation with DataAnnotations, FluentValidation, ModelState, and automatic 400 responses via [ApiController] |
| Caching | In-memory, distributed, and response caching with profiles, vary-by rules, and smart invalidation |
| Authentication & Authorization | JWT, cookie schemes, policy-based auth, roles/claims, custom handlers |
| CORS | Configure global or scoped policies using WithOrigins, handle preflight requests, and control wildcard behavior |
| Custom Middleware | Create pipeline components using IMiddleware or inline delegates; manage request flow, inject logging, and handle early exits |
| HttpClient & Message Handlers | Manage outbound HTTP calls with IHttpClientFactory, typed clients, and custom DelegatingHandlers for retries and logging |
| SignalR (Real-Time) | Hubs, connections, broadcasting, stateful messaging in APIs |
| Background & Worker Services | BackgroundService, IHostedService, IHostedLifecycleService, timers, graceful shutdowns |
| File Uploads in APIs | Upload files via IFormFile with streaming or buffering, apply size limits, and perform server-side validation |
| Logging & Monitoring | Use ILogger and Serilog for structured logging, integrate telemetry, and enable diagnostics for production insights |
| Model Binding Internals | Dive into parameter binding sources, complex type handling, and how model binding integrates with validation and custom binders |
- 😄 Pronouns: He/Him
- 🌱 I believe in lifelong learning and enjoy mentoring others in their coding journey.
- ✍️ I also take time to document what I discover, capturing ideas through code, writing, and quiet reflection.
- 🤝 I welcome thoughtful feedback and conversation. If something I’ve shared resonates with you, feel free to reach out.
My projects focus on what's essential: clean structure, practical patterns, and thoughtful documentation.
