Today I am releasing PosInformatique.Foundations 1.0.0: a set of small, focused .NET libraries that I use every day in my projects, and that are now available as NuGet packages.
This project was born from a very simple frustration:
I was tired of recreating the same basic value objects (email, phone number, names, MIME types, etc.) in every project.
I wanted to standardize data across applications instead of having a different string format and validation rule in each solution.
I did not want to create a huge “framework” or “super library” that you install for one useful type and then carry hundreds of classes you never use.
So instead, I decided to build a set of small, independent libraries, each one doing one thing well, and all following the same philosophy.
Philosophy: Small, Focused and Standards-Based
PosInformatique.Foundations is not a framework. It is a toolbox of tiny building blocks:
Granular: each package is independent, lightweight, minimal.
Composable: you install only what you need.
Practical: most packages are about value objects, helpers, and small utilities that are missing in many projects.
Standards-based: whenever possible, implementations follow existing standards:
Integration-specific packages: instead of making the core value object depend on everything, I provide derived packages per technology:
You can use the core value objects alone, or plug them into Entity Framework Core, validation, or JSON serialization with the packages you need.
All libraries target .NET 8.0, .NET 9.0 and .NET 10.0.
Main Features in 1.0.0
Email Address Value Object
Package: PosInformatique.Foundations.EmailAddresses
Plus integrations: EF Core, FluentValidation, System.Text.Json.
This package provides a strongly-typed EmailAddress value object with:
Validation based on RFC 5322
Normalization (for example on casing of the local and domain parts)
Equality and comparison on the normalized form
Why it helps:
No more string email arguments everywhere.
You avoid inconsistent regexes and ad-hoc checks in each project.
You can share a standard, tested implementation across many solutions.
Phone Number Value Object (E.164)
Package: PosInformatique.Foundations.PhoneNumbers
Plus integrations: EF Core, FluentValidation, System.Text.Json.
The PhoneNumber value object represents numbers in E.164 format:
Parsing with region-aware support for local numbers
Validation and normalization to a single, canonical form
Helpers for formatting and comparison
This gives you consistent phone numbers across your system:
One normalized representation
Easier matching and comparisons
No more half-baked "+33" vs "0033" vs local format issues
First/Last Name Value Objects
Package: PosInformatique.Foundations.People
Plus integrations: DataAnnotations, FluentValidation, FluentAssertions, EF Core, System.Text.Json.
These packages provide:
Goal: stop using raw strings for user names and apply shared rules across your application with the following conventions:
The last name are in uppercase and allows only one space as separator and alphabetic characters.
The first name starts with uppercase and the letters are in lower case. The hypen and one spaces are allowed for separators.
MimeType Value Object
Package: PosInformatique.Foundations.MediaTypes
Plus integrations: EF Core, System.Text.Json.
MimeType is an immutable value object that represents a media type like image/png or application/pdf, with:
A list of well-known MIME types
Helpers to map between extensions and media types
Strong typing instead of string everywhere
Functional helpers to determine if a MIME type is an image, Auto CAD drawing,…
Text Templating: Building Emails (and More) From Models
Emailing is a simple but essential feature in almost every application. I wanted a way to:
Define strongly-typed email templates with a model
Use different templating engines (Razor, Scriban, …)
Keep the email sending logic decoupled from the rendering engine
This is why I introduced two building blocks:
Text templating abstractions
Concrete implementations
On top of that, there is an emailing infrastructure:
You can:
Register email templates (subject + body) as text templates
Render them from a model (e.g., PasswordResetModel, WelcomeUserModel, etc.)
Send them via a chosen provider
The nice part is that this text templating mechanism is generic. It is not limited to emails:
Why Not One Big Library?
I intentionally avoid a single “mega package” that does everything.
Instead:
This keeps your dependencies clean and your binaries smaller, and it avoids installing 98% of unused code just for one class. Also, because the library are very small, you can use it in Blazor WASM applications which requires binaries as small as possible for the startup of the application.
.NET Compatibility And Dependencies
All PosInformatique.Foundations packages target:
.NET 8.0
.NET 9.0
.NET 10.0
For external dependencies, I intentionally target relatively old versions (for example Microsoft.Graph) to stay compatible with more projects.
If you need newer versions in your solution, you can simply:
Add an explicit reference to the newer dependency in your application
Let NuGet resolve the latest version for that library
Still use PosInformatique.Foundations without issues
This approach keeps the libraries flexible and avoids forcing a full update of your stack.
Real-World Usage
These libraries are not theoretical. I built them to solve real problems in real applications.
PosInformatique.Foundations is currently used in the development of SaaS applications at:
Chantier Connect: A 360° application for desktop, tablet, and phone, and a kiosk to track the progress of construction sites.
Artahe Solutions: A software editor that allows the creation of activity tracking reports.
The goal is to reuse the same reliable building blocks across multiple products, rather than copy-pasting the same pieces of code again and again.
Getting Started
All packages are available on NuGet.
The full list is in the GitHub repository: PosInformatique.Foundations
From there you can:
Browse each package README
Copy installation commands
See examples, supported scenarios, and integration details
Conclusion
PosInformatique.Foundations is my attempt to provide simple, reusable .NET foundations for everyday work:
Strongly-typed value objects for email, phone numbers, names, MIME types
A clean text templating abstraction
A flexible emailing infrastructure
Small, modular packages instead of one big framework
Based on standards and compatible with .NET 8–10
If you are a .NET developer who is tired of rewriting the same value objects and basic infrastructure, I hope these libraries will save you time and bring more consistency to your projects.
If you try them, I would be happy to hear your feedback and suggestions for future improvements.
