Discover PosInformatique.Foundations 1.0.0: A Comprehensive Overview

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:

  • Email addresses: RFC 5322

  • Phone numbers: E.164

  • MIME types: IANA media types

• Integration-specific packages: instead of making the core value object depend on everything, I provide derived packages per technology:

  • DataAnnotations

  • FluentValidation

  • Entity Framework Core

  • System.Text.Json

  • etc.

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:

• FirstName and LastName value objects with normalization and validation

• Integration with:

  • DataAnnotations for ASP.NET MVC / Blazor forms

  • FluentValidation for more advanced validation rules

  • Entity Framework Core for persistence

  • System.Text.Json for serialization

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:

1. Text templating abstractions

   • Package: PosInformatique.Foundations.Text.Templating

   • Provides:

     • TextTemplate<TModel> base class

     • ITextTemplateRenderContext

   • Idea: define a clear contract for “take a model and render text”.

2. Concrete implementations

   • PosInformatique.Foundations.Text.Templating.Razor

     • Razor-based templating using Blazor components

     • Strongly-typed models

     • Full dependency injection support

   • PosInformatique.Foundations.Text.Templating.Scriban

     • Scriban-based templating with mustache-style syntax

     • Strongly-typed models mapped to template data

On top of that, there is an emailing infrastructure:

• PosInformatique.Foundations.Emailing

• Plus providers:

  • PosInformatique.Foundations.Emailing.Azure (Azure Communication Service)

  • PosInformatique.Foundations.Emailing.Graph (Microsoft Graph API)

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:

• You can reuse it to generate:

  • SMS content

  • Notifications

  • System messages

  • Any other text-based messages from a model

Why Not One Big Library?

I intentionally avoid a single “mega package” that does everything.

Instead:

• Each package has a single responsibility.

• There is no hard coupling between them (only logical relationships).

• You choose:

  • Only the value objects you need (email, phone, names, MIME types, …)

  • Only the integrations you need (EF, JSON, validation, …)

  • Only the emailing pieces you actually use.

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.